Add files using upload-large-folder tool

.gitattributes

@@ -565,3 +565,4 @@ falcon/lib/python3.10/site-packages/sklearn/cluster/_hierarchical_fast.cpython-3
 falcon/lib/python3.10/site-packages/sklearn/cluster/_k_means_minibatch.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 evalkit_tf437/lib/python3.10/site-packages/sympy/polys/matrices/__pycache__/domainmatrix.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 falcon/lib/python3.10/site-packages/sklearn/preprocessing/_csr_polynomial_expansion.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+falcon/lib/python3.10/site-packages/PIL/_imagingmath.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

falcon/lib/python3.10/site-packages/PIL/_imagingmath.cpython-310-x86_64-linux-gnu.so

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

falcon/lib/python3.10/site-packages/beautifulsoup4-4.12.3.dist-info/licenses/AUTHORS

@@ -0,0 +1,49 @@
+Behold, mortal, the origins of Beautiful Soup...
+================================================
+
+Leonard Richardson is the primary maintainer.
+
+Aaron DeVore and Isaac Muse have made significant contributions to the
+code base.
+
+Mark Pilgrim provided the encoding detection code that forms the base
+of UnicodeDammit.
+
+Thomas Kluyver and Ezio Melotti finished the work of getting Beautiful
+Soup 4 working under Python 3.
+
+Simon Willison wrote soupselect, which was used to make Beautiful Soup
+support CSS selectors. Isaac Muse wrote SoupSieve, which made it
+possible to _remove_ the CSS selector code from Beautiful Soup.
+
+Sam Ruby helped with a lot of edge cases.
+
+Jonathan Ellis was awarded the prestigious Beau Potage D'Or for his
+work in solving the nestable tags conundrum.
+
+An incomplete list of people have contributed patches to Beautiful
+Soup:
+
+ Istvan Albert, Andrew Lin, Anthony Baxter, Oliver Beattie, Andrew
+Boyko, Tony Chang, Francisco Canas, "Delong", Zephyr Fang, Fuzzy,
+Roman Gaufman, Yoni Gilad, Richie Hindle, Toshihiro Kamiya, Peteris
+Krumins, Kent Johnson, Marek Kapolka, Andreas Kostyrka, Roel Kramer,
+Ben Last, Robert Leftwich, Stefaan Lippens, "liquider", Staffan
+Malmgren, Ksenia Marasanova, JP Moins, Adam Monsen, John Nagle, "Jon",
+Ed Oskiewicz, Martijn Peters, Greg Phillips, Giles Radford, Stefano
+Revera, Arthur Rudolph, Marko Samastur, James Salter, Jouni Sepp�nen,
+Alexander Schmolck, Tim Shirley, Geoffrey Sneddon, Ville Skytt�,
+"Vikas", Jens Svalgaard, Andy Theyers, Eric Weiser, Glyn Webster, John
+Wiseman, Paul Wright, Danny Yoo
+
+An incomplete list of people who made suggestions or found bugs or
+found ways to break Beautiful Soup:
+
+ Hanno B�ck, Matteo Bertini, Chris Curvey, Simon Cusack, Bruce Eckel,
+ Matt Ernst, Michael Foord, Tom Harris, Bill de hOra, Donald Howes,
+ Matt Patterson, Scott Roberts, Steve Strassmann, Mike Williams,
+ warchild at redho dot com, Sami Kuisma, Carlos Rocha, Bob Hutchison,
+ Joren Mc, Michal Migurski, John Kleven, Tim Heaney, Tripp Lilley, Ed
+ Summers, Dennis Sutch, Chris Smith, Aaron Swartz, Stuart
+ Turner, Greg Edwards, Kevin J Kalupson, Nikos Kouremenos, Artur de
+ Sousa Rocha, Yichun Wei, Per Vognsen

falcon/lib/python3.10/site-packages/exceptiongroup/_catch.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import inspect
+import sys
+from collections.abc import Callable, Iterable, Mapping
+from contextlib import AbstractContextManager
+from types import TracebackType
+from typing import TYPE_CHECKING, Any
+
+if sys.version_info < (3, 11):
+    from ._exceptions import BaseExceptionGroup
+
+if TYPE_CHECKING:
+    _Handler = Callable[[BaseExceptionGroup[Any]], Any]
+
+
+class _Catcher:
+    def __init__(self, handler_map: Mapping[tuple[type[BaseException], ...], _Handler]):
+        self._handler_map = handler_map
+
+    def __enter__(self) -> None:
+        pass
+
+    def __exit__(
+        self,
+        etype: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> bool:
+        if exc is not None:
+            unhandled = self.handle_exception(exc)
+            if unhandled is exc:
+                return False
+            elif unhandled is None:
+                return True
+            else:
+                if isinstance(exc, BaseExceptionGroup):
+                    try:
+                        raise unhandled from exc.__cause__
+                    except BaseExceptionGroup:
+                        # Change __context__ to __cause__ because Python 3.11 does this
+                        # too
+                        unhandled.__context__ = exc.__cause__
+                        raise
+
+                raise unhandled from exc
+
+        return False
+
+    def handle_exception(self, exc: BaseException) -> BaseException | None:
+        excgroup: BaseExceptionGroup | None
+        if isinstance(exc, BaseExceptionGroup):
+            excgroup = exc
+        else:
+            excgroup = BaseExceptionGroup("", [exc])
+
+        new_exceptions: list[BaseException] = []
+        for exc_types, handler in self._handler_map.items():
+            matched, excgroup = excgroup.split(exc_types)
+            if matched:
+                try:
+                    try:
+                        raise matched
+                    except BaseExceptionGroup:
+                        result = handler(matched)
+                except BaseExceptionGroup as new_exc:
+                    if new_exc is matched:
+                        new_exceptions.append(new_exc)
+                    else:
+                        new_exceptions.extend(new_exc.exceptions)
+                except BaseException as new_exc:
+                    new_exceptions.append(new_exc)
+                else:
+                    if inspect.iscoroutine(result):
+                        raise TypeError(
+                            f"Error trying to handle {matched!r} with {handler!r}. "
+                            "Exception handler must be a sync function."
+                        ) from exc
+
+            if not excgroup:
+                break
+
+        if new_exceptions:
+            if len(new_exceptions) == 1:
+                return new_exceptions[0]
+
+            return BaseExceptionGroup("", new_exceptions)
+        elif (
+            excgroup and len(excgroup.exceptions) == 1 and excgroup.exceptions[0] is exc
+        ):
+            return exc
+        else:
+            return excgroup
+
+
+def catch(
+    __handlers: Mapping[type[BaseException] | Iterable[type[BaseException]], _Handler],
+) -> AbstractContextManager[None]:
+    if not isinstance(__handlers, Mapping):
+        raise TypeError("the argument must be a mapping")
+
+    handler_map: dict[
+        tuple[type[BaseException], ...], Callable[[BaseExceptionGroup]]
+    ] = {}
+    for type_or_iterable, handler in __handlers.items():
+        iterable: tuple[type[BaseException]]
+        if isinstance(type_or_iterable, type) and issubclass(
+            type_or_iterable, BaseException
+        ):
+            iterable = (type_or_iterable,)
+        elif isinstance(type_or_iterable, Iterable):
+            iterable = tuple(type_or_iterable)
+        else:
+            raise TypeError(
+                "each key must be either an exception classes or an iterable thereof"
+            )
+
+        if not callable(handler):
+            raise TypeError("handlers must be callable")
+
+        for exc_type in iterable:
+            if not isinstance(exc_type, type) or not issubclass(
+                exc_type, BaseException
+            ):
+                raise TypeError(
+                    "each key must be either an exception classes or an iterable "
+                    "thereof"
+                )
+
+            if issubclass(exc_type, BaseExceptionGroup):
+                raise TypeError(
+                    "catching ExceptionGroup with catch() is not allowed. "
+                    "Use except instead."
+                )
+
+        handler_map[iterable] = handler
+
+    return _Catcher(handler_map)

falcon/lib/python3.10/site-packages/exceptiongroup/_version.py

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '1.2.2'
+__version_tuple__ = version_tuple = (1, 2, 2)

falcon/lib/python3.10/site-packages/gradio/.dockerignore

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

falcon/lib/python3.10/site-packages/gradio/__init__.py

@@ -0,0 +1,97 @@
+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,
+    AnnotatedImage,
+    Annotatedimage,
+    Audio,
+    BarPlot,
+    Button,
+    Carousel,
+    Chatbot,
+    Checkbox,
+    CheckboxGroup,
+    Checkboxgroup,
+    ClearButton,
+    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.deploy_space import deploy
+from gradio.events import SelectData
+from gradio.exceptions import Error
+from gradio.external import load
+from gradio.flagging import (
+    CSVLogger,
+    FlaggingCallback,
+    HuggingFaceDatasetJSONSaver,
+    HuggingFaceDatasetSaver,
+    SimpleCSVLogger,
+)
+from gradio.helpers import EventData, Progress, make_waveform, skip, update
+from gradio.helpers import create_examples as Examples  # noqa: N812
+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

falcon/lib/python3.10/site-packages/gradio/analytics.py

@@ -0,0 +1,190 @@
+""" Functions related to analytics and telemetry. """
+from __future__ import annotations
+
+import json
+import os
+import pkgutil
+import threading
+import warnings
+from distutils.version import StrictVersion
+from typing import Any
+
+import requests
+
+import gradio
+from gradio.context import Context
+from gradio.utils import GRADIO_VERSION
+
+ANALYTICS_URL = "https://api.gradio.app/"
+PKG_VERSION_URL = "https://api.gradio.app/pkg-version"
+
+
+def analytics_enabled() -> bool:
+    """
+    Returns: True if analytics are enabled, False otherwise.
+    """
+    return os.getenv("GRADIO_ANALYTICS_ENABLED", "True") == "True"
+
+
+def _do_analytics_request(url: str, data: dict[str, Any]) -> None:
+    try:
+        requests.post(url, data=data, timeout=5)
+    except (requests.ConnectionError, requests.exceptions.ReadTimeout):
+        pass  # do not push analytics if no network
+
+
+def version_check():
+    if not analytics_enabled():
+        return
+    try:
+        version_data = pkgutil.get_data(__name__, "version.txt")
+        if not version_data:
+            raise FileNotFoundError
+        current_pkg_version = version_data.decode("ascii").strip()
+        latest_pkg_version = requests.get(url=PKG_VERSION_URL, timeout=3).json()[
+            "version"
+        ]
+        if StrictVersion(latest_pkg_version) > StrictVersion(current_pkg_version):
+            print(
+                f"IMPORTANT: You are using gradio version {current_pkg_version}, "
+                f"however version {latest_pkg_version} is available, please upgrade."
+            )
+            print("--------")
+    except json.decoder.JSONDecodeError:
+        warnings.warn("unable to parse version details from package URL.")
+    except KeyError:
+        warnings.warn("package URL does not contain version info.")
+    except Exception:
+        pass
+
+
+def get_local_ip_address() -> str:
+    """
+    Gets the public IP address or returns the string "No internet connection" if unable
+    to obtain it or the string "Analytics disabled" if a user has disabled analytics.
+    Does not make a new request if the IP address has already been obtained in the
+    same Python session.
+    """
+    if not analytics_enabled():
+        return "Analytics disabled"
+
+    if Context.ip_address is None:
+        try:
+            ip_address = requests.get(
+                "https://checkip.amazonaws.com/", timeout=3
+            ).text.strip()
+        except (requests.ConnectionError, requests.exceptions.ReadTimeout):
+            ip_address = "No internet connection"
+        Context.ip_address = ip_address
+    else:
+        ip_address = Context.ip_address
+    return ip_address
+
+
+def initiated_analytics(data: dict[str, Any]) -> None:
+    if not analytics_enabled():
+        return
+
+    threading.Thread(
+        target=_do_analytics_request,
+        kwargs={
+            "url": f"{ANALYTICS_URL}gradio-initiated-analytics/",
+            "data": {**data, "ip_address": get_local_ip_address()},
+        },
+    ).start()
+
+
+def launched_analytics(blocks: gradio.Blocks, data: dict[str, Any]) -> None:
+    if not analytics_enabled():
+        return
+
+    blocks_telemetry, inputs_telemetry, outputs_telemetry, targets_telemetry = (
+        [],
+        [],
+        [],
+        [],
+    )
+
+    from gradio.blocks import BlockContext
+
+    for x in list(blocks.blocks.values()):
+        blocks_telemetry.append(x.get_block_name()) if isinstance(
+            x, BlockContext
+        ) else blocks_telemetry.append(str(x))
+
+    for x in blocks.dependencies:
+        targets_telemetry = targets_telemetry + [
+            # Sometimes the target can be the Blocks object itself, so we need to check if its in blocks.blocks
+            str(blocks.blocks[y])
+            for y in x["targets"]
+            if y in blocks.blocks
+        ]
+        inputs_telemetry = inputs_telemetry + [
+            str(blocks.blocks[y]) for y in x["inputs"]
+        ]
+        outputs_telemetry = outputs_telemetry + [
+            str(blocks.blocks[y]) for y in x["outputs"]
+        ]
+    additional_data = {
+        "version": GRADIO_VERSION,
+        "is_kaggle": blocks.is_kaggle,
+        "is_sagemaker": blocks.is_sagemaker,
+        "using_auth": blocks.auth is not None,
+        "dev_mode": blocks.dev_mode,
+        "show_api": blocks.show_api,
+        "show_error": blocks.show_error,
+        "title": blocks.title,
+        "inputs": blocks.input_components
+        if blocks.mode == "interface"
+        else inputs_telemetry,
+        "outputs": blocks.output_components
+        if blocks.mode == "interface"
+        else outputs_telemetry,
+        "targets": targets_telemetry,
+        "blocks": blocks_telemetry,
+        "events": [str(x["trigger"]) for x in blocks.dependencies],
+    }
+
+    data.update(additional_data)
+    data.update({"ip_address": get_local_ip_address()})
+
+    threading.Thread(
+        target=_do_analytics_request,
+        kwargs={
+            "url": f"{ANALYTICS_URL}gradio-launched-telemetry/",
+            "data": data,
+        },
+    ).start()
+
+
+def integration_analytics(data: dict[str, Any]) -> None:
+    if not analytics_enabled():
+        return
+
+    threading.Thread(
+        target=_do_analytics_request,
+        kwargs={
+            "url": f"{ANALYTICS_URL}gradio-integration-analytics/",
+            "data": {**data, "ip_address": get_local_ip_address()},
+        },
+    ).start()
+
+
+def error_analytics(message: str) -> None:
+    """
+    Send error analytics if there is network
+    Parameters:
+        message: Details about error
+    """
+    if not analytics_enabled():
+        return
+
+    data = {"ip_address": get_local_ip_address(), "error": message}
+
+    threading.Thread(
+        target=_do_analytics_request,
+        kwargs={
+            "url": f"{ANALYTICS_URL}gradio-error-analytics/",
+            "data": data,
+        },
+    ).start()

falcon/lib/python3.10/site-packages/gradio/cli.py

@@ -0,0 +1,14 @@
+import sys
+
+import gradio.deploy_space
+import gradio.reload
+
+
+def cli():
+    args = sys.argv[1:]
+    if len(args) == 0:
+        raise ValueError("No file specified.")
+    if args[0] == "deploy":
+        gradio.deploy_space.deploy()
+    else:
+        gradio.reload.main()

falcon/lib/python3.10/site-packages/gradio/context.py

@@ -0,0 +1,16 @@
+# 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.
+    hf_token: str | None = None  # The token provided when loading private HF repos

falcon/lib/python3.10/site-packages/gradio/deploy_space.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import argparse
+import os
+import re
+
+import huggingface_hub
+
+import gradio as gr
+
+repo_directory = os.getcwd()
+readme_file = os.path.join(repo_directory, "README.md")
+github_action_template = os.path.join(
+    os.path.dirname(__file__), "deploy_space_action.yaml"
+)
+
+
+def add_configuration_to_readme(
+    title: str | None,
+    app_file: str | None,
+) -> dict:
+    configuration = {}
+
+    dir_name = os.path.basename(repo_directory)
+    if title is None:
+        title = input(f"Enter Spaces app title [{dir_name}]: ") or dir_name
+    formatted_title = format_title(title)
+    if formatted_title != title:
+        print(f"Formatted to {formatted_title}. ")
+    configuration["title"] = formatted_title
+
+    if app_file is None:
+        for file in os.listdir(repo_directory):
+            file_path = os.path.join(repo_directory, file)
+            if not os.path.isfile(file_path) or not file.endswith(".py"):
+                continue
+
+            with open(file_path, encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+                if "import gradio" in content:
+                    app_file = file
+                    break
+
+        app_file = (
+            input(f"Enter Gradio app file {f'[{app_file}]' if app_file else ''}: ")
+            or app_file
+        )
+    if not app_file or not os.path.exists(app_file):
+        raise FileNotFoundError("Failed to find Gradio app file.")
+    configuration["app_file"] = app_file
+
+    configuration["sdk"] = "gradio"
+    configuration["sdk_version"] = gr.__version__
+    huggingface_hub.metadata_save(readme_file, configuration)
+
+    configuration["hardware"] = (
+        input(
+            f"Enter Spaces hardware ({', '.join(hardware.value for hardware in huggingface_hub.SpaceHardware)}) [cpu-basic]: "
+        )
+        or "cpu-basic"
+    )
+
+    secrets = {}
+    if input("Any Spaces secrets (y/n) [n]: ") == "y":
+        while True:
+            secret_name = input("Enter secret name (leave blank to end): ")
+            if not secret_name:
+                break
+            secret_value = input(f"Enter secret value for {secret_name}: ")
+            secrets[secret_name] = secret_value
+    configuration["secrets"] = secrets
+
+    requirements_file = os.path.join(repo_directory, "requirements.txt")
+    if (
+        not os.path.exists(requirements_file)
+        and input("Create requirements.txt file? (y/n) [n]: ").lower() == "y"
+    ):
+        while True:
+            requirement = input("Enter a dependency (leave blank to end): ")
+            if not requirement:
+                break
+            with open(requirements_file, "a") as f:
+                f.write(requirement + "\n")
+
+    if (
+        input(
+            "Create Github Action to automatically update Space on 'git push'? [n]: "
+        ).lower()
+        == "y"
+    ):
+        track_branch = input("Enter branch to track [main]: ") or "main"
+        github_action_file = os.path.join(
+            repo_directory, ".github/workflows/update_space.yml"
+        )
+        os.makedirs(os.path.dirname(github_action_file), exist_ok=True)
+        with open(github_action_template) as f:
+            github_action_content = f.read()
+        github_action_content = github_action_content.replace("$branch", track_branch)
+        with open(github_action_file, "w") as f:
+            f.write(github_action_content)
+
+        print(
+            "Github Action created. Add your Hugging Face write token (from https://huggingface.co/settings/tokens) as an Actions Secret named 'hf_token' to your GitHub repository. This can be set in your repository's settings page."
+        )
+
+    return configuration
+
+
+def format_title(title: str):
+    title = title.replace(" ", "_")
+    title = re.sub(r"[^a-zA-Z0-9\-._]", "", title)
+    title = re.sub("-+", "-", title)
+    while title.startswith("."):
+        title = title[1:]
+    return title
+
+
+def deploy():
+    if (
+        os.getenv("SYSTEM") == "spaces"
+    ):  # in case a repo with this function is uploaded to spaces
+        return
+    parser = argparse.ArgumentParser(description="Deploy to Spaces")
+    parser.add_argument("deploy")
+    parser.add_argument("--title", type=str, help="Spaces app title")
+    parser.add_argument("--app-file", type=str, help="File containing the Gradio app")
+
+    args = parser.parse_args()
+
+    hf_api = huggingface_hub.HfApi()
+    whoami = None
+    login = False
+    try:
+        whoami = hf_api.whoami()
+        if whoami["auth"]["accessToken"]["role"] != "write":
+            login = True
+    except OSError:
+        login = True
+    if login:
+        print("Need 'write' access token to create a Spaces repo.")
+        huggingface_hub.login(add_to_git_credential=False)
+        whoami = hf_api.whoami()
+
+    configuration: None | dict = None
+    if os.path.exists(readme_file):
+        try:
+            configuration = huggingface_hub.metadata_load(readme_file)
+        except ValueError:
+            pass
+
+    if configuration is None:
+        print(
+            f"Creating new Spaces Repo in '{repo_directory}'. Collecting metadata, press Enter to accept default value."
+        )
+        configuration = add_configuration_to_readme(
+            args.title,
+            args.app_file,
+        )
+
+    space_id = huggingface_hub.create_repo(
+        configuration["title"],
+        space_sdk="gradio",
+        repo_type="space",
+        exist_ok=True,
+        space_hardware=configuration.get("hardware"),
+    ).repo_id
+    hf_api.upload_folder(
+        repo_id=space_id,
+        repo_type="space",
+        folder_path=repo_directory,
+    )
+    if configuration.get("secrets"):
+        for secret_name, secret_value in configuration["secrets"].items():
+            huggingface_hub.add_space_secret(space_id, secret_name, secret_value)
+    print(f"Space available at https://huggingface.co/spaces/{space_id}")

falcon/lib/python3.10/site-packages/gradio/deprecation.py

@@ -0,0 +1,46 @@
+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, *, stacklevel: int = 2, 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, stacklevel=stacklevel)
+
+    if kwargs:
+        warnings.warn(
+            f"You have unused kwarg parameters in {cls}, please remove them: {kwargs}",
+            stacklevel=stacklevel,
+        )

falcon/lib/python3.10/site-packages/gradio/events.py

@@ -0,0 +1,351 @@
+"""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, Literal
+
+from gradio_client.documentation import document, set_documentation_group
+
+from gradio.blocks import Block
+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
+
+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: Literal["full"]
+        | Literal["minimal"]
+        | Literal["hidden"] = "full",
+        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: None = None,
+        scroll_to_output: bool = False,
+        show_progress: Literal["full"]
+        | Literal["minimal"]
+        | Literal["hidden"] = "full",
+        queue: bool | None = None,
+        batch: bool = False,
+        max_batch_size: int = 4,
+        preprocess: bool = True,
+        postprocess: bool = True,
+        cancels: dict[str, Any] | list[dict[str, Any]] | None = None,
+        every: 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 has been enabled. If False, will not put this event on the queue, even if the queue has been enabled. If None, will use the queue setting of the gradio app.
+            batch: If True, then the function should process a batch of inputs, meaning that it should accept a list of input values for each parameter. The lists should be of equal length (and be up to length `max_batch_size`). The function is then *required* to return a tuple of lists (even if there is only 1 output component), with each list in the tuple corresponding to one output component.
+            max_batch_size: Maximum number of inputs to batch together if this is called from the queue (only relevant if batch=True)
+            preprocess: If False, will not run preprocessing of component data before running 'fn' (e.g. leaving it as a base64 string if this method is called with the `Image` component).
+            postprocess: If False, will not run postprocessing of component data before returning 'fn' output to the browser.
+            cancels: A list of other events to cancel when This listener is triggered. For example, setting cancels=[click_event] will cancel the click_event, where click_event is the return value of another components .click method. Functions that have not yet run (or generators that are iterating) will be cancelled, but functions that are currently running will be allowed to finish.
+            every: Run this event 'every' number of seconds while the client connection is open. Interpreted in seconds. Queue must be enabled.
+        """
+        if status_tracker:
+            warnings.warn(
+                "The 'status_tracker' parameter has been deprecated and has no effect."
+            )
+        if self.event_name == "stop":
+            warnings.warn(
+                "The `stop` event on Video and Audio has been deprecated and will be remove in a future version. Use `ended` instead."
+            )
+
+        if isinstance(self, Streamable):
+            self.check_streamable()
+        if isinstance(show_progress, bool):
+            show_progress = "full" if show_progress else "hidden"
+
+        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 listener is triggered when the component's value changes either because of user input (e.g. a user types in a textbox) OR because of a function update (e.g. an image receives a value from the output of an event trigger).
+        See `.input()` for a listener that is only triggered by user input.
+        This method can be used when this component is in a Gradio Blocks.
+        """
+
+
+@document("*input", inherit=True)
+class Inputable(EventListener):
+    def __init__(self):
+        self.input = EventListenerMethod(self, "input")
+        """
+        This listener is triggered when the user changes the value of the component.
+        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 listener 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 listener 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 listener 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 listener 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 listener 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 listener is triggered when the media stops playing for any reason (e.g. audio or video).
+        This method can be used when this component is in a Gradio Blocks.
+        """
+
+        self.stop = EventListenerMethod(self, "stop")
+        """
+        This listener is triggered when the user reaches the end of the media track (e.g. audio or video).
+        This method can be used when this component is in a Gradio Blocks.
+        """
+
+        self.end = EventListenerMethod(self, "end")
+        """
+        This listener is triggered when the user reaches the end of the media track (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="hidden",
+            callback=lambda: setattr(self, "streaming", True),
+        )
+        """
+        This listener 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.
+        """
+
+    def check_streamable(self):
+        pass
+
+
+@document("*start_recording", "*stop_recording", inherit=True)
+class Recordable(EventListener):
+    def __init__(self):
+        self.start_recording = EventListenerMethod(self, "start_recording")
+        """
+        This listener is triggered when the user starts recording with the component (e.g. audio or video).
+        This method can be used when this component is in a Gradio Blocks.
+        """
+
+        self.stop_recording = EventListenerMethod(self, "stop_recording")
+        """
+        This listener is triggered when the user stops recording with the component (e.g. audio or video).
+        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 listener 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 listener 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 listener 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 listener 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.
+        """

falcon/lib/python3.10/site-packages/gradio/exceptions.py

@@ -0,0 +1,42 @@
+from gradio_client.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 InvalidApiNameError(ValueError):
+    pass
+
+
+InvalidApiName = InvalidApiNameError  # backwards compatibility
+
+
+@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)

falcon/lib/python3.10/site-packages/gradio/external_utils.py

@@ -0,0 +1,140 @@
+"""Utility function for gradio/external.py"""
+
+import base64
+import math
+import operator
+import re
+import warnings
+from typing import Dict, List, Tuple
+
+import requests
+import yaml
+
+from gradio import components
+
+##################
+# 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:
+                data = r.json()[0]
+                content_type = data["content-type"]
+                base64_repr = data["blob"]
+            except KeyError as ke:
+                raise ValueError(
+                    "Cannot determine content type returned by external API."
+                ) from ke
+        # Case 3: the data prefix is included in the response headers
+        else:
+            pass
+        new_base64 = f"data:{content_type};base64,{base64_repr}"
+        return new_base64
+
+
+##################
+# 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

falcon/lib/python3.10/site-packages/gradio/flagging.py

@@ -0,0 +1,518 @@
+from __future__ import annotations
+
+import csv
+import datetime
+import json
+import os
+import time
+import uuid
+import warnings
+from abc import ABC, abstractmethod
+from collections import OrderedDict
+from distutils.version import StrictVersion
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import filelock
+import huggingface_hub
+import pkg_resources
+from gradio_client import utils as client_utils
+from gradio_client.documentation import document, set_documentation_group
+
+import gradio as gr
+from gradio import utils
+
+if TYPE_CHECKING:
+    from gradio.components import IOComponent
+
+set_documentation_group("flagging")
+
+
+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
+            ) / client_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) as csvfile:
+            line_count = len(list(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
+            ) / client_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, encoding="utf-8") as csvfile:
+            line_count = len(list(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,
+        info_filename: str = "dataset_info.json",
+        separate_dirs: bool = False,
+        verbose: bool = True,  # silently ignored. TODO: remove it?
+    ):
+        """
+        Parameters:
+            hf_token: The HuggingFace token to use to create (and write the flagged sample to) the HuggingFace dataset (defaults to the registered one).
+            dataset_name: The repo_id of the dataset to save the data to, e.g. "image-classifier-1" or "username/image-classifier-1".
+            organization: Deprecated argument. Please pass a full dataset id (e.g. 'username/dataset_name') to `dataset_name` instead.
+            private: Whether the dataset should be private (defaults to False).
+            info_filename: The name of the file to save the dataset info (defaults to "dataset_infos.json").
+            separate_dirs: If True, each flagged item will be saved in a separate directory. This makes the flagging more robust to concurrent editing, but may be less convenient to use.
+        """
+        if organization is not None:
+            warnings.warn(
+                "Parameter `organization` is not used anymore. Please pass a full dataset id (e.g. 'username/dataset_name') to `dataset_name` instead."
+            )
+        self.hf_token = hf_token
+        self.dataset_id = dataset_name  # TODO: rename parameter (but ensure backward compatibility somehow)
+        self.dataset_private = private
+        self.info_filename = info_filename
+        self.separate_dirs = separate_dirs
+
+    def setup(self, components: list[IOComponent], flagging_dir: str):
+        """
+        Params:
+        flagging_dir (str): local directory where the dataset is cloned,
+        updated, and pushed from.
+        """
+        hh_version = pkg_resources.get_distribution("huggingface_hub").version
+        try:
+            if StrictVersion(hh_version) < StrictVersion("0.12.0"):
+                raise ImportError(
+                    "The `huggingface_hub` package must be version 0.12.0 or higher"
+                    "for HuggingFaceDatasetSaver. Try 'pip install huggingface_hub --upgrade'."
+                )
+        except ValueError:
+            pass
+
+        # Setup dataset on the Hub
+        self.dataset_id = huggingface_hub.create_repo(
+            repo_id=self.dataset_id,
+            token=self.hf_token,
+            private=self.dataset_private,
+            repo_type="dataset",
+            exist_ok=True,
+        ).repo_id
+
+        # Setup flagging dir
+        self.components = components
+        self.dataset_dir = (
+            Path(flagging_dir).absolute() / self.dataset_id.split("/")[-1]
+        )
+        self.dataset_dir.mkdir(parents=True, exist_ok=True)
+        self.infos_file = self.dataset_dir / self.info_filename
+
+        # Download remote files to local
+        remote_files = [self.info_filename]
+        if not self.separate_dirs:
+            # No separate dirs => means all data is in the same CSV file => download it to get its current content
+            remote_files.append("data.csv")
+
+        for filename in remote_files:
+            try:
+                huggingface_hub.hf_hub_download(
+                    repo_id=self.dataset_id,
+                    repo_type="dataset",
+                    filename=filename,
+                    local_dir=self.dataset_dir,
+                    token=self.hf_token,
+                )
+            except huggingface_hub.utils.EntryNotFoundError:
+                pass
+
+    def flag(
+        self,
+        flag_data: list[Any],
+        flag_option: str = "",
+        username: str | None = None,
+    ) -> int:
+        if self.separate_dirs:
+            # JSONL files to support dataset preview on the Hub
+            unique_id = str(uuid.uuid4())
+            components_dir = self.dataset_dir / str(uuid.uuid4())
+            data_file = components_dir / "metadata.jsonl"
+            path_in_repo = unique_id  # upload in sub folder (safer for concurrency)
+        else:
+            # Unique CSV file
+            components_dir = self.dataset_dir
+            data_file = components_dir / "data.csv"
+            path_in_repo = None  # upload at root level
+
+        return self._flag_in_dir(
+            data_file=data_file,
+            components_dir=components_dir,
+            path_in_repo=path_in_repo,
+            flag_data=flag_data,
+            flag_option=flag_option,
+            username=username or "",
+        )
+
+    def _flag_in_dir(
+        self,
+        data_file: Path,
+        components_dir: Path,
+        path_in_repo: str | None,
+        flag_data: list[Any],
+        flag_option: str = "",
+        username: str = "",
+    ) -> int:
+        # Deserialize components (write images/audio to files)
+        features, row = self._deserialize_components(
+            components_dir, flag_data, flag_option, username
+        )
+
+        # Write generic info to dataset_infos.json + upload
+        with filelock.FileLock(str(self.infos_file) + ".lock"):
+            if not self.infos_file.exists():
+                self.infos_file.write_text(
+                    json.dumps({"flagged": {"features": features}})
+                )
+
+                huggingface_hub.upload_file(
+                    repo_id=self.dataset_id,
+                    repo_type="dataset",
+                    token=self.hf_token,
+                    path_in_repo=self.infos_file.name,
+                    path_or_fileobj=self.infos_file,
+                )
+
+        headers = list(features.keys())
+
+        if not self.separate_dirs:
+            with filelock.FileLock(components_dir / ".lock"):
+                sample_nb = self._save_as_csv(data_file, headers=headers, row=row)
+                sample_name = str(sample_nb)
+                huggingface_hub.upload_folder(
+                    repo_id=self.dataset_id,
+                    repo_type="dataset",
+                    commit_message=f"Flagged sample #{sample_name}",
+                    path_in_repo=path_in_repo,
+                    ignore_patterns="*.lock",
+                    folder_path=components_dir,
+                    token=self.hf_token,
+                )
+        else:
+            sample_name = self._save_as_jsonl(data_file, headers=headers, row=row)
+            sample_nb = len(
+                [path for path in self.dataset_dir.iterdir() if path.is_dir()]
+            )
+            huggingface_hub.upload_folder(
+                repo_id=self.dataset_id,
+                repo_type="dataset",
+                commit_message=f"Flagged sample #{sample_name}",
+                path_in_repo=path_in_repo,
+                ignore_patterns="*.lock",
+                folder_path=components_dir,
+                token=self.hf_token,
+            )
+
+        return sample_nb
+
+    @staticmethod
+    def _save_as_csv(data_file: Path, headers: list[str], row: list[Any]) -> int:
+        """Save data as CSV and return the sample name (row number)."""
+        is_new = not data_file.exists()
+
+        with data_file.open("a", newline="", encoding="utf-8") as csvfile:
+            writer = csv.writer(csvfile)
+
+            # Write CSV headers if new file
+            if is_new:
+                writer.writerow(utils.sanitize_list_for_csv(headers))
+
+            # Write CSV row for flagged sample
+            writer.writerow(utils.sanitize_list_for_csv(row))
+
+        with data_file.open(encoding="utf-8") as csvfile:
+            return sum(1 for _ in csv.reader(csvfile)) - 1
+
+    @staticmethod
+    def _save_as_jsonl(data_file: Path, headers: list[str], row: list[Any]) -> str:
+        """Save data as JSONL and return the sample name (uuid)."""
+        Path.mkdir(data_file.parent, parents=True, exist_ok=True)
+        with open(data_file, "w") as f:
+            json.dump(dict(zip(headers, row)), f)
+        return data_file.parent.name
+
+    def _deserialize_components(
+        self,
+        data_dir: Path,
+        flag_data: list[Any],
+        flag_option: str = "",
+        username: str = "",
+    ) -> tuple[dict[Any, Any], list[Any]]:
+        """Deserialize components and return the corresponding row for the flagged sample.
+
+        Images/audio are saved to disk as individual files.
+        """
+        # Components that can have a preview on dataset repos
+        file_preview_types = {gr.Audio: "Audio", gr.Image: "Image"}
+
+        # Generate the row corresponding to the flagged sample
+        features = OrderedDict()
+        row = []
+        for component, sample in zip(self.components, flag_data):
+            # Get deserialized object (will save sample to disk if applicable -file, audio, image,...-)
+            label = component.label or ""
+            save_dir = data_dir / client_utils.strip_invalid_filename_characters(label)
+            deserialized = component.deserialize(sample, save_dir, None)
+
+            # Add deserialized object to row
+            features[label] = {"dtype": "string", "_type": "Value"}
+            try:
+                assert Path(deserialized).exists()
+                row.append(Path(deserialized).name)
+            except (AssertionError, TypeError, ValueError):
+                row.append(str(deserialized))
+
+            # If component is eligible for a preview, add the URL of the file
+            if isinstance(component, tuple(file_preview_types)):  # type: ignore
+                for _component, _type in file_preview_types.items():
+                    if isinstance(component, _component):
+                        features[label + " file"] = {"_type": _type}
+                        break
+                path_in_repo = str(  # returned filepath is absolute, we want it relative to compute URL
+                    Path(deserialized).relative_to(self.dataset_dir)
+                ).replace(
+                    "\\", "/"
+                )
+                row.append(
+                    huggingface_hub.hf_hub_url(
+                        repo_id=self.dataset_id,
+                        filename=path_in_repo,
+                        repo_type="dataset",
+                    )
+                )
+        features["flag"] = {"dtype": "string", "_type": "Value"}
+        features["username"] = {"dtype": "string", "_type": "Value"}
+        row.append(flag_option)
+        row.append(username)
+        return features, row
+
+
+class HuggingFaceDatasetJSONSaver(HuggingFaceDatasetSaver):
+    def __init__(
+        self,
+        hf_token: str,
+        dataset_name: str,
+        organization: str | None = None,
+        private: bool = False,
+        info_filename: str = "dataset_info.json",
+        verbose: bool = True,  # silently ignored. TODO: remove it?
+    ):
+        warnings.warn(
+            "Callback `HuggingFaceDatasetJSONSaver` is deprecated in favor of using"
+            " `HuggingFaceDatasetSaver` and passing `separate_dirs=True` as parameter."
+        )
+        super().__init__(
+            hf_token=hf_token,
+            dataset_name=dataset_name,
+            organization=organization,
+            private=private,
+            info_filename=info_filename,
+            separate_dirs=True,
+        )
+
+
+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, request: gr.Request, *flag_data):
+        try:
+            self.flagging_callback.flag(
+                list(flag_data), flag_option=self.value, username=request.username
+            )
+        except Exception as e:
+            print(f"Error while flagging: {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)

falcon/lib/python3.10/site-packages/gradio/interface.py

@@ -0,0 +1,899 @@
+"""
+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 warnings
+import weakref
+from typing import TYPE_CHECKING, Any, Callable
+
+from gradio_client.documentation import document, set_documentation_group
+
+from gradio import Examples, analytics, external, interpretation, utils
+from gradio.blocks import Blocks
+from gradio.components import (
+    Button,
+    ClearButton,
+    Interpretation,
+    IOComponent,
+    Markdown,
+    State,
+    get_component_instance,
+)
+from gradio.data_classes import InterfaceTypes
+from gradio.events import Changeable, Streamable, Submittable
+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
+
+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,
+    ) -> Blocks:
+        """
+        Warning: this method will be deprecated. Use the equivalent `gradio.load()` instead. This is a class
+        method that constructs a Blocks 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. Warning: only provide this if you are loading a trusted private Space as it can be read by the Space you are loading.
+            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
+        """
+        warnings.warn("gr.Interface.load() will be deprecated. Use gr.load() instead.")
+        return external.load(
+            name=name, src=src, hf_token=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 | str | 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  # type: ignore
+        ]
+        self.output_components = [
+            get_component_instance(o, render=False) for o in outputs  # type: ignore
+        ]
+
+        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)
+                if o.interactive is None:
+                    # Unless explicitly otherwise specified, force output components to
+                    # be non-interactive
+                    o.interactive = False
+        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
+
+        md = utils.get_markdown_parser()
+        simple_description: str | None = None
+        if description is not None:
+            description = md.render(description)
+            simple_description = utils.remove_html_tags(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.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
+        analytics.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 = f"output {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(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(
+                f"<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,
+        ClearButton | 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 = ClearButton()
+                    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
+                        ) or inspect.isasyncgenfunction(self.fn):
+                            stop_btn = Button("Stop", variant="stop", visible=False)
+                elif self.interface_type == InterfaceTypes.UNIFIED:
+                    clear_btn = ClearButton()
+                    submit_btn = Button("Submit", variant="primary")
+                    if (
+                        inspect.isgeneratorfunction(self.fn)
+                        or inspect.isasyncgenfunction(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, ClearButton | 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 = ClearButton()
+                    submit_btn = Button("Generate", variant="primary")
+                    if (
+                        inspect.isgeneratorfunction(self.fn)
+                        or inspect.isasyncgenfunction(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 = []
+
+            triggers = [submit_btn.click] + [
+                component.submit
+                for component in self.input_components
+                if isinstance(component, Submittable)
+            ]
+            predict_events = []
+
+            if stop_btn:
+                # Wrap the original function to show/hide the "Stop" button
+                async 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
+
+                    if inspect.isasyncgenfunction(self.fn):
+                        iterator = self.fn(*args)
+                    else:
+                        iterator = utils.SyncToAsyncIterator(
+                            self.fn(*args), limiter=self.limiter
+                        )
+                    async for output in iterator:
+                        yield output
+
+                extra_output = [submit_btn, stop_btn]
+
+                def cleanup():
+                    return [Button.update(visible=True), Button.update(visible=False)]
+
+                for i, trigger in enumerate(triggers):
+                    predict_event = trigger(
+                        lambda: (
+                            submit_btn.update(visible=False),
+                            stop_btn.update(visible=True),
+                        ),
+                        inputs=None,
+                        outputs=[submit_btn, stop_btn],
+                        queue=False,
+                    ).then(
+                        fn,
+                        self.input_components,
+                        self.output_components,
+                        api_name="predict" if i == 0 else None,
+                        scroll_to_output=True,
+                        preprocess=not (self.api_mode),
+                        postprocess=not (self.api_mode),
+                        batch=self.batch,
+                        max_batch_size=self.max_batch_size,
+                    )
+                    predict_events.append(predict_event)
+
+                    predict_event.then(
+                        cleanup,
+                        inputs=None,
+                        outputs=extra_output,  # type: ignore
+                        queue=False,
+                    )
+
+                stop_btn.click(
+                    cleanup,
+                    inputs=None,
+                    outputs=[submit_btn, stop_btn],
+                    cancels=predict_events,
+                    queue=False,
+                )
+            else:
+                for i, trigger in enumerate(triggers):
+                    predict_events.append(
+                        trigger(
+                            fn,
+                            self.input_components,
+                            self.output_components,
+                            api_name="predict" if i == 0 else None,
+                            scroll_to_output=True,
+                            preprocess=not (self.api_mode),
+                            postprocess=not (self.api_mode),
+                            batch=self.batch,
+                            max_batch_size=self.max_batch_size,
+                        )
+                    )
+
+    def attach_clear_events(
+        self,
+        clear_btn: ClearButton,
+        input_component_column: Column | None,
+        interpret_component_column: Column | None,
+    ):
+        clear_btn.add(self.input_components + self.output_components)
+        clear_btn.click(
+            None,
+            [],
+            (
+                ([input_component_column] if input_component_column else [])
+                + ([interpret_component_column] if self.interpretation else [])
+            ),  # type: ignore
+            _js=f"""() => {json.dumps(
+                (
+                    [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: ClearButton
+    ):
+        if not (
+            flag_btns
+            and self.interface_type
+            in (
+                InterfaceTypes.STANDARD,
+                InterfaceTypes.OUTPUT_ONLY,
+                InterfaceTypes.UNIFIED,
+            )
+        ):
+            return
+
+        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 += f"\n{'-' * len(repr)}"
+        repr += "\ninputs:"
+        for component in self.input_components:
+            repr += f"\n|-{component}"
+        repr += "\noutputs:"
+        for component in self.output_components:
+            repr += f"\n|-{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 = [f"Tab {i}" for i in range(len(interface_list))]
+        with self:
+            if title:
+                Markdown(
+                    f"<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)

falcon/lib/python3.10/site-packages/gradio/interpretation.py

@@ -0,0 +1,328 @@
+"""Contains classes and methods related to interpretation for components in Gradio."""
+
+from __future__ import annotations
+
+import copy
+import math
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+from gradio_client import utils as client_utils
+
+from gradio import components
+
+if TYPE_CHECKING:  # Only import for type checking (is False at runtime).
+    from gradio import Interface
+
+
+class Interpretable(ABC):  # noqa: B024
+    def __init__(self) -> None:
+        self.set_interpret_parameters()
+
+    def set_interpret_parameters(self):  # noqa: B027
+        """
+        Set any parameters for interpretation. Properties can be set here to be
+        used in get_interpretation_neighbors and get_interpretation_scores.
+        """
+        pass
+
+    def get_interpretation_scores(
+        self, x: Any, neighbors: list[Any] | None, scores: list[float], **kwargs
+    ) -> list:
+        """
+        Arrange the output values from the neighbors into interpretation scores for the interface to render.
+        Parameters:
+            x: Input to interface
+            neighbors: Neighboring values to input x used for interpretation.
+            scores: Output value corresponding to each neighbor in neighbors
+        Returns:
+            Arrangement of interpretation scores for interfaces to render.
+        """
+        return scores
+
+
+class TokenInterpretable(Interpretable, ABC):
+    @abstractmethod
+    def tokenize(self, x: Any) -> tuple[list, list, None]:
+        """
+        Interprets an input data point x by splitting it into a list of tokens (e.g
+        a string into words or an image into super-pixels).
+        """
+        return [], [], None
+
+    @abstractmethod
+    def get_masked_inputs(self, tokens: list, binary_mask_matrix: list[list]) -> list:
+        return []
+
+
+class NeighborInterpretable(Interpretable, ABC):
+    @abstractmethod
+    def get_interpretation_neighbors(self, x: Any) -> tuple[list, dict]:
+        """
+        Generates values similar to input to be used to interpret the significance of the input in the final output.
+        Parameters:
+            x: Input to interface
+        Returns: (neighbor_values, interpret_kwargs, interpret_by_removal)
+            neighbor_values: Neighboring values to input x to compute for interpretation
+            interpret_kwargs: Keyword arguments to be passed to get_interpretation_scores
+        """
+        return [], {}
+
+
+async def run_interpret(interface: Interface, raw_input: list):
+    """
+    Runs the interpretation command for the machine learning model. Handles both the "default" out-of-the-box
+    interpretation for a certain set of UI component types, as well as the custom interpretation case.
+    Parameters:
+    raw_input: a list of raw inputs to apply the interpretation(s) on.
+    """
+    if isinstance(interface.interpretation, list):  # Either "default" or "shap"
+        processed_input = [
+            input_component.preprocess(raw_input[i])
+            for i, input_component in enumerate(interface.input_components)
+        ]
+        original_output = await interface.call_function(0, processed_input)
+        original_output = original_output["prediction"]
+
+        if len(interface.output_components) == 1:
+            original_output = [original_output]
+
+        scores, alternative_outputs = [], []
+
+        for i, (x, interp) in enumerate(zip(raw_input, interface.interpretation)):
+            if interp == "default":
+                input_component = interface.input_components[i]
+                neighbor_raw_input = list(raw_input)
+                if isinstance(input_component, TokenInterpretable):
+                    tokens, neighbor_values, masks = input_component.tokenize(x)
+                    interface_scores = []
+                    alternative_output = []
+                    for neighbor_input in neighbor_values:
+                        neighbor_raw_input[i] = neighbor_input
+                        processed_neighbor_input = [
+                            input_component.preprocess(neighbor_raw_input[i])
+                            for i, input_component in enumerate(
+                                interface.input_components
+                            )
+                        ]
+
+                        neighbor_output = await interface.call_function(
+                            0, processed_neighbor_input
+                        )
+                        neighbor_output = neighbor_output["prediction"]
+                        if len(interface.output_components) == 1:
+                            neighbor_output = [neighbor_output]
+                        processed_neighbor_output = [
+                            output_component.postprocess(neighbor_output[i])
+                            for i, output_component in enumerate(
+                                interface.output_components
+                            )
+                        ]
+
+                        alternative_output.append(processed_neighbor_output)
+                        interface_scores.append(
+                            quantify_difference_in_label(
+                                interface, original_output, neighbor_output
+                            )
+                        )
+                    alternative_outputs.append(alternative_output)
+                    scores.append(
+                        input_component.get_interpretation_scores(
+                            raw_input[i],
+                            neighbor_values,
+                            interface_scores,
+                            masks=masks,
+                            tokens=tokens,
+                        )
+                    )
+                elif isinstance(input_component, NeighborInterpretable):
+                    (
+                        neighbor_values,
+                        interpret_kwargs,
+                    ) = input_component.get_interpretation_neighbors(
+                        x
+                    )  # type: ignore
+                    interface_scores = []
+                    alternative_output = []
+                    for neighbor_input in neighbor_values:
+                        neighbor_raw_input[i] = neighbor_input
+                        processed_neighbor_input = [
+                            input_component.preprocess(neighbor_raw_input[i])
+                            for i, input_component in enumerate(
+                                interface.input_components
+                            )
+                        ]
+                        neighbor_output = await interface.call_function(
+                            0, processed_neighbor_input
+                        )
+                        neighbor_output = neighbor_output["prediction"]
+                        if len(interface.output_components) == 1:
+                            neighbor_output = [neighbor_output]
+                        processed_neighbor_output = [
+                            output_component.postprocess(neighbor_output[i])
+                            for i, output_component in enumerate(
+                                interface.output_components
+                            )
+                        ]
+
+                        alternative_output.append(processed_neighbor_output)
+                        interface_scores.append(
+                            quantify_difference_in_label(
+                                interface, original_output, neighbor_output
+                            )
+                        )
+                    alternative_outputs.append(alternative_output)
+                    interface_scores = [-score for score in interface_scores]
+                    scores.append(
+                        input_component.get_interpretation_scores(
+                            raw_input[i],
+                            neighbor_values,
+                            interface_scores,
+                            **interpret_kwargs,
+                        )
+                    )
+                else:
+                    raise ValueError(
+                        f"Component {input_component} does not support interpretation"
+                    )
+            elif interp == "shap" or interp == "shapley":
+                try:
+                    import shap  # type: ignore
+                except (ImportError, ModuleNotFoundError) as err:
+                    raise ValueError(
+                        "The package `shap` is required for this interpretation method. Try: `pip install shap`"
+                    ) from err
+                input_component = interface.input_components[i]
+                if not isinstance(input_component, TokenInterpretable):
+                    raise ValueError(
+                        f"Input component {input_component} does not support `shap` interpretation"
+                    )
+
+                tokens, _, masks = input_component.tokenize(x)
+
+                # construct a masked version of the input
+                def get_masked_prediction(binary_mask):
+                    assert isinstance(input_component, TokenInterpretable)
+                    masked_xs = input_component.get_masked_inputs(tokens, binary_mask)
+                    preds = []
+                    for masked_x in masked_xs:
+                        processed_masked_input = copy.deepcopy(processed_input)
+                        processed_masked_input[i] = input_component.preprocess(masked_x)
+                        new_output = client_utils.synchronize_async(
+                            interface.call_function, 0, processed_masked_input
+                        )
+                        new_output = new_output["prediction"]
+                        if len(interface.output_components) == 1:
+                            new_output = [new_output]
+                        pred = get_regression_or_classification_value(
+                            interface, original_output, new_output
+                        )
+                        preds.append(pred)
+                    return np.array(preds)
+
+                num_total_segments = len(tokens)
+                explainer = shap.KernelExplainer(
+                    get_masked_prediction, np.zeros((1, num_total_segments))
+                )
+                shap_values = explainer.shap_values(
+                    np.ones((1, num_total_segments)),
+                    nsamples=int(interface.num_shap * num_total_segments),
+                    silent=True,
+                )
+                assert shap_values is not None, "SHAP values could not be calculated"
+                scores.append(
+                    input_component.get_interpretation_scores(
+                        raw_input[i],
+                        None,
+                        shap_values[0].tolist(),
+                        masks=masks,
+                        tokens=tokens,
+                    )
+                )
+                alternative_outputs.append([])
+            elif interp is None:
+                scores.append(None)
+                alternative_outputs.append([])
+            else:
+                raise ValueError(f"Unknown interpretation method: {interp}")
+        return scores, alternative_outputs
+    elif interface.interpretation:  # custom interpretation function
+        processed_input = [
+            input_component.preprocess(raw_input[i])
+            for i, input_component in enumerate(interface.input_components)
+        ]
+        interpreter = interface.interpretation
+        interpretation = interpreter(*processed_input)
+        if len(raw_input) == 1:
+            interpretation = [interpretation]
+        return interpretation, []
+    else:
+        raise ValueError("No interpretation method specified.")
+
+
+def diff(original: Any, perturbed: Any) -> int | float:
+    try:  # try computing numerical difference
+        score = float(original) - float(perturbed)
+    except ValueError:  # otherwise, look at strict difference in label
+        score = int(original != perturbed)
+    return score
+
+
+def quantify_difference_in_label(
+    interface: Interface, original_output: list, perturbed_output: list
+) -> int | float:
+    output_component = interface.output_components[0]
+    post_original_output = output_component.postprocess(original_output[0])
+    post_perturbed_output = output_component.postprocess(perturbed_output[0])
+
+    if isinstance(output_component, components.Label):
+        original_label = post_original_output["label"]
+        perturbed_label = post_perturbed_output["label"]
+
+        # Handle different return types of Label interface
+        if "confidences" in post_original_output:
+            original_confidence = original_output[0][original_label]
+            perturbed_confidence = perturbed_output[0][original_label]
+            score = original_confidence - perturbed_confidence
+        else:
+            score = diff(original_label, perturbed_label)
+        return score
+
+    elif isinstance(output_component, components.Number):
+        score = diff(post_original_output, post_perturbed_output)
+        return score
+
+    else:
+        raise ValueError(
+            f"This interpretation method doesn't support the Output component: {output_component}"
+        )
+
+
+def get_regression_or_classification_value(
+    interface: Interface, original_output: list, perturbed_output: list
+) -> int | float:
+    """Used to combine regression/classification for Shap interpretation method."""
+    output_component = interface.output_components[0]
+    post_original_output = output_component.postprocess(original_output[0])
+    post_perturbed_output = output_component.postprocess(perturbed_output[0])
+
+    if isinstance(output_component, components.Label):
+        original_label = post_original_output["label"]
+        perturbed_label = post_perturbed_output["label"]
+
+        # Handle different return types of Label interface
+        if "confidences" in post_original_output:
+            if math.isnan(perturbed_output[0][original_label]):
+                return 0
+            return perturbed_output[0][original_label]
+        else:
+            score = diff(
+                perturbed_label, original_label
+            )  # Intentionally inverted order of arguments.
+        return score
+
+    else:
+        raise ValueError(
+            f"This interpretation method doesn't support the Output component: {output_component}"
+        )

falcon/lib/python3.10/site-packages/gradio/mix.py

@@ -0,0 +1,129 @@
+"""
+Ways to transform interfaces to produce new interfaces
+"""
+import asyncio
+import warnings
+
+from gradio_client.documentation import document, set_documentation_group
+
+import gradio
+
+set_documentation_group("mix_interface")
+
+
+@document()
+class Parallel(gradio.Interface):
+    """
+    Creates a new Interface consisting of multiple Interfaces in parallel (comparing their outputs).
+    The Interfaces to put in Parallel must share the same input components (but can have different output components).
+
+    Demos: interface_parallel, interface_parallel_load
+    Guides: advanced-interface-features
+    """
+
+    def __init__(self, *interfaces: gradio.Interface, **options):
+        """
+        Parameters:
+            interfaces: any number of Interface objects that are to be compared in parallel
+            options: additional kwargs that are passed into the new Interface object to customize it
+        Returns:
+            an Interface object comparing the given models
+        """
+        outputs = []
+
+        for interface in interfaces:
+            if not (isinstance(interface, gradio.Interface)):
+                warnings.warn(
+                    "Parallel requires all inputs to be of type Interface. "
+                    "May not work as expected."
+                )
+            outputs.extend(interface.output_components)
+
+        async def parallel_fn(*args):
+            return_values_with_durations = await asyncio.gather(
+                *[interface.call_function(0, list(args)) for interface in interfaces]
+            )
+            return_values = [rv["prediction"] for rv in return_values_with_durations]
+            combined_list = []
+            for interface, return_value in zip(interfaces, return_values):
+                if len(interface.output_components) == 1:
+                    combined_list.append(return_value)
+                else:
+                    combined_list.extend(return_value)
+            if len(outputs) == 1:
+                return combined_list[0]
+            return combined_list
+
+        parallel_fn.__name__ = " | ".join([io.__name__ for io in interfaces])
+
+        kwargs = {
+            "fn": parallel_fn,
+            "inputs": interfaces[0].input_components,
+            "outputs": outputs,
+        }
+        kwargs.update(options)
+        super().__init__(**kwargs)
+
+
+@document()
+class Series(gradio.Interface):
+    """
+    Creates a new Interface from multiple Interfaces in series (the output of one is fed as the input to the next,
+    and so the input and output components must agree between the interfaces).
+
+    Demos: interface_series, interface_series_load
+    Guides: advanced-interface-features
+    """
+
+    def __init__(self, *interfaces: gradio.Interface, **options):
+        """
+        Parameters:
+            interfaces: any number of Interface objects that are to be connected in series
+            options: additional kwargs that are passed into the new Interface object to customize it
+        Returns:
+            an Interface object connecting the given models
+        """
+
+        async def connected_fn(*data):
+            for idx, interface in enumerate(interfaces):
+                # skip preprocessing for first interface since the Series interface will include it
+                if idx > 0 and not (interface.api_mode):
+                    data = [
+                        input_component.preprocess(data[i])
+                        for i, input_component in enumerate(interface.input_components)
+                    ]
+
+                # run all of predictions sequentially
+                data = (await interface.call_function(0, list(data)))["prediction"]
+                if len(interface.output_components) == 1:
+                    data = [data]
+
+                # skip postprocessing for final interface since the Series interface will include it
+                if idx < len(interfaces) - 1 and not (interface.api_mode):
+                    data = [
+                        output_component.postprocess(data[i])
+                        for i, output_component in enumerate(
+                            interface.output_components
+                        )
+                    ]
+
+            if len(interface.output_components) == 1:  # type: ignore
+                return data[0]
+            return data
+
+        for interface in interfaces:
+            if not (isinstance(interface, gradio.Interface)):
+                warnings.warn(
+                    "Series requires all inputs to be of type Interface. May "
+                    "not work as expected."
+                )
+        connected_fn.__name__ = " => ".join([io.__name__ for io in interfaces])
+
+        kwargs = {
+            "fn": connected_fn,
+            "inputs": interfaces[0].input_components,
+            "outputs": interfaces[-1].output_components,
+            "_api_mode": interfaces[0].api_mode,  # TODO: set api_mode per-interface
+        }
+        kwargs.update(options)
+        super().__init__(**kwargs)

falcon/lib/python3.10/site-packages/gradio/processing_utils.py

@@ -0,0 +1,530 @@
+from __future__ import annotations
+
+import base64
+import json
+import os
+import shutil
+import subprocess
+import tempfile
+import warnings
+from io import BytesIO
+from pathlib import Path
+
+import numpy as np
+from ffmpy import FFmpeg, FFprobe, FFRuntimeError
+from gradio_client import utils as client_utils
+from PIL import Image, ImageOps, PngImagePlugin
+
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")  # Ignore pydub warning if ffmpeg is not installed
+    from pydub import AudioSegment
+
+
+#########################
+# GENERAL
+#########################
+
+
+def to_binary(x: str | dict) -> bytes:
+    """Converts a base64 string or dictionary to a binary string that can be sent in a POST."""
+    if isinstance(x, dict):
+        if x.get("data"):
+            base64str = x["data"]
+        else:
+            base64str = client_utils.encode_url_or_file_to_base64(x["name"])
+    else:
+        base64str = x
+    return base64.b64decode(extract_base64_data(base64str))
+
+
+def extract_base64_data(x: str) -> str:
+    """Just extracts the base64 data from a general base64 string."""
+    return x.rsplit(",", 1)[-1]
+
+
+#########################
+# IMAGE PRE-PROCESSING
+#########################
+
+
+def decode_base64_to_image(encoding: str) -> Image.Image:
+    image_encoded = extract_base64_data(encoding)
+    img = Image.open(BytesIO(base64.b64decode(image_encoded)))
+    exif = img.getexif()
+    # 274 is the code for image rotation and 1 means "correct orientation"
+    if exif.get(274, 1) != 1 and hasattr(ImageOps, "exif_transpose"):
+        img = ImageOps.exif_transpose(img)
+    return img
+
+
+def encode_plot_to_base64(plt):
+    with BytesIO() as output_bytes:
+        plt.savefig(output_bytes, format="png")
+        bytes_data = output_bytes.getvalue()
+    base64_str = str(base64.b64encode(bytes_data), "utf-8")
+    return "data:image/png;base64," + base64_str
+
+
+def get_pil_metadata(pil_image):
+    # Copy any text-only metadata
+    metadata = PngImagePlugin.PngInfo()
+    for key, value in pil_image.info.items():
+        if isinstance(key, str) and isinstance(value, str):
+            metadata.add_text(key, value)
+
+    return metadata
+
+
+def encode_pil_to_bytes(pil_image, format="png"):
+    with BytesIO() as output_bytes:
+        pil_image.save(output_bytes, format, pnginfo=get_pil_metadata(pil_image))
+        return output_bytes.getvalue()
+
+
+def encode_pil_to_base64(pil_image):
+    bytes_data = encode_pil_to_bytes(pil_image)
+    base64_str = str(base64.b64encode(bytes_data), "utf-8")
+    return "data:image/png;base64," + base64_str
+
+
+def encode_array_to_base64(image_array):
+    with BytesIO() as output_bytes:
+        pil_image = Image.fromarray(_convert(image_array, np.uint8, force_copy=False))
+        pil_image.save(output_bytes, "PNG")
+        bytes_data = output_bytes.getvalue()
+    base64_str = str(base64.b64encode(bytes_data), "utf-8")
+    return "data:image/png;base64," + base64_str
+
+
+def resize_and_crop(img, size, crop_type="center"):
+    """
+    Resize and crop an image to fit the specified size.
+    args:
+        size: `(width, height)` tuple. Pass `None` for either width or height
+        to only crop and resize the other.
+        crop_type: can be 'top', 'middle' or 'bottom', depending on this
+            value, the image will cropped getting the 'top/left', 'middle' or
+            'bottom/right' of the image to fit the size.
+    raises:
+        ValueError: if an invalid `crop_type` is provided.
+    """
+    if crop_type == "top":
+        center = (0, 0)
+    elif crop_type == "center":
+        center = (0.5, 0.5)
+    else:
+        raise ValueError
+
+    resize = list(size)
+    if size[0] is None:
+        resize[0] = img.size[0]
+    if size[1] is None:
+        resize[1] = img.size[1]
+    return ImageOps.fit(img, resize, centering=center)  # type: ignore
+
+
+##################
+# Audio
+##################
+
+
+def audio_from_file(filename, crop_min=0, crop_max=100):
+    try:
+        audio = AudioSegment.from_file(filename)
+    except FileNotFoundError as e:
+        isfile = Path(filename).is_file()
+        msg = (
+            f"Cannot load audio from file: `{'ffprobe' if isfile else filename}` not found."
+            + " Please install `ffmpeg` in your system to use non-WAV audio file formats"
+            " and make sure `ffprobe` is in your PATH."
+            if isfile
+            else ""
+        )
+        raise RuntimeError(msg) from e
+    if crop_min != 0 or crop_max != 100:
+        audio_start = len(audio) * crop_min / 100
+        audio_end = len(audio) * crop_max / 100
+        audio = audio[audio_start:audio_end]
+    data = np.array(audio.get_array_of_samples())
+    if audio.channels > 1:
+        data = data.reshape(-1, audio.channels)
+    return audio.frame_rate, data
+
+
+def audio_to_file(sample_rate, data, filename, format="wav"):
+    if format == "wav":
+        data = convert_to_16_bit_wav(data)
+    audio = AudioSegment(
+        data.tobytes(),
+        frame_rate=sample_rate,
+        sample_width=data.dtype.itemsize,
+        channels=(1 if len(data.shape) == 1 else data.shape[1]),
+    )
+    file = audio.export(filename, format=format)
+    file.close()  # type: ignore
+
+
+def convert_to_16_bit_wav(data):
+    # Based on: https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.wavfile.write.html
+    warning = "Trying to convert audio automatically from {} to 16-bit int format."
+    if data.dtype in [np.float64, np.float32, np.float16]:
+        warnings.warn(warning.format(data.dtype))
+        data = data / np.abs(data).max()
+        data = data * 32767
+        data = data.astype(np.int16)
+    elif data.dtype == np.int32:
+        warnings.warn(warning.format(data.dtype))
+        data = data / 65538
+        data = data.astype(np.int16)
+    elif data.dtype == np.int16:
+        pass
+    elif data.dtype == np.uint16:
+        warnings.warn(warning.format(data.dtype))
+        data = data - 32768
+        data = data.astype(np.int16)
+    elif data.dtype == np.uint8:
+        warnings.warn(warning.format(data.dtype))
+        data = data * 257 - 32768
+        data = data.astype(np.int16)
+    else:
+        raise ValueError(
+            "Audio data cannot be converted automatically from "
+            f"{data.dtype} to 16-bit int format."
+        )
+    return data
+
+
+##################
+# OUTPUT
+##################
+
+
+def _convert(image, dtype, force_copy=False, uniform=False):
+    """
+    Adapted from: https://github.com/scikit-image/scikit-image/blob/main/skimage/util/dtype.py#L510-L531
+
+    Convert an image to the requested data-type.
+    Warnings are issued in case of precision loss, or when negative values
+    are clipped during conversion to unsigned integer types (sign loss).
+    Floating point values are expected to be normalized and will be clipped
+    to the range [0.0, 1.0] or [-1.0, 1.0] when converting to unsigned or
+    signed integers respectively.
+    Numbers are not shifted to the negative side when converting from
+    unsigned to signed integer types. Negative values will be clipped when
+    converting to unsigned integers.
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    dtype : dtype
+        Target data-type.
+    force_copy : bool, optional
+        Force a copy of the data, irrespective of its current dtype.
+    uniform : bool, optional
+        Uniformly quantize the floating point range to the integer range.
+        By default (uniform=False) floating point values are scaled and
+        rounded to the nearest integers, which minimizes back and forth
+        conversion errors.
+    .. versionchanged :: 0.15
+        ``_convert`` no longer warns about possible precision or sign
+        information loss. See discussions on these warnings at:
+        https://github.com/scikit-image/scikit-image/issues/2602
+        https://github.com/scikit-image/scikit-image/issues/543#issuecomment-208202228
+        https://github.com/scikit-image/scikit-image/pull/3575
+    References
+    ----------
+    .. [1] DirectX data conversion rules.
+           https://msdn.microsoft.com/en-us/library/windows/desktop/dd607323%28v=vs.85%29.aspx
+    .. [2] Data Conversions. In "OpenGL ES 2.0 Specification v2.0.25",
+           pp 7-8. Khronos Group, 2010.
+    .. [3] Proper treatment of pixels as integers. A.W. Paeth.
+           In "Graphics Gems I", pp 249-256. Morgan Kaufmann, 1990.
+    .. [4] Dirty Pixels. J. Blinn. In "Jim Blinn's corner: Dirty Pixels",
+           pp 47-57. Morgan Kaufmann, 1998.
+    """
+    dtype_range = {
+        bool: (False, True),
+        np.bool_: (False, True),
+        np.bool8: (False, True),
+        float: (-1, 1),
+        np.float_: (-1, 1),
+        np.float16: (-1, 1),
+        np.float32: (-1, 1),
+        np.float64: (-1, 1),
+    }
+
+    def _dtype_itemsize(itemsize, *dtypes):
+        """Return first of `dtypes` with itemsize greater than `itemsize`
+        Parameters
+        ----------
+        itemsize: int
+            The data type object element size.
+        Other Parameters
+        ----------------
+        *dtypes:
+            Any Object accepted by `np.dtype` to be converted to a data
+            type object
+        Returns
+        -------
+        dtype: data type object
+            First of `dtypes` with itemsize greater than `itemsize`.
+        """
+        return next(dt for dt in dtypes if np.dtype(dt).itemsize >= itemsize)
+
+    def _dtype_bits(kind, bits, itemsize=1):
+        """Return dtype of `kind` that can store a `bits` wide unsigned int
+        Parameters:
+        kind: str
+            Data type kind.
+        bits: int
+            Desired number of bits.
+        itemsize: int
+            The data type object element size.
+        Returns
+        -------
+        dtype: data type object
+            Data type of `kind` that can store a `bits` wide unsigned int
+        """
+
+        s = next(
+            i
+            for i in (itemsize,) + (2, 4, 8)
+            if bits < (i * 8) or (bits == (i * 8) and kind == "u")
+        )
+
+        return np.dtype(kind + str(s))
+
+    def _scale(a, n, m, copy=True):
+        """Scale an array of unsigned/positive integers from `n` to `m` bits.
+        Numbers can be represented exactly only if `m` is a multiple of `n`.
+        Parameters
+        ----------
+        a : ndarray
+            Input image array.
+        n : int
+            Number of bits currently used to encode the values in `a`.
+        m : int
+            Desired number of bits to encode the values in `out`.
+        copy : bool, optional
+            If True, allocates and returns new array. Otherwise, modifies
+            `a` in place.
+        Returns
+        -------
+        out : array
+            Output image array. Has the same kind as `a`.
+        """
+        kind = a.dtype.kind
+        if n > m and a.max() < 2**m:
+            return a.astype(_dtype_bits(kind, m))
+        elif n == m:
+            return a.copy() if copy else a
+        elif n > m:
+            # downscale with precision loss
+            if copy:
+                b = np.empty(a.shape, _dtype_bits(kind, m))
+                np.floor_divide(a, 2 ** (n - m), out=b, dtype=a.dtype, casting="unsafe")
+                return b
+            else:
+                a //= 2 ** (n - m)
+                return a
+        elif m % n == 0:
+            # exact upscale to a multiple of `n` bits
+            if copy:
+                b = np.empty(a.shape, _dtype_bits(kind, m))
+                np.multiply(a, (2**m - 1) // (2**n - 1), out=b, dtype=b.dtype)
+                return b
+            else:
+                a = a.astype(_dtype_bits(kind, m, a.dtype.itemsize), copy=False)
+                a *= (2**m - 1) // (2**n - 1)
+                return a
+        else:
+            # upscale to a multiple of `n` bits,
+            # then downscale with precision loss
+            o = (m // n + 1) * n
+            if copy:
+                b = np.empty(a.shape, _dtype_bits(kind, o))
+                np.multiply(a, (2**o - 1) // (2**n - 1), out=b, dtype=b.dtype)
+                b //= 2 ** (o - m)
+                return b
+            else:
+                a = a.astype(_dtype_bits(kind, o, a.dtype.itemsize), copy=False)
+                a *= (2**o - 1) // (2**n - 1)
+                a //= 2 ** (o - m)
+                return a
+
+    image = np.asarray(image)
+    dtypeobj_in = image.dtype
+    dtypeobj_out = np.dtype("float64") if dtype is np.floating else np.dtype(dtype)
+    dtype_in = dtypeobj_in.type
+    dtype_out = dtypeobj_out.type
+    kind_in = dtypeobj_in.kind
+    kind_out = dtypeobj_out.kind
+    itemsize_in = dtypeobj_in.itemsize
+    itemsize_out = dtypeobj_out.itemsize
+
+    # Below, we do an `issubdtype` check.  Its purpose is to find out
+    # whether we can get away without doing any image conversion.  This happens
+    # when:
+    #
+    # - the output and input dtypes are the same or
+    # - when the output is specified as a type, and the input dtype
+    #   is a subclass of that type (e.g. `np.floating` will allow
+    #   `float32` and `float64` arrays through)
+
+    if np.issubdtype(dtype_in, np.obj2sctype(dtype)):
+        if force_copy:
+            image = image.copy()
+        return image
+
+    if kind_in in "ui":
+        imin_in = np.iinfo(dtype_in).min
+        imax_in = np.iinfo(dtype_in).max
+    if kind_out in "ui":
+        imin_out = np.iinfo(dtype_out).min  # type: ignore
+        imax_out = np.iinfo(dtype_out).max  # type: ignore
+
+    # any -> binary
+    if kind_out == "b":
+        return image > dtype_in(dtype_range[dtype_in][1] / 2)
+
+    # binary -> any
+    if kind_in == "b":
+        result = image.astype(dtype_out)
+        if kind_out != "f":
+            result *= dtype_out(dtype_range[dtype_out][1])
+        return result
+
+    # float -> any
+    if kind_in == "f":
+        if kind_out == "f":
+            # float -> float
+            return image.astype(dtype_out)
+
+        if np.min(image) < -1.0 or np.max(image) > 1.0:
+            raise ValueError("Images of type float must be between -1 and 1.")
+        # floating point -> integer
+        # use float type that can represent output integer type
+        computation_type = _dtype_itemsize(
+            itemsize_out, dtype_in, np.float32, np.float64
+        )
+
+        if not uniform:
+            if kind_out == "u":
+                image_out = np.multiply(image, imax_out, dtype=computation_type)  # type: ignore
+            else:
+                image_out = np.multiply(
+                    image, (imax_out - imin_out) / 2, dtype=computation_type  # type: ignore
+                )
+                image_out -= 1.0 / 2.0
+            np.rint(image_out, out=image_out)
+            np.clip(image_out, imin_out, imax_out, out=image_out)  # type: ignore
+        elif kind_out == "u":
+            image_out = np.multiply(image, imax_out + 1, dtype=computation_type)  # type: ignore
+            np.clip(image_out, 0, imax_out, out=image_out)  # type: ignore
+        else:
+            image_out = np.multiply(
+                image, (imax_out - imin_out + 1.0) / 2.0, dtype=computation_type  # type: ignore
+            )
+            np.floor(image_out, out=image_out)
+            np.clip(image_out, imin_out, imax_out, out=image_out)  # type: ignore
+        return image_out.astype(dtype_out)
+
+    # signed/unsigned int -> float
+    if kind_out == "f":
+        # use float type that can exactly represent input integers
+        computation_type = _dtype_itemsize(
+            itemsize_in, dtype_out, np.float32, np.float64
+        )
+
+        if kind_in == "u":
+            # using np.divide or np.multiply doesn't copy the data
+            # until the computation time
+            image = np.multiply(image, 1.0 / imax_in, dtype=computation_type)  # type: ignore
+            # DirectX uses this conversion also for signed ints
+            # if imin_in:
+            #     np.maximum(image, -1.0, out=image)
+        else:
+            image = np.add(image, 0.5, dtype=computation_type)
+            image *= 2 / (imax_in - imin_in)  # type: ignore
+
+        return np.asarray(image, dtype_out)
+
+    # unsigned int -> signed/unsigned int
+    if kind_in == "u":
+        if kind_out == "i":
+            # unsigned int -> signed int
+            image = _scale(image, 8 * itemsize_in, 8 * itemsize_out - 1)
+            return image.view(dtype_out)
+        else:
+            # unsigned int -> unsigned int
+            return _scale(image, 8 * itemsize_in, 8 * itemsize_out)
+
+    # signed int -> unsigned int
+    if kind_out == "u":
+        image = _scale(image, 8 * itemsize_in - 1, 8 * itemsize_out)
+        result = np.empty(image.shape, dtype_out)
+        np.maximum(image, 0, out=result, dtype=image.dtype, casting="unsafe")
+        return result
+
+    # signed int -> signed int
+    if itemsize_in > itemsize_out:
+        return _scale(image, 8 * itemsize_in - 1, 8 * itemsize_out - 1)
+
+    image = image.astype(_dtype_bits("i", itemsize_out * 8))
+    image -= imin_in  # type: ignore
+    image = _scale(image, 8 * itemsize_in, 8 * itemsize_out, copy=False)
+    image += imin_out  # type: ignore
+    return image.astype(dtype_out)
+
+
+def ffmpeg_installed() -> bool:
+    return shutil.which("ffmpeg") is not None
+
+
+def video_is_playable(video_filepath: str) -> bool:
+    """Determines if a video is playable in the browser.
+
+    A video is playable if it has a playable container and codec.
+        .mp4 -> h264
+        .webm -> vp9
+        .ogg -> theora
+    """
+    try:
+        container = Path(video_filepath).suffix.lower()
+        probe = FFprobe(
+            global_options="-show_format -show_streams -select_streams v -print_format json",
+            inputs={video_filepath: None},
+        )
+        output = probe.run(stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+        output = json.loads(output[0])
+        video_codec = output["streams"][0]["codec_name"]
+        return (container, video_codec) in [
+            (".mp4", "h264"),
+            (".ogg", "theora"),
+            (".webm", "vp9"),
+        ]
+    # If anything goes wrong, assume the video can be played to not convert downstream
+    except (FFRuntimeError, IndexError, KeyError):
+        return True
+
+
+def convert_video_to_playable_mp4(video_path: str) -> str:
+    """Convert the video to mp4. If something goes wrong return the original video."""
+    try:
+        with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
+            output_path = Path(video_path).with_suffix(".mp4")
+            shutil.copy2(video_path, tmp_file.name)
+            # ffmpeg will automatically use h264 codec (playable in browser) when converting to mp4
+            ff = FFmpeg(
+                inputs={str(tmp_file.name): None},
+                outputs={str(output_path): None},
+                global_options="-y -loglevel quiet",
+            )
+            ff.run()
+    except FFRuntimeError as e:
+        print(f"Error converting video to browser-playable format {str(e)}")
+        output_path = video_path
+    finally:
+        # Remove temp file
+        os.remove(tmp_file.name)  # type: ignore
+    return str(output_path)

falcon/lib/python3.10/site-packages/gradio/queueing.py

@@ -0,0 +1,462 @@
+from __future__ import annotations
+
+import asyncio
+import copy
+import time
+from asyncio import TimeoutError as AsyncTimeOutError
+from collections import deque
+from typing import Any
+
+import fastapi
+import httpx
+
+from gradio.data_classes import Estimation, PredictBody, Progress, ProgressUnit
+from gradio.helpers import TrackedIterable
+from gradio.utils import AsyncRequest, run_coro_in_background, set_task_name
+
+
+class Event:
+    def __init__(
+        self,
+        websocket: fastapi.WebSocket,
+        session_hash: str,
+        fn_index: int,
+    ):
+        self.websocket = websocket
+        self.session_hash: str = session_hash
+        self.fn_index: int = fn_index
+        self._id = f"{self.session_hash}_{self.fn_index}"
+        self.data: PredictBody | None = None
+        self.lost_connection_time: float | None = None
+        self.token: str | None = None
+        self.progress: Progress | None = None
+        self.progress_pending: bool = False
+
+    async def disconnect(self, code: int = 1000):
+        await self.websocket.close(code=code)
+
+
+class Queue:
+    def __init__(
+        self,
+        live_updates: bool,
+        concurrency_count: int,
+        update_intervals: float,
+        max_size: int | None,
+        blocks_dependencies: list,
+    ):
+        self.event_queue: deque[Event] = deque()
+        self.events_pending_reconnection = []
+        self.stopped = False
+        self.max_thread_count = concurrency_count
+        self.update_intervals = update_intervals
+        self.active_jobs: list[None | list[Event]] = [None] * concurrency_count
+        self.delete_lock = asyncio.Lock()
+        self.server_path = None
+        self.duration_history_total = 0
+        self.duration_history_count = 0
+        self.avg_process_time = 0
+        self.avg_concurrent_process_time = None
+        self.queue_duration = 1
+        self.live_updates = live_updates
+        self.sleep_when_free = 0.05
+        self.progress_update_sleep_when_free = 0.1
+        self.max_size = max_size
+        self.blocks_dependencies = blocks_dependencies
+        self.access_token = ""
+        self.queue_client = None
+
+    async def start(self, progress_tracking=False, ssl_verify=True):
+        # So that the client is attached to the running event loop
+        self.queue_client = httpx.AsyncClient(verify=ssl_verify)
+
+        run_coro_in_background(self.start_processing)
+        if progress_tracking:
+            run_coro_in_background(self.start_progress_tracking)
+        if not self.live_updates:
+            run_coro_in_background(self.notify_clients)
+
+    def close(self):
+        self.stopped = True
+
+    def resume(self):
+        self.stopped = False
+
+    def set_url(self, url: str):
+        self.server_path = url
+
+    def set_access_token(self, token: str):
+        self.access_token = token
+
+    def get_active_worker_count(self) -> int:
+        count = 0
+        for worker in self.active_jobs:
+            if worker is not None:
+                count += 1
+        return count
+
+    def get_events_in_batch(self) -> tuple[list[Event] | None, bool]:
+        if not (self.event_queue):
+            return None, False
+
+        first_event = self.event_queue.popleft()
+        events = [first_event]
+
+        event_fn_index = first_event.fn_index
+        batch = self.blocks_dependencies[event_fn_index]["batch"]
+
+        if batch:
+            batch_size = self.blocks_dependencies[event_fn_index]["max_batch_size"]
+            rest_of_batch = [
+                event for event in self.event_queue if event.fn_index == event_fn_index
+            ][: batch_size - 1]
+            events.extend(rest_of_batch)
+            [self.event_queue.remove(event) for event in rest_of_batch]
+
+        return events, batch
+
+    async def start_processing(self) -> None:
+        while not self.stopped:
+            if not self.event_queue:
+                await asyncio.sleep(self.sleep_when_free)
+                continue
+
+            if None not in self.active_jobs:
+                await asyncio.sleep(self.sleep_when_free)
+                continue
+            # Using mutex to avoid editing a list in use
+            async with self.delete_lock:
+                events, batch = self.get_events_in_batch()
+
+            if events:
+                self.active_jobs[self.active_jobs.index(None)] = events
+                task = run_coro_in_background(self.process_events, events, batch)
+                run_coro_in_background(self.broadcast_live_estimations)
+                set_task_name(task, events[0].session_hash, events[0].fn_index, batch)
+
+    async def start_progress_tracking(self) -> None:
+        while not self.stopped:
+            if not any(self.active_jobs):
+                await asyncio.sleep(self.progress_update_sleep_when_free)
+                continue
+
+            for job in self.active_jobs:
+                if job is None:
+                    continue
+                for event in job:
+                    if event.progress_pending and event.progress:
+                        event.progress_pending = False
+                        client_awake = await self.send_message(
+                            event, event.progress.dict()
+                        )
+                        if not client_awake:
+                            await self.clean_event(event)
+
+            await asyncio.sleep(self.progress_update_sleep_when_free)
+
+    def set_progress(
+        self,
+        event_id: str,
+        iterables: list[TrackedIterable] | None,
+    ):
+        if iterables is None:
+            return
+        for job in self.active_jobs:
+            if job is None:
+                continue
+            for evt in job:
+                if evt._id == event_id:
+                    progress_data: list[ProgressUnit] = []
+                    for iterable in iterables:
+                        progress_unit = ProgressUnit(
+                            index=iterable.index,
+                            length=iterable.length,
+                            unit=iterable.unit,
+                            progress=iterable.progress,
+                            desc=iterable.desc,
+                        )
+                        progress_data.append(progress_unit)
+                    evt.progress = Progress(progress_data=progress_data)
+                    evt.progress_pending = True
+
+    def push(self, event: Event) -> int | None:
+        """
+        Add event to queue, or return None if Queue is full
+        Parameters:
+            event: Event to add to Queue
+        Returns:
+            rank of submitted Event
+        """
+        queue_len = len(self.event_queue)
+        if self.max_size is not None and queue_len >= self.max_size:
+            return None
+        self.event_queue.append(event)
+        return queue_len
+
+    async def clean_event(self, event: Event) -> None:
+        if event in self.event_queue:
+            async with self.delete_lock:
+                self.event_queue.remove(event)
+
+    async def broadcast_live_estimations(self) -> None:
+        """
+        Runs 2 functions sequentially instead of concurrently. Otherwise dced clients are tried to get deleted twice.
+        """
+        if self.live_updates:
+            await self.broadcast_estimations()
+
+    async def gather_event_data(self, event: Event, receive_timeout=60) -> bool:
+        """
+        Gather data for the event
+        Parameters:
+            event: the Event to gather data for
+            receive_timeout: how long to wait for data to be received from frontend
+        """
+        if not event.data:
+            client_awake = await self.send_message(event, {"msg": "send_data"})
+            if not client_awake:
+                return False
+            data, client_awake = await self.get_message(event, timeout=receive_timeout)
+            if not client_awake:
+                # In the event, we timeout due to large data size
+                # Let the client know, otherwise will hang
+                await self.send_message(
+                    event,
+                    {
+                        "msg": "process_completed",
+                        "output": {"error": "Time out uploading data to server"},
+                        "success": False,
+                    },
+                )
+                return False
+            event.data = data
+        return True
+
+    async def notify_clients(self) -> None:
+        """
+        Notify clients about events statuses in the queue periodically.
+        """
+        while not self.stopped:
+            await asyncio.sleep(self.update_intervals)
+            if self.event_queue:
+                await self.broadcast_estimations()
+
+    async def broadcast_estimations(self) -> None:
+        estimation = self.get_estimation()
+        # Send all messages concurrently
+        await asyncio.gather(
+            *[
+                self.send_estimation(event, estimation, rank)
+                for rank, event in enumerate(self.event_queue)
+            ]
+        )
+
+    async def send_estimation(
+        self, event: Event, estimation: Estimation, rank: int
+    ) -> Estimation:
+        """
+        Send estimation about ETA to the client.
+
+        Parameters:
+            event:
+            estimation:
+            rank:
+        """
+        estimation.rank = rank
+
+        if self.avg_concurrent_process_time is not None:
+            estimation.rank_eta = (
+                estimation.rank * self.avg_concurrent_process_time
+                + self.avg_process_time
+            )
+            if None not in self.active_jobs:
+                # Add estimated amount of time for a thread to get empty
+                estimation.rank_eta += self.avg_concurrent_process_time
+        client_awake = await self.send_message(event, estimation.dict())
+        if not client_awake:
+            await self.clean_event(event)
+        return estimation
+
+    def update_estimation(self, duration: float) -> None:
+        """
+        Update estimation by last x element's average duration.
+
+        Parameters:
+            duration:
+        """
+        self.duration_history_total += duration
+        self.duration_history_count += 1
+        self.avg_process_time = (
+            self.duration_history_total / self.duration_history_count
+        )
+        self.avg_concurrent_process_time = self.avg_process_time / min(
+            self.max_thread_count, self.duration_history_count
+        )
+        self.queue_duration = self.avg_concurrent_process_time * len(self.event_queue)
+
+    def get_estimation(self) -> Estimation:
+        return Estimation(
+            queue_size=len(self.event_queue),
+            avg_event_process_time=self.avg_process_time,
+            avg_event_concurrent_process_time=self.avg_concurrent_process_time,
+            queue_eta=self.queue_duration,
+        )
+
+    def get_request_params(self, websocket: fastapi.WebSocket) -> dict[str, Any]:
+        return {
+            "url": str(websocket.url),
+            "headers": dict(websocket.headers),
+            "query_params": dict(websocket.query_params),
+            "path_params": dict(websocket.path_params),
+            "client": {"host": websocket.client.host, "port": websocket.client.port},  # type: ignore
+        }
+
+    async def call_prediction(self, events: list[Event], batch: bool):
+        data = events[0].data
+        assert data is not None, "No event data"
+        token = events[0].token
+        data.event_id = events[0]._id if not batch else None
+        try:
+            data.request = self.get_request_params(events[0].websocket)
+        except ValueError:
+            pass
+
+        if batch:
+            data.data = list(zip(*[event.data.data for event in events if event.data]))
+            data.request = [
+                self.get_request_params(event.websocket)
+                for event in events
+                if event.data
+            ]
+            data.batched = True
+        response = await AsyncRequest(
+            method=AsyncRequest.Method.POST,
+            url=f"{self.server_path}api/predict",
+            json=dict(data),
+            headers={"Authorization": f"Bearer {self.access_token}"},
+            cookies={"access-token": token} if token is not None else None,
+            client=self.queue_client,
+        )
+        return response
+
+    async def process_events(self, events: list[Event], batch: bool) -> None:
+        awake_events: list[Event] = []
+        try:
+            for event in events:
+                client_awake = await self.gather_event_data(event)
+                if client_awake:
+                    client_awake = await self.send_message(
+                        event, {"msg": "process_starts"}
+                    )
+                if client_awake:
+                    awake_events.append(event)
+            if not awake_events:
+                return
+            begin_time = time.time()
+            response = await self.call_prediction(awake_events, batch)
+            if response.has_exception:
+                for event in awake_events:
+                    await self.send_message(
+                        event,
+                        {
+                            "msg": "process_completed",
+                            "output": {"error": str(response.exception)},
+                            "success": False,
+                        },
+                    )
+            elif response.json.get("is_generating", False):
+                old_response = response
+                while response.json.get("is_generating", False):
+                    old_response = response
+                    open_ws = []
+                    for event in awake_events:
+                        open = await self.send_message(
+                            event,
+                            {
+                                "msg": "process_generating",
+                                "output": old_response.json,
+                                "success": old_response.status == 200,
+                            },
+                        )
+                        open_ws.append(open)
+                    awake_events = [
+                        e for e, is_open in zip(awake_events, open_ws) if is_open
+                    ]
+                    if not awake_events:
+                        return
+                    response = await self.call_prediction(awake_events, batch)
+                for event in awake_events:
+                    if response.status != 200:
+                        relevant_response = response
+                    else:
+                        relevant_response = old_response
+
+                    await self.send_message(
+                        event,
+                        {
+                            "msg": "process_completed",
+                            "output": relevant_response.json,
+                            "success": relevant_response.status == 200,
+                        },
+                    )
+            else:
+                output = copy.deepcopy(response.json)
+                for e, event in enumerate(awake_events):
+                    if batch and "data" in output:
+                        output["data"] = list(zip(*response.json.get("data")))[e]
+                    await self.send_message(
+                        event,
+                        {
+                            "msg": "process_completed",
+                            "output": output,
+                            "success": response.status == 200,
+                        },
+                    )
+            end_time = time.time()
+            if response.status == 200:
+                self.update_estimation(end_time - begin_time)
+        finally:
+            for event in awake_events:
+                try:
+                    await event.disconnect()
+                except Exception:
+                    pass
+            self.active_jobs[self.active_jobs.index(events)] = None
+            for event in events:
+                await self.clean_event(event)
+                # Always reset the state of the iterator
+                # If the job finished successfully, this has no effect
+                # If the job is cancelled, this will enable future runs
+                # to start "from scratch"
+                await self.reset_iterators(event.session_hash, event.fn_index)
+
+    async def send_message(self, event, data: dict, timeout: float | int = 1) -> bool:
+        try:
+            await asyncio.wait_for(
+                event.websocket.send_json(data=data), timeout=timeout
+            )
+            return True
+        except Exception:
+            await self.clean_event(event)
+            return False
+
+    async def get_message(self, event, timeout=5) -> tuple[PredictBody | None, bool]:
+        try:
+            data = await asyncio.wait_for(
+                event.websocket.receive_json(), timeout=timeout
+            )
+            return PredictBody(**data), True
+        except AsyncTimeOutError:
+            await self.clean_event(event)
+            return None, False
+
+    async def reset_iterators(self, session_hash: str, fn_index: int):
+        await AsyncRequest(
+            method=AsyncRequest.Method.POST,
+            url=f"{self.server_path}reset",
+            json={
+                "session_hash": session_hash,
+                "fn_index": fn_index,
+            },
+            client=self.queue_client,
+        )

falcon/lib/python3.10/site-packages/gradio/ranged_response.py

@@ -0,0 +1,185 @@
+# Taken from https://gist.github.com/kevinastone/a6a62db57577b3f24e8a6865ed311463
+# Context: https://github.com/encode/starlette/pull/1090
+from __future__ import annotations
+
+import os
+import re
+import stat
+from typing import NamedTuple
+from urllib.parse import quote
+
+import aiofiles
+from aiofiles.os import stat as aio_stat
+from starlette.datastructures import Headers
+from starlette.exceptions import HTTPException
+from starlette.responses import Response, guess_type
+from starlette.staticfiles import StaticFiles
+from starlette.types import Receive, Scope, Send
+
+RANGE_REGEX = re.compile(r"^bytes=(?P<start>\d+)-(?P<end>\d*)$")
+
+
+class ClosedRange(NamedTuple):
+    start: int
+    end: int
+
+    def __len__(self) -> int:
+        return self.end - self.start + 1
+
+    def __bool__(self) -> bool:
+        return len(self) > 0
+
+
+class OpenRange(NamedTuple):
+    start: int
+    end: int | None = None
+
+    def clamp(self, start: int, end: int) -> ClosedRange:
+        begin = max(self.start, start)
+        end = min(x for x in (self.end, end) if x)
+
+        begin = min(begin, end)
+        end = max(begin, end)
+
+        return ClosedRange(begin, end)
+
+
+class RangedFileResponse(Response):
+    chunk_size = 4096
+
+    def __init__(
+        self,
+        path: str | os.PathLike,
+        range: OpenRange,
+        headers: dict[str, str] | None = None,
+        media_type: str | None = None,
+        filename: str | None = None,
+        stat_result: os.stat_result | None = None,
+        method: str | None = None,
+    ) -> None:
+        assert aiofiles is not None, "'aiofiles' must be installed to use FileResponse"
+        self.path = path
+        self.range = range
+        self.filename = filename
+        self.background = None
+        self.send_header_only = method is not None and method.upper() == "HEAD"
+        if media_type is None:
+            media_type = guess_type(filename or path)[0] or "text/plain"
+        self.media_type = media_type
+        self.init_headers(headers or {})
+        if self.filename is not None:
+            content_disposition_filename = quote(self.filename)
+            if content_disposition_filename != self.filename:
+                content_disposition = (
+                    f"attachment; filename*=utf-8''{content_disposition_filename}"
+                )
+            else:
+                content_disposition = f'attachment; filename="{self.filename}"'
+            self.headers.setdefault("content-disposition", content_disposition)
+        self.stat_result = stat_result
+
+    def set_range_headers(self, range: ClosedRange) -> None:
+        assert self.stat_result
+        total_length = self.stat_result.st_size
+        content_length = len(range)
+        self.headers[
+            "content-range"
+        ] = f"bytes {range.start}-{range.end}/{total_length}"
+        self.headers["content-length"] = str(content_length)
+        pass
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if self.stat_result is None:
+            try:
+                stat_result = await aio_stat(self.path)
+                self.stat_result = stat_result
+            except FileNotFoundError as fnfe:
+                raise RuntimeError(
+                    f"File at path {self.path} does not exist."
+                ) from fnfe
+            else:
+                mode = stat_result.st_mode
+                if not stat.S_ISREG(mode):
+                    raise RuntimeError(f"File at path {self.path} is not a file.")
+
+        byte_range = self.range.clamp(0, self.stat_result.st_size)
+        self.set_range_headers(byte_range)
+
+        async with aiofiles.open(self.path, mode="rb") as file:
+            await file.seek(byte_range.start)
+            await send(
+                {
+                    "type": "http.response.start",
+                    "status": 206,
+                    "headers": self.raw_headers,
+                }
+            )
+            if self.send_header_only:
+                await send(
+                    {"type": "http.response.body", "body": b"", "more_body": False}
+                )
+            else:
+                remaining_bytes = len(byte_range)
+
+                if not byte_range:
+                    await send(
+                        {"type": "http.response.body", "body": b"", "more_body": False}
+                    )
+                    return
+
+                while remaining_bytes > 0:
+                    chunk_size = min(self.chunk_size, remaining_bytes)
+                    chunk = await file.read(chunk_size)
+                    remaining_bytes -= len(chunk)
+                    await send(
+                        {
+                            "type": "http.response.body",
+                            "body": chunk,
+                            "more_body": remaining_bytes > 0,
+                        }
+                    )
+
+
+class RangedStaticFiles(StaticFiles):
+    def file_response(
+        self,
+        full_path: str | os.PathLike,
+        stat_result: os.stat_result,
+        scope: Scope,
+        status_code: int = 200,
+    ) -> Response:
+        request_headers = Headers(scope=scope)
+
+        if request_headers.get("range"):
+            response = self.ranged_file_response(
+                full_path, stat_result=stat_result, scope=scope
+            )
+        else:
+            response = super().file_response(
+                full_path, stat_result=stat_result, scope=scope, status_code=status_code
+            )
+        response.headers["accept-ranges"] = "bytes"
+        return response
+
+    def ranged_file_response(
+        self,
+        full_path: str | os.PathLike,
+        stat_result: os.stat_result,
+        scope: Scope,
+    ) -> Response:
+        method = scope["method"]
+        request_headers = Headers(scope=scope)
+
+        range_header = request_headers["range"]
+
+        match = RANGE_REGEX.search(range_header)
+        if not match:
+            raise HTTPException(400)
+
+        start, end = match.group("start"), match.group("end")
+
+        range = OpenRange(int(start), int(end) if end else None)
+
+        return RangedFileResponse(
+            full_path, range, stat_result=stat_result, method=method
+        )

falcon/lib/python3.10/site-packages/gradio/reload.py

@@ -0,0 +1,91 @@
+"""
+
+Contains the functions that run when `gradio` is called from the command line. Specifically, allows
+
+$ gradio app.py, to run app.py in reload mode where any changes in the app.py file or Gradio library reloads the demo.
+$ gradio app.py my_demo.app, to use variable names other than "demo"
+"""
+import inspect
+import os
+import sys
+from pathlib import Path
+
+from uvicorn import Config
+from uvicorn.supervisors import ChangeReload
+
+import gradio
+from gradio import networking, utils
+
+
+def _setup_config():
+    args = sys.argv[1:]
+    if len(args) == 0:
+        raise ValueError("No file specified.")
+    if len(args) == 1 or args[1].startswith("--"):
+        demo_name = "demo.app"
+    else:
+        demo_name = args[1]
+        if "." not in demo_name:
+            print(
+                "\nWARNING: As of Gradio 3.31, the parameter after the file path must be the name of the FastAPI app, not the Gradio demo. In most cases, this just means you should add '.app' after the name of your demo, e.g. 'demo' -> 'demo.app'."
+            )
+
+    original_path = args[0]
+    abs_original_path = utils.abspath(original_path)
+    path = os.path.normpath(original_path)
+    path = path.replace("/", ".")
+    path = path.replace("\\", ".")
+    filename = os.path.splitext(path)[0]
+
+    gradio_folder = Path(inspect.getfile(gradio)).parent
+
+    port = networking.get_first_available_port(
+        networking.INITIAL_PORT_VALUE,
+        networking.INITIAL_PORT_VALUE + networking.TRY_NUM_PORTS,
+    )
+    print(
+        f"\nLaunching in *reload mode* on: http://{networking.LOCALHOST_NAME}:{port} (Press CTRL+C to quit)\n"
+    )
+
+    gradio_app = f"{filename}:{demo_name}"
+    message = "Watching:"
+    message_change_count = 0
+
+    watching_dirs = []
+    if str(gradio_folder).strip():
+        watching_dirs.append(gradio_folder)
+        message += f" '{gradio_folder}'"
+        message_change_count += 1
+
+    abs_parent = abs_original_path.parent
+    if str(abs_parent).strip():
+        watching_dirs.append(abs_parent)
+        if message_change_count == 1:
+            message += ","
+        message += f" '{abs_parent}'"
+
+    print(message + "\n")
+
+    # guaranty access to the module of an app
+    sys.path.insert(0, os.getcwd())
+
+    # uvicorn.run blocks the execution (looping) which makes it hard to test
+    return Config(
+        gradio_app,
+        reload=True,
+        port=port,
+        log_level="warning",
+        reload_dirs=watching_dirs,
+    )
+
+
+def main():
+    # default execution pattern to start the server and watch changes
+    config = _setup_config()
+    server = networking.Server(config)
+    sock = config.bind_socket()
+    ChangeReload(config, target=server.run, sockets=[sock]).run()
+
+
+if __name__ == "__main__":
+    main()

falcon/lib/python3.10/site-packages/gradio/routes.py

@@ -0,0 +1,824 @@
+"""Implements a FastAPI server to run the gradio interface. Note that some types in this
+module use the Optional/Union notation so that they work correctly with pydantic."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import json
+import mimetypes
+import os
+import posixpath
+import secrets
+import tempfile
+import traceback
+from asyncio import TimeoutError as AsyncTimeOutError
+from collections import defaultdict
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Type
+from urllib.parse import urlparse
+
+import fastapi
+import httpx
+import markupsafe
+import orjson
+import pkg_resources
+from fastapi import Depends, FastAPI, File, HTTPException, UploadFile, WebSocket, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import (
+    FileResponse,
+    HTMLResponse,
+    JSONResponse,
+    PlainTextResponse,
+)
+from fastapi.security import OAuth2PasswordRequestForm
+from fastapi.templating import Jinja2Templates
+from gradio_client.documentation import document, set_documentation_group
+from jinja2.exceptions import TemplateNotFound
+from starlette.background import BackgroundTask
+from starlette.responses import RedirectResponse, StreamingResponse
+from starlette.websockets import WebSocketState
+
+import gradio
+import gradio.ranged_response as ranged_response
+from gradio import utils
+from gradio.context import Context
+from gradio.data_classes import PredictBody, ResetBody
+from gradio.exceptions import Error
+from gradio.helpers import EventData
+from gradio.queueing import Estimation, Event
+from gradio.utils import cancel_tasks, run_coro_in_background, set_task_name
+
+mimetypes.init()
+
+STATIC_TEMPLATE_LIB = pkg_resources.resource_filename("gradio", "templates/")
+STATIC_PATH_LIB = pkg_resources.resource_filename("gradio", "templates/frontend/static")
+BUILD_PATH_LIB = pkg_resources.resource_filename("gradio", "templates/frontend/assets")
+VERSION_FILE = pkg_resources.resource_filename("gradio", "version.txt")
+with open(VERSION_FILE) as version_file:
+    VERSION = version_file.read()
+
+
+class ORJSONResponse(JSONResponse):
+    media_type = "application/json"
+
+    @staticmethod
+    def _render(content: Any) -> bytes:
+        return orjson.dumps(
+            content,
+            option=orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_PASSTHROUGH_DATETIME,
+            default=str,
+        )
+
+    def render(self, content: Any) -> bytes:
+        return ORJSONResponse._render(content)
+
+    @staticmethod
+    def _render_str(content: Any) -> str:
+        return ORJSONResponse._render(content).decode("utf-8")
+
+
+def toorjson(value):
+    return markupsafe.Markup(
+        ORJSONResponse._render_str(value)
+        .replace("<", "\\u003c")
+        .replace(">", "\\u003e")
+        .replace("&", "\\u0026")
+        .replace("'", "\\u0027")
+    )
+
+
+templates = Jinja2Templates(directory=STATIC_TEMPLATE_LIB)
+templates.env.filters["toorjson"] = toorjson
+
+client = httpx.AsyncClient()
+
+###########
+# Auth
+###########
+
+
+class App(FastAPI):
+    """
+    FastAPI App Wrapper
+    """
+
+    def __init__(self, **kwargs):
+        self.tokens = {}
+        self.auth = None
+        self.blocks: gradio.Blocks | None = None
+        self.state_holder = {}
+        self.iterators = defaultdict(dict)
+        self.lock = asyncio.Lock()
+        self.queue_token = secrets.token_urlsafe(32)
+        self.startup_events_triggered = False
+        self.uploaded_file_dir = os.environ.get("GRADIO_TEMP_DIR") or str(
+            Path(tempfile.gettempdir()) / "gradio"
+        )
+        # Allow user to manually set `docs_url` and `redoc_url`
+        # when instantiating an App; when they're not set, disable docs and redoc.
+        kwargs.setdefault("docs_url", None)
+        kwargs.setdefault("redoc_url", None)
+        super().__init__(**kwargs)
+
+    def configure_app(self, blocks: gradio.Blocks) -> None:
+        auth = blocks.auth
+        if auth is not None:
+            if not callable(auth):
+                self.auth = {account[0]: account[1] for account in auth}
+            else:
+                self.auth = auth
+        else:
+            self.auth = None
+
+        self.blocks = blocks
+        if hasattr(self.blocks, "_queue"):
+            self.blocks._queue.set_access_token(self.queue_token)
+        self.cwd = os.getcwd()
+        self.favicon_path = blocks.favicon_path
+        self.tokens = {}
+        self.root_path = blocks.root_path
+
+    def get_blocks(self) -> gradio.Blocks:
+        if self.blocks is None:
+            raise ValueError("No Blocks has been configured for this app.")
+        return self.blocks
+
+    def build_proxy_request(self, url_path):
+        url = httpx.URL(url_path)
+        assert self.blocks
+        # Don't proxy a URL unless it's a URL specifically loaded by the user using
+        # gr.load() to prevent SSRF or harvesting of HF tokens by malicious Spaces.
+        is_safe_url = any(
+            url.host == httpx.URL(root).host for root in self.blocks.root_urls
+        )
+        if not is_safe_url:
+            raise PermissionError("This URL cannot be proxied.")
+        is_hf_url = url.host.endswith(".hf.space")
+        headers = {}
+        if Context.hf_token is not None and is_hf_url:
+            headers["Authorization"] = f"Bearer {Context.hf_token}"
+        rp_req = client.build_request("GET", url, headers=headers)
+        return rp_req
+
+    @staticmethod
+    def create_app(
+        blocks: gradio.Blocks, app_kwargs: Dict[str, Any] | None = None
+    ) -> App:
+        app_kwargs = app_kwargs or {}
+        app_kwargs.setdefault("default_response_class", ORJSONResponse)
+        app = App(**app_kwargs)
+        app.configure_app(blocks)
+
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=["*"],
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+
+        @app.get("/user")
+        @app.get("/user/")
+        def get_current_user(request: fastapi.Request) -> Optional[str]:
+            token = request.cookies.get("access-token") or request.cookies.get(
+                "access-token-unsecure"
+            )
+            return app.tokens.get(token)
+
+        @app.get("/login_check")
+        @app.get("/login_check/")
+        def login_check(user: str = Depends(get_current_user)):
+            if app.auth is None or user is not None:
+                return
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED, detail="Not authenticated"
+            )
+
+        async def ws_login_check(websocket: WebSocket) -> Optional[str]:
+            token = websocket.cookies.get("access-token") or websocket.cookies.get(
+                "access-token-unsecure"
+            )
+            return token  # token is returned to allow request in queue
+
+        @app.get("/token")
+        @app.get("/token/")
+        def get_token(request: fastapi.Request) -> dict:
+            token = request.cookies.get("access-token")
+            return {"token": token, "user": app.tokens.get(token)}
+
+        @app.get("/app_id")
+        @app.get("/app_id/")
+        def app_id(request: fastapi.Request) -> dict:
+            return {"app_id": app.get_blocks().app_id}
+
+        @app.post("/login")
+        @app.post("/login/")
+        def login(form_data: OAuth2PasswordRequestForm = Depends()):
+            username, password = form_data.username, form_data.password
+            if app.auth is None:
+                return RedirectResponse(url="/", status_code=status.HTTP_302_FOUND)
+            if (
+                not callable(app.auth)
+                and username in app.auth
+                and app.auth[username] == password
+            ) or (callable(app.auth) and app.auth.__call__(username, password)):
+                token = secrets.token_urlsafe(16)
+                app.tokens[token] = username
+                response = JSONResponse(content={"success": True})
+                response.set_cookie(
+                    key="access-token",
+                    value=token,
+                    httponly=True,
+                    samesite="none",
+                    secure=True,
+                )
+                response.set_cookie(
+                    key="access-token-unsecure", value=token, httponly=True
+                )
+                return response
+            else:
+                raise HTTPException(status_code=400, detail="Incorrect credentials.")
+
+        ###############
+        # Main Routes
+        ###############
+
+        @app.head("/", response_class=HTMLResponse)
+        @app.get("/", response_class=HTMLResponse)
+        def main(request: fastapi.Request, user: str = Depends(get_current_user)):
+            mimetypes.add_type("application/javascript", ".js")
+            blocks = app.get_blocks()
+            root_path = request.scope.get("root_path", "")
+
+            if app.auth is None or user is not None:
+                config = app.get_blocks().config
+                config["root"] = root_path
+            else:
+                config = {
+                    "auth_required": True,
+                    "auth_message": blocks.auth_message,
+                    "is_space": app.get_blocks().is_space,
+                    "root": root_path,
+                }
+
+            try:
+                template = (
+                    "frontend/share.html" if blocks.share else "frontend/index.html"
+                )
+                return templates.TemplateResponse(
+                    template,
+                    {"request": request, "config": config},
+                )
+            except TemplateNotFound as err:
+                if blocks.share:
+                    raise ValueError(
+                        "Did you install Gradio from source files? Share mode only "
+                        "works when Gradio is installed through the pip package."
+                    ) from err
+                else:
+                    raise ValueError(
+                        "Did you install Gradio from source files? You need to build "
+                        "the frontend by running /scripts/build_frontend.sh"
+                    ) from err
+
+        @app.get("/info/", dependencies=[Depends(login_check)])
+        @app.get("/info", dependencies=[Depends(login_check)])
+        def api_info(serialize: bool = True):
+            config = app.get_blocks().config
+            return gradio.blocks.get_api_info(config, serialize)  # type: ignore
+
+        @app.get("/config/", dependencies=[Depends(login_check)])
+        @app.get("/config", dependencies=[Depends(login_check)])
+        def get_config(request: fastapi.Request):
+            root_path = request.scope.get("root_path", "")
+            config = app.get_blocks().config
+            config["root"] = root_path
+            return config
+
+        @app.get("/static/{path:path}")
+        def static_resource(path: str):
+            static_file = safe_join(STATIC_PATH_LIB, path)
+            return FileResponse(static_file)
+
+        @app.get("/assets/{path:path}")
+        def build_resource(path: str):
+            build_file = safe_join(BUILD_PATH_LIB, path)
+            return FileResponse(build_file)
+
+        @app.get("/favicon.ico")
+        async def favicon():
+            blocks = app.get_blocks()
+            if blocks.favicon_path is None:
+                return static_resource("img/logo.svg")
+            else:
+                return FileResponse(blocks.favicon_path)
+
+        @app.head("/proxy={url_path:path}", dependencies=[Depends(login_check)])
+        @app.get("/proxy={url_path:path}", dependencies=[Depends(login_check)])
+        async def reverse_proxy(url_path: str):
+            # Adapted from: https://github.com/tiangolo/fastapi/issues/1788
+            try:
+                rp_req = app.build_proxy_request(url_path)
+            except PermissionError as err:
+                raise HTTPException(status_code=400, detail=str(err)) from err
+            rp_resp = await client.send(rp_req, stream=True)
+            return StreamingResponse(
+                rp_resp.aiter_raw(),
+                status_code=rp_resp.status_code,
+                headers=rp_resp.headers,  # type: ignore
+                background=BackgroundTask(rp_resp.aclose),
+            )
+
+        @app.head("/file={path_or_url:path}", dependencies=[Depends(login_check)])
+        @app.get("/file={path_or_url:path}", dependencies=[Depends(login_check)])
+        async def file(path_or_url: str, request: fastapi.Request):
+            blocks = app.get_blocks()
+            if utils.validate_url(path_or_url):
+                return RedirectResponse(
+                    url=path_or_url, status_code=status.HTTP_302_FOUND
+                )
+
+            abs_path = utils.abspath(path_or_url)
+
+            in_blocklist = any(
+                utils.is_in_or_equal(abs_path, blocked_path)
+                for blocked_path in blocks.blocked_paths
+            )
+            is_dotfile = any(part.startswith(".") for part in abs_path.parts)
+            is_dir = abs_path.is_dir()
+
+            if in_blocklist or is_dotfile or is_dir:
+                raise HTTPException(403, f"File not allowed: {path_or_url}.")
+            if not abs_path.exists():
+                raise HTTPException(404, f"File not found: {path_or_url}.")
+
+            in_app_dir = utils.is_in_or_equal(abs_path, app.cwd)
+            created_by_app = str(abs_path) in set().union(*blocks.temp_file_sets)
+            in_allowlist = any(
+                utils.is_in_or_equal(abs_path, allowed_path)
+                for allowed_path in blocks.allowed_paths
+            )
+            was_uploaded = utils.is_in_or_equal(abs_path, app.uploaded_file_dir)
+
+            if not (in_app_dir or created_by_app or in_allowlist or was_uploaded):
+                raise HTTPException(403, f"File not allowed: {path_or_url}.")
+
+            range_val = request.headers.get("Range", "").strip()
+            if range_val.startswith("bytes=") and "-" in range_val:
+                range_val = range_val[6:]
+                start, end = range_val.split("-")
+                if start.isnumeric() and end.isnumeric():
+                    start = int(start)
+                    end = int(end)
+                    response = ranged_response.RangedFileResponse(
+                        abs_path,
+                        ranged_response.OpenRange(start, end),
+                        dict(request.headers),
+                        stat_result=os.stat(abs_path),
+                    )
+                    return response
+            return FileResponse(abs_path, headers={"Accept-Ranges": "bytes"})
+
+        @app.get("/file/{path:path}", dependencies=[Depends(login_check)])
+        async def file_deprecated(path: str, request: fastapi.Request):
+            return await file(path, request)
+
+        @app.post("/reset/")
+        @app.post("/reset")
+        async def reset_iterator(body: ResetBody):
+            if body.session_hash not in app.iterators:
+                return {"success": False}
+            async with app.lock:
+                app.iterators[body.session_hash][body.fn_index] = None
+                app.iterators[body.session_hash]["should_reset"].add(body.fn_index)
+            return {"success": True}
+
+        async def run_predict(
+            body: PredictBody,
+            request: Request | List[Request],
+            fn_index_inferred: int,
+        ):
+            if hasattr(body, "session_hash"):
+                if body.session_hash not in app.state_holder:
+                    app.state_holder[body.session_hash] = {
+                        _id: deepcopy(getattr(block, "value", None))
+                        for _id, block in app.get_blocks().blocks.items()
+                        if getattr(block, "stateful", False)
+                    }
+                session_state = app.state_holder[body.session_hash]
+                iterators = app.iterators[body.session_hash]
+                # The should_reset set keeps track of the fn_indices
+                # that have been cancelled. When a job is cancelled,
+                # the /reset route will mark the jobs as having been reset.
+                # That way if the cancel job finishes BEFORE the job being cancelled
+                # the job being cancelled will not overwrite the state of the iterator.
+                # In all cases, should_reset will be the empty set the next time
+                # the fn_index is run.
+                app.iterators[body.session_hash]["should_reset"] = set()
+            else:
+                session_state = {}
+                iterators = {}
+            event_id = getattr(body, "event_id", None)
+            raw_input = body.data
+            fn_index = body.fn_index
+
+            dependency = app.get_blocks().dependencies[fn_index_inferred]
+            target = dependency["targets"][0] if len(dependency["targets"]) else None
+            event_data = EventData(
+                app.get_blocks().blocks.get(target) if target else None,
+                body.event_data,
+            )
+            batch = dependency["batch"]
+            if not (body.batched) and batch:
+                raw_input = [raw_input]
+            try:
+                with utils.MatplotlibBackendMananger():
+                    output = await app.get_blocks().process_api(
+                        fn_index=fn_index_inferred,
+                        inputs=raw_input,
+                        request=request,
+                        state=session_state,
+                        iterators=iterators,
+                        event_id=event_id,
+                        event_data=event_data,
+                    )
+                iterator = output.pop("iterator", None)
+                if hasattr(body, "session_hash"):
+                    if fn_index in app.iterators[body.session_hash]["should_reset"]:
+                        app.iterators[body.session_hash][fn_index] = None
+                    else:
+                        app.iterators[body.session_hash][fn_index] = iterator
+                if isinstance(output, Error):
+                    raise output
+            except BaseException as error:
+                show_error = app.get_blocks().show_error or isinstance(error, Error)
+                traceback.print_exc()
+                return JSONResponse(
+                    content={"error": str(error) if show_error else None},
+                    status_code=500,
+                )
+
+            if not (body.batched) and batch:
+                output["data"] = output["data"][0]
+            return output
+
+        # had to use '/run' endpoint for Colab compatibility, '/api' supported for backwards compatibility
+        @app.post("/run/{api_name}", dependencies=[Depends(login_check)])
+        @app.post("/run/{api_name}/", dependencies=[Depends(login_check)])
+        @app.post("/api/{api_name}", dependencies=[Depends(login_check)])
+        @app.post("/api/{api_name}/", dependencies=[Depends(login_check)])
+        async def predict(
+            api_name: str,
+            body: PredictBody,
+            request: fastapi.Request,
+            username: str = Depends(get_current_user),
+        ):
+            fn_index_inferred = None
+            if body.fn_index is None:
+                for i, fn in enumerate(app.get_blocks().dependencies):
+                    if fn["api_name"] == api_name:
+                        fn_index_inferred = i
+                        break
+                if fn_index_inferred is None:
+                    return JSONResponse(
+                        content={
+                            "error": f"This app has no endpoint /api/{api_name}/."
+                        },
+                        status_code=500,
+                    )
+            else:
+                fn_index_inferred = body.fn_index
+            if (
+                not app.get_blocks().api_open
+                and app.get_blocks().queue_enabled_for_fn(fn_index_inferred)
+                and f"Bearer {app.queue_token}" != request.headers.get("Authorization")
+            ):
+                raise HTTPException(
+                    status_code=status.HTTP_401_UNAUTHORIZED,
+                    detail="Not authorized to skip the queue",
+                )
+
+            # If this fn_index cancels jobs, then the only input we need is the
+            # current session hash
+            if app.get_blocks().dependencies[fn_index_inferred]["cancels"]:
+                body.data = [body.session_hash]
+            if body.request:
+                if body.batched:
+                    gr_request = [
+                        Request(username=username, **req) for req in body.request
+                    ]
+                else:
+                    assert isinstance(body.request, dict)
+                    gr_request = Request(username=username, **body.request)
+            else:
+                gr_request = Request(username=username, request=request)
+            result = await run_predict(
+                body=body,
+                fn_index_inferred=fn_index_inferred,
+                request=gr_request,
+            )
+            return result
+
+        @app.websocket("/queue/join")
+        async def join_queue(
+            websocket: WebSocket,
+            token: Optional[str] = Depends(ws_login_check),
+        ):
+            blocks = app.get_blocks()
+            if app.auth is not None and token is None:
+                await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
+                return
+            if blocks._queue.server_path is None:
+                app_url = get_server_url_from_ws_url(str(websocket.url))
+                blocks._queue.set_url(app_url)
+            await websocket.accept()
+            # In order to cancel jobs, we need the session_hash and fn_index
+            # to create a unique id for each job
+            try:
+                await asyncio.wait_for(
+                    websocket.send_json({"msg": "send_hash"}), timeout=5
+                )
+            except AsyncTimeOutError:
+                return
+
+            try:
+                session_info = await asyncio.wait_for(
+                    websocket.receive_json(), timeout=5
+                )
+            except AsyncTimeOutError:
+                return
+
+            event = Event(
+                websocket, session_info["session_hash"], session_info["fn_index"]
+            )
+            # set the token into Event to allow using the same token for call_prediction
+            event.token = token
+            event.session_hash = session_info["session_hash"]
+
+            # Continuous events are not put in the queue  so that they do not
+            # occupy the queue's resource as they are expected to run forever
+            if blocks.dependencies[event.fn_index].get("every", 0):
+                await cancel_tasks({f"{event.session_hash}_{event.fn_index}"})
+                await blocks._queue.reset_iterators(event.session_hash, event.fn_index)
+                task = run_coro_in_background(
+                    blocks._queue.process_events, [event], False
+                )
+                set_task_name(task, event.session_hash, event.fn_index, batch=False)
+            else:
+                rank = blocks._queue.push(event)
+
+                if rank is None:
+                    await blocks._queue.send_message(event, {"msg": "queue_full"})
+                    await event.disconnect()
+                    return
+                estimation = blocks._queue.get_estimation()
+                await blocks._queue.send_estimation(event, estimation, rank)
+            while True:
+                await asyncio.sleep(1)
+                if websocket.application_state == WebSocketState.DISCONNECTED:
+                    return
+
+        @app.get(
+            "/queue/status",
+            dependencies=[Depends(login_check)],
+            response_model=Estimation,
+        )
+        async def get_queue_status():
+            return app.get_blocks()._queue.get_estimation()
+
+        @app.post("/upload", dependencies=[Depends(login_check)])
+        async def upload_file(
+            files: List[UploadFile] = File(...),
+        ):
+            output_files = []
+            file_manager = gradio.File()
+            for input_file in files:
+                output_files.append(
+                    await file_manager.save_uploaded_file(
+                        input_file, app.uploaded_file_dir
+                    )
+                )
+            return output_files
+
+        @app.on_event("startup")
+        @app.get("/startup-events")
+        async def startup_events():
+            if not app.startup_events_triggered:
+                app.get_blocks().startup_events()
+                app.startup_events_triggered = True
+                return True
+            return False
+
+        @app.get("/theme.css", response_class=PlainTextResponse)
+        def theme_css():
+            return PlainTextResponse(app.get_blocks().theme_css, media_type="text/css")
+
+        @app.get("/robots.txt", response_class=PlainTextResponse)
+        def robots_txt():
+            if app.get_blocks().share:
+                return "User-agent: *\nDisallow: /"
+            else:
+                return "User-agent: *\nDisallow: "
+
+        return app
+
+
+########
+# Helper functions
+########
+
+
+def safe_join(directory: str, path: str) -> str:
+    """Safely path to a base directory to avoid escaping the base directory.
+    Borrowed from: werkzeug.security.safe_join"""
+    _os_alt_seps: List[str] = [
+        sep for sep in [os.path.sep, os.path.altsep] if sep is not None and sep != "/"
+    ]
+
+    if path == "":
+        raise HTTPException(400)
+
+    filename = posixpath.normpath(path)
+    fullpath = os.path.join(directory, filename)
+    if (
+        any(sep in filename for sep in _os_alt_seps)
+        or os.path.isabs(filename)
+        or filename == ".."
+        or filename.startswith("../")
+        or os.path.isdir(fullpath)
+    ):
+        raise HTTPException(403)
+
+    if not os.path.exists(fullpath):
+        raise HTTPException(404, "File not found")
+
+    return fullpath
+
+
+def get_types(cls_set: List[Type]):
+    docset = []
+    types = []
+    for cls in cls_set:
+        doc = inspect.getdoc(cls) or ""
+        doc_lines = doc.split("\n")
+        for line in doc_lines:
+            if "value (" in line:
+                types.append(line.split("value (")[1].split(")")[0])
+        docset.append(doc_lines[1].split(":")[-1])
+    return docset, types
+
+
+def get_server_url_from_ws_url(ws_url: str):
+    ws_url_parsed = urlparse(ws_url)
+    scheme = "http" if ws_url_parsed.scheme == "ws" else "https"
+    port = f":{ws_url_parsed.port}" if ws_url_parsed.port else ""
+    return f"{scheme}://{ws_url_parsed.hostname}{port}{ws_url_parsed.path.replace('queue/join', '')}"
+
+
+set_documentation_group("routes")
+
+
+class Obj:
+    """
+    Using a class to convert dictionaries into objects. Used by the `Request` class.
+    Credit: https://www.geeksforgeeks.org/convert-nested-python-dictionary-to-object/
+    """
+
+    def __init__(self, dict_):
+        self.__dict__.update(dict_)
+        for key, value in dict_.items():
+            if isinstance(value, (dict, list)):
+                value = Obj(value)
+            setattr(self, key, value)
+
+    def __getitem__(self, item):
+        return self.__dict__[item]
+
+    def __setitem__(self, item, value):
+        self.__dict__[item] = value
+
+    def __iter__(self):
+        for key, value in self.__dict__.items():
+            if isinstance(value, Obj):
+                yield (key, dict(value))
+            else:
+                yield (key, value)
+
+    def __contains__(self, item) -> bool:
+        if item in self.__dict__:
+            return True
+        for value in self.__dict__.values():
+            if isinstance(value, Obj) and item in value:
+                return True
+        return False
+
+    def keys(self):
+        return self.__dict__.keys()
+
+    def values(self):
+        return self.__dict__.values()
+
+    def items(self):
+        return self.__dict__.items()
+
+    def __str__(self) -> str:
+        return str(self.__dict__)
+
+    def __repr__(self) -> str:
+        return str(self.__dict__)
+
+
+@document()
+class Request:
+    """
+    A Gradio request object that can be used to access the request headers, cookies,
+    query parameters and other information about the request from within the prediction
+    function. The class is a thin wrapper around the fastapi.Request class. Attributes
+    of this class include: `headers`, `client`, `query_params`, and `path_params`. If
+    auth is enabled, the `username` attribute can be used to get the logged in user.
+    Example:
+        import gradio as gr
+        def echo(name, request: gr.Request):
+            print("Request headers dictionary:", request.headers)
+            print("IP address:", request.client.host)
+            return name
+        io = gr.Interface(echo, "textbox", "textbox").launch()
+    """
+
+    def __init__(
+        self,
+        request: fastapi.Request | None = None,
+        username: str | None = None,
+        **kwargs,
+    ):
+        """
+        Can be instantiated with either a fastapi.Request or by manually passing in
+        attributes (needed for websocket-based queueing).
+        Parameters:
+            request: A fastapi.Request
+        """
+        self.request = request
+        self.username = username
+        self.kwargs: Dict = kwargs
+
+    def dict_to_obj(self, d):
+        if isinstance(d, dict):
+            return json.loads(json.dumps(d), object_hook=Obj)
+        else:
+            return d
+
+    def __getattr__(self, name):
+        if self.request:
+            return self.dict_to_obj(getattr(self.request, name))
+        else:
+            try:
+                obj = self.kwargs[name]
+            except KeyError as ke:
+                raise AttributeError(
+                    f"'Request' object has no attribute '{name}'"
+                ) from ke
+            return self.dict_to_obj(obj)
+
+
+@document()
+def mount_gradio_app(
+    app: fastapi.FastAPI,
+    blocks: gradio.Blocks,
+    path: str,
+    gradio_api_url: str | None = None,
+    app_kwargs: dict[str, Any] | None = None,
+) -> fastapi.FastAPI:
+    """Mount a gradio.Blocks to an existing FastAPI application.
+
+    Parameters:
+        app: The parent FastAPI application.
+        blocks: The blocks object we want to mount to the parent app.
+        path: The path at which the gradio application will be mounted.
+        gradio_api_url: The full url at which the gradio app will run. This is only needed if deploying to Huggingface spaces of if the websocket endpoints of your deployed app are on a different network location than the gradio app. If deploying to spaces, set gradio_api_url to 'http://localhost:7860/'
+        app_kwargs: Additional keyword arguments to pass to the underlying FastAPI app as a dictionary of parameter keys and argument values. For example, `{"docs_url": "/docs"}`
+    Example:
+        from fastapi import FastAPI
+        import gradio as gr
+        app = FastAPI()
+        @app.get("/")
+        def read_main():
+            return {"message": "This is your main app"}
+        io = gr.Interface(lambda x: "Hello, " + x + "!", "textbox", "textbox")
+        app = gr.mount_gradio_app(app, io, path="/gradio")
+        # Then run `uvicorn run:app` from the terminal and navigate to http://localhost:8000/gradio.
+    """
+    blocks.dev_mode = False
+    blocks.config = blocks.get_config_file()
+    blocks.validate_queue_settings()
+    gradio_app = App.create_app(blocks, app_kwargs=app_kwargs)
+
+    @app.on_event("startup")
+    async def start_queue():
+        if gradio_app.get_blocks().enable_queue:
+            if gradio_api_url:
+                gradio_app.get_blocks()._queue.set_url(gradio_api_url)
+            gradio_app.get_blocks().startup_events()
+
+    app.mount(path, gradio_app)
+    return app

falcon/lib/python3.10/site-packages/gradio/strings.py

@@ -0,0 +1,45 @@
+import os
+import threading
+from typing import Dict
+
+import requests
+
+MESSAGING_API_ENDPOINT = "https://api.gradio.app/gradio-messaging/en"
+
+en = {
+    "RUNNING_LOCALLY": "Running on local URL:  {}",
+    "RUNNING_LOCALLY_SEPARATED": "Running on local URL:  {}://{}:{}",
+    "SHARE_LINK_DISPLAY": "Running on public URL: {}",
+    "COULD_NOT_GET_SHARE_LINK": "\nCould not create share link. Please check your internet connection or our status page: https://status.gradio.app. \n\nAlso please ensure that your antivirus or firewall is not blocking the binary file located at: {}",
+    "COLAB_NO_LOCAL": "Cannot display local interface on google colab, public link created.",
+    "PUBLIC_SHARE_TRUE": "\nTo create a public link, set `share=True` in `launch()`.",
+    "MODEL_PUBLICLY_AVAILABLE_URL": "Model available publicly at: {} (may take up to a minute for link to be usable)",
+    "GENERATING_PUBLIC_LINK": "Generating public link (may take a few seconds...):",
+    "BETA_INVITE": "\nThanks for being a Gradio user! If you have questions or feedback, please join our Discord server and chat with us: https://discord.gg/feTf9x3ZSB",
+    "COLAB_DEBUG_TRUE": "Colab notebook detected. This cell will run indefinitely so that you can see errors and logs. "
+    "To turn off, set debug=False in launch().",
+    "COLAB_DEBUG_FALSE": "Colab notebook detected. To show errors in colab notebook, set debug=True in launch()",
+    "COLAB_WARNING": "Note: opening Chrome Inspector may crash demo inside Colab notebooks.",
+    "SHARE_LINK_MESSAGE": "\nThis share link expires in 72 hours. For free permanent hosting and GPU upgrades, run `gradio deploy` from Terminal to deploy to Spaces (https://huggingface.co/spaces)",
+    "INLINE_DISPLAY_BELOW": "Interface loading below...",
+    "TIPS": [
+        "You can add authentication to your app with the `auth=` kwarg in the `launch()` command; for example: `gr.Interface(...).launch(auth=('username', 'password'))`",
+        "Let users specify why they flagged input with the `flagging_options=` kwarg; for example: `gr.Interface(..., flagging_options=['too slow', 'incorrect output', 'other'])`",
+        "You can show or hide the button for flagging with the `allow_flagging=` kwarg; for example: gr.Interface(..., allow_flagging=False)",
+        "The inputs and outputs flagged by the users are stored in the flagging directory, specified by the flagging_dir= kwarg. You can view this data through the interface by setting the examples= kwarg to the flagging directory; for example gr.Interface(..., examples='flagged')",
+        "You can add a title and description to your interface using the `title=` and `description=` kwargs. The `article=` kwarg can be used to add a description under the interface; for example gr.Interface(..., title='My app', description='Lorem ipsum'). Try using Markdown!",
+        "For a classification or regression model, set `interpretation='default'` to see why the model made a prediction.",
+    ],
+}
+
+
+def get_updated_messaging(en: Dict):
+    try:
+        updated_messaging = requests.get(MESSAGING_API_ENDPOINT, timeout=3).json()
+        en.update(updated_messaging)
+    except Exception:  # Use default messaging
+        pass
+
+
+if os.getenv("GRADIO_ANALYTICS_ENABLED", "True") == "True":
+    threading.Thread(target=get_updated_messaging, args=(en,)).start()

falcon/lib/python3.10/site-packages/gradio/templates.py

@@ -0,0 +1,574 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+import numpy as np
+from PIL.Image import Image
+
+from gradio import components
+
+
+class TextArea(components.Textbox):
+    """
+    Sets: lines=7
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: str | Callable | None = "",
+        *,
+        lines: int = 7,
+        max_lines: int = 20,
+        placeholder: str | None = None,
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = None,
+        visible: bool = True,
+        elem_id: str | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            lines=lines,
+            max_lines=max_lines,
+            placeholder=placeholder,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            **kwargs,
+        )
+
+
+class Webcam(components.Image):
+    """
+    Sets: source="webcam", interactive=True
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: str | Image | np.ndarray | None = None,
+        *,
+        shape: tuple[int, int] | None = None,
+        image_mode: str = "RGB",
+        invert_colors: bool = False,
+        source: str = "webcam",
+        tool: str | None = None,
+        type: str = "numpy",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = True,
+        visible: bool = True,
+        streaming: bool = False,
+        elem_id: str | None = None,
+        mirror_webcam: bool = True,
+        brush_radius: float | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            shape=shape,
+            image_mode=image_mode,
+            invert_colors=invert_colors,
+            source=source,
+            tool=tool,
+            type=type,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            streaming=streaming,
+            elem_id=elem_id,
+            mirror_webcam=mirror_webcam,
+            brush_radius=brush_radius,
+            **kwargs,
+        )
+
+
+class Sketchpad(components.Image):
+    """
+    Sets: image_mode="L", source="canvas", shape=(28, 28), invert_colors=True, interactive=True
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: str | Image | np.ndarray | None = None,
+        *,
+        shape: tuple[int, int] = (28, 28),
+        image_mode: str = "L",
+        invert_colors: bool = True,
+        source: str = "canvas",
+        tool: str | None = None,
+        type: str = "numpy",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = True,
+        visible: bool = True,
+        streaming: bool = False,
+        elem_id: str | None = None,
+        mirror_webcam: bool = True,
+        brush_radius: float | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            shape=shape,
+            image_mode=image_mode,
+            invert_colors=invert_colors,
+            source=source,
+            tool=tool,
+            type=type,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            streaming=streaming,
+            elem_id=elem_id,
+            mirror_webcam=mirror_webcam,
+            brush_radius=brush_radius,
+            **kwargs,
+        )
+
+
+class Paint(components.Image):
+    """
+    Sets: source="canvas", tool="color-sketch", interactive=True
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: str | Image | np.ndarray | None = None,
+        *,
+        shape: tuple[int, int] | None = None,
+        image_mode: str = "RGB",
+        invert_colors: bool = False,
+        source: str = "canvas",
+        tool: str = "color-sketch",
+        type: str = "numpy",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = True,
+        visible: bool = True,
+        streaming: bool = False,
+        elem_id: str | None = None,
+        mirror_webcam: bool = True,
+        brush_radius: float | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            shape=shape,
+            image_mode=image_mode,
+            invert_colors=invert_colors,
+            source=source,
+            tool=tool,
+            type=type,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            streaming=streaming,
+            elem_id=elem_id,
+            mirror_webcam=mirror_webcam,
+            brush_radius=brush_radius,
+            **kwargs,
+        )
+
+
+class ImageMask(components.Image):
+    """
+    Sets: source="upload", tool="sketch", interactive=True
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: str | Image | np.ndarray | None = None,
+        *,
+        shape: tuple[int, int] | None = None,
+        image_mode: str = "RGB",
+        invert_colors: bool = False,
+        source: str = "upload",
+        tool: str = "sketch",
+        type: str = "numpy",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = True,
+        visible: bool = True,
+        streaming: bool = False,
+        elem_id: str | None = None,
+        mirror_webcam: bool = True,
+        brush_radius: float | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            shape=shape,
+            image_mode=image_mode,
+            invert_colors=invert_colors,
+            source=source,
+            tool=tool,
+            type=type,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            streaming=streaming,
+            elem_id=elem_id,
+            mirror_webcam=mirror_webcam,
+            brush_radius=brush_radius,
+            **kwargs,
+        )
+
+
+class ImagePaint(components.Image):
+    """
+    Sets: source="upload", tool="color-sketch", interactive=True
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: str | Image | np.ndarray | None = None,
+        *,
+        shape: tuple[int, int] | None = None,
+        image_mode: str = "RGB",
+        invert_colors: bool = False,
+        source: str = "upload",
+        tool: str = "color-sketch",
+        type: str = "numpy",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = True,
+        visible: bool = True,
+        streaming: bool = False,
+        elem_id: str | None = None,
+        mirror_webcam: bool = True,
+        brush_radius: float | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            shape=shape,
+            image_mode=image_mode,
+            invert_colors=invert_colors,
+            source=source,
+            tool=tool,
+            type=type,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            streaming=streaming,
+            elem_id=elem_id,
+            mirror_webcam=mirror_webcam,
+            brush_radius=brush_radius,
+            **kwargs,
+        )
+
+
+class Pil(components.Image):
+    """
+    Sets: type="pil"
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: str | Image | np.ndarray | None = None,
+        *,
+        shape: tuple[int, int] | None = None,
+        image_mode: str = "RGB",
+        invert_colors: bool = False,
+        source: str = "upload",
+        tool: str | None = None,
+        type: str = "pil",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = None,
+        visible: bool = True,
+        streaming: bool = False,
+        elem_id: str | None = None,
+        mirror_webcam: bool = True,
+        brush_radius: float | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            shape=shape,
+            image_mode=image_mode,
+            invert_colors=invert_colors,
+            source=source,
+            tool=tool,
+            type=type,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            streaming=streaming,
+            elem_id=elem_id,
+            mirror_webcam=mirror_webcam,
+            brush_radius=brush_radius,
+            **kwargs,
+        )
+
+
+class PlayableVideo(components.Video):
+    """
+    Sets: format="mp4"
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: str | Callable | None = None,
+        *,
+        format: str | None = "mp4",
+        source: str = "upload",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = None,
+        visible: bool = True,
+        elem_id: str | None = None,
+        mirror_webcam: bool = True,
+        include_audio: bool | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            format=format,
+            source=source,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            mirror_webcam=mirror_webcam,
+            include_audio=include_audio,
+            **kwargs,
+        )
+
+
+class Microphone(components.Audio):
+    """
+    Sets: source="microphone"
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: str | tuple[int, np.ndarray] | Callable | None = None,
+        *,
+        source: str = "microphone",
+        type: str = "numpy",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = None,
+        visible: bool = True,
+        streaming: bool = False,
+        elem_id: str | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            source=source,
+            type=type,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            streaming=streaming,
+            elem_id=elem_id,
+            **kwargs,
+        )
+
+
+class Files(components.File):
+    """
+    Sets: file_count="multiple"
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: str | list[str] | Callable | None = None,
+        *,
+        file_count: str = "multiple",
+        type: str = "file",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = None,
+        visible: bool = True,
+        elem_id: str | None = None,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            file_count=file_count,
+            type=type,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            **kwargs,
+        )
+
+
+class Numpy(components.Dataframe):
+    """
+    Sets: type="numpy"
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: list[list[Any]] | Callable | None = None,
+        *,
+        headers: list[str] | None = None,
+        row_count: int | tuple[int, str] = (1, "dynamic"),
+        col_count: int | tuple[int, str] | None = None,
+        datatype: str | list[str] = "str",
+        type: str = "numpy",
+        max_rows: int | None = 20,
+        max_cols: int | None = None,
+        overflow_row_behaviour: str = "paginate",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = None,
+        visible: bool = True,
+        elem_id: str | None = None,
+        wrap: bool = False,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            headers=headers,
+            row_count=row_count,
+            col_count=col_count,
+            datatype=datatype,
+            type=type,
+            max_rows=max_rows,
+            max_cols=max_cols,
+            overflow_row_behaviour=overflow_row_behaviour,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            wrap=wrap,
+            **kwargs,
+        )
+
+
+class Matrix(components.Dataframe):
+    """
+    Sets: type="array"
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: list[list[Any]] | Callable | None = None,
+        *,
+        headers: list[str] | None = None,
+        row_count: int | tuple[int, str] = (1, "dynamic"),
+        col_count: int | tuple[int, str] | None = None,
+        datatype: str | list[str] = "str",
+        type: str = "array",
+        max_rows: int | None = 20,
+        max_cols: int | None = None,
+        overflow_row_behaviour: str = "paginate",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = None,
+        visible: bool = True,
+        elem_id: str | None = None,
+        wrap: bool = False,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            headers=headers,
+            row_count=row_count,
+            col_count=col_count,
+            datatype=datatype,
+            type=type,
+            max_rows=max_rows,
+            max_cols=max_cols,
+            overflow_row_behaviour=overflow_row_behaviour,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            wrap=wrap,
+            **kwargs,
+        )
+
+
+class List(components.Dataframe):
+    """
+    Sets: type="array", col_count=1
+    """
+
+    is_template = True
+
+    def __init__(
+        self,
+        value: list[list[Any]] | Callable | None = None,
+        *,
+        headers: list[str] | None = None,
+        row_count: int | tuple[int, str] = (1, "dynamic"),
+        col_count: int | tuple[int, str] = 1,
+        datatype: str | list[str] = "str",
+        type: str = "array",
+        max_rows: int | None = 20,
+        max_cols: int | None = None,
+        overflow_row_behaviour: str = "paginate",
+        label: str | None = None,
+        show_label: bool = True,
+        interactive: bool | None = None,
+        visible: bool = True,
+        elem_id: str | None = None,
+        wrap: bool = False,
+        **kwargs,
+    ):
+        super().__init__(
+            value=value,
+            headers=headers,
+            row_count=row_count,
+            col_count=col_count,
+            datatype=datatype,
+            type=type,
+            max_rows=max_rows,
+            max_cols=max_cols,
+            overflow_row_behaviour=overflow_row_behaviour,
+            label=label,
+            show_label=show_label,
+            interactive=interactive,
+            visible=visible,
+            elem_id=elem_id,
+            wrap=wrap,
+            **kwargs,
+        )
+
+
+Mic = Microphone

falcon/lib/python3.10/site-packages/gradio/templates/frontend/assets/Column-2853eb31.css

@@ -0,0 +1 @@
+div.svelte-vt1mxs{display:flex;position:relative;flex-direction:column}div.svelte-vt1mxs>*,div.svelte-vt1mxs>.form>*{width:var(--size-full)}.gap.svelte-vt1mxs{gap:var(--layout-gap)}.hide.svelte-vt1mxs{display:none}.compact.svelte-vt1mxs>*,.compact.svelte-vt1mxs .box{border-radius:0}.compact.svelte-vt1mxs,.panel.svelte-vt1mxs{border:solid var(--panel-border-width) var(--panel-border-color);border-radius:var(--container-radius);background:var(--panel-background-fill);padding:var(--spacing-lg)}

falcon/lib/python3.10/site-packages/gradio/templates/frontend/assets/Copy-143d56db.js

@@ -0,0 +1,2 @@
+import{S as p,i as c,s as h,B as a,C as e,g as u,E as i,F as n,q as g}from"./index-188ef5e8.js";function v(l){let t,s;return{c(){t=a("svg"),s=a("polyline"),e(s,"points","20 6 9 17 4 12"),e(t,"xmlns","http://www.w3.org/2000/svg"),e(t,"width","100%"),e(t,"height","100%"),e(t,"viewBox","0 0 24 24"),e(t,"fill","none"),e(t,"stroke","currentColor"),e(t,"stroke-width","3"),e(t,"stroke-linecap","round"),e(t,"stroke-linejoin","round")},m(o,r){u(o,t,r),i(t,s)},p:n,i:n,o:n,d(o){o&&g(t)}}}class m extends p{constructor(t){super(),c(this,t,null,v,h,{})}}function w(l){let t,s,o;return{c(){t=a("svg"),s=a("path"),o=a("path"),e(s,"fill","currentColor"),e(s,"d","M28 10v18H10V10h18m0-2H10a2 2 0 0 0-2 2v18a2 2 0 0 0 2 2h18a2 2 0 0 0 2-2V10a2 2 0 0 0-2-2Z"),e(o,"fill","currentColor"),e(o,"d","M4 18H2V4a2 2 0 0 1 2-2h14v2H4Z"),e(t,"xmlns","http://www.w3.org/2000/svg"),e(t,"width","100%"),e(t,"height","100%"),e(t,"viewBox","0 0 32 32")},m(r,d){u(r,t,d),i(t,s),i(t,o)},p:n,i:n,o:n,d(r){r&&g(t)}}}class x extends p{constructor(t){super(),c(this,t,null,w,h,{})}}export{x as C,m as a};
+//# sourceMappingURL=Copy-143d56db.js.map

falcon/lib/python3.10/site-packages/gradio/templates/frontend/assets/Form-68b374ed.js

@@ -0,0 +1,2 @@
+import{S as m,i as c,s as r,a4 as d,G as g,C as h,M as u,D as f,g as w,a6 as b,a7 as v,a8 as F,p as q,t as C,q as S}from"./index-188ef5e8.js";function y(n){let s,l;const _=n[4].default,t=d(_,n,n[3],null);return{c(){s=g("div"),t&&t.c(),h(s,"class","form svelte-b6y5bg"),u(s,"hidden",!n[0]),f(s,"flex-grow",n[1]),f(s,"min-width",`calc(min(${n[2]}px, 100%))`)},m(e,i){w(e,s,i),t&&t.m(s,null),l=!0},p(e,[i]){t&&t.p&&(!l||i&8)&&b(t,_,e,e[3],l?F(_,e[3],i,null):v(e[3]),null),(!l||i&1)&&u(s,"hidden",!e[0]),i&2&&f(s,"flex-grow",e[1]),i&4&&f(s,"min-width",`calc(min(${e[2]}px, 100%))`)},i(e){l||(q(t,e),l=!0)},o(e){C(t,e),l=!1},d(e){e&&S(s),t&&t.d(e)}}}function D(n,s,l){let{$$slots:_={},$$scope:t}=s,{visible:e=!0}=s,{scale:i=1}=s,{min_width:o=0}=s;return n.$$set=a=>{"visible"in a&&l(0,e=a.visible),"scale"in a&&l(1,i=a.scale),"min_width"in a&&l(2,o=a.min_width),"$$scope"in a&&l(3,t=a.$$scope)},[e,i,o,t,_]}class M extends m{constructor(s){super(),c(this,s,D,y,r,{visible:0,scale:1,min_width:2})}}export{M as F};
+//# sourceMappingURL=Form-68b374ed.js.map

falcon/lib/python3.10/site-packages/gradio/templates/frontend/assets/Info-b7dfbb56.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Info-b7dfbb56.js","sources":["../../../../js/atoms/src/Info.svelte"],"sourcesContent":["<div>\n\t<slot />\n</div>\n\n<style>\n\tdiv {\n\t\tmargin-bottom: var(--spacing-lg);\n\t\tcolor: var(--block-info-text-color);\n\t\tfont-weight: var(--block-info-text-weight);\n\t\tfont-size: var(--block-info-text-size);\n\t\tline-height: var(--line-sm);\n\t}\n</style>\n"],"names":["insert","target","div","anchor"],"mappings":"+RAAAA,EAEKC,EAAAC,EAAAC,CAAA"}

falcon/lib/python3.10/site-packages/gradio/templates/frontend/assets/Model3D-98fc2b2c.css

@@ -0,0 +1 @@
+.gallery.svelte-1ayixqk{padding:var(--size-1) var(--size-2)}

falcon/lib/python3.10/site-packages/gradio/templates/frontend/assets/TabItem.svelte_svelte_type_style_lang-f9698472.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TabItem.svelte_svelte_type_style_lang-f9698472.js","sources":["../../../../js/tabs/src/Tabs.svelte"],"sourcesContent":["<script context=\"module\">\n\texport const TABS = {};\n</script>\n\n<script lang=\"ts\">\n\timport { setContext, createEventDispatcher, tick } from \"svelte\";\n\timport { writable } from \"svelte/store\";\n\timport type { SelectData } from \"@gradio/utils\";\n\n\tinterface Tab {\n\t\tname: string;\n\t\tid: object;\n\t}\n\n\texport let visible: boolean = true;\n\texport let elem_id: string = \"id\";\n\texport let elem_classes: Array<string> = [];\n\texport let selected: number | string | object;\n\n\tlet tabs: Array<Tab> = [];\n\n\tconst selected_tab = writable<false | object | number | string>(false);\n\tconst selected_tab_index = writable<number>(0);\n\tconst dispatch = createEventDispatcher<{\n\t\tchange: undefined;\n\t\tselect: SelectData;\n\t}>();\n\n\tsetContext(TABS, {\n\t\tregister_tab: (tab: Tab) => {\n\t\t\ttabs.push({ name: tab.name, id: tab.id });\n\t\t\tselected_tab.update((current) => current ?? tab.id);\n\t\t\ttabs = tabs;\n\t\t\treturn tabs.length - 1;\n\t\t},\n\t\tunregister_tab: (tab: Tab) => {\n\t\t\tconst i = tabs.findIndex((t) => t.id === tab.id);\n\t\t\ttabs.splice(i, 1);\n\t\t\tselected_tab.update((current) =>\n\t\t\t\tcurrent === tab.id ? tabs[i]?.id || tabs[tabs.length - 1]?.id : current\n\t\t\t);\n\t\t},\n\t\tselected_tab,\n\t\tselected_tab_index\n\t});\n\n\tfunction change_tab(id: object | string | number) {\n\t\tselected = id;\n\t\t$selected_tab = id;\n\t\t$selected_tab_index = tabs.findIndex((t) => t.id === id);\n\t\tdispatch(\"change\");\n\t}\n\n\t$: selected !== null && change_tab(selected);\n</script>\n\n<div class=\"tabs {elem_classes.join(' ')}\" class:hide={!visible} id={elem_id}>\n\t<div class=\"tab-nav scroll-hide\">\n\t\t{#each tabs as t, i (t.id)}\n\t\t\t{#if t.id === $selected_tab}\n\t\t\t\t<button class=\"selected\">\n\t\t\t\t\t{t.name}\n\t\t\t\t</button>\n\t\t\t{:else}\n\t\t\t\t<button\n\t\t\t\t\ton:click={() => {\n\t\t\t\t\t\tchange_tab(t.id);\n\t\t\t\t\t\tdispatch(\"select\", { value: t.name, index: i });\n\t\t\t\t\t}}\n\t\t\t\t>\n\t\t\t\t\t{t.name}\n\t\t\t\t</button>\n\t\t\t{/if}\n\t\t{/each}\n\t</div>\n\t<slot />\n</div>\n\n<style>\n\t.tabs {\n\t\tposition: relative;\n\t}\n\n\t.hide {\n\t\tdisplay: none;\n\t}\n\n\t.tab-nav {\n\t\tdisplay: flex;\n\t\tposition: relative;\n\t\tflex-wrap: wrap;\n\t\tborder-bottom: 1px solid var(--border-color-primary);\n\t}\n\n\tbutton {\n\t\tmargin-bottom: -1px;\n\t\tborder: 1px solid transparent;\n\t\tborder-color: transparent;\n\t\tborder-bottom: none;\n\t\tborder-top-right-radius: var(--container-radius);\n\t\tborder-top-left-radius: var(--container-radius);\n\t\tpadding: var(--size-1) var(--size-4);\n\t\tcolor: var(--body-text-color-subdued);\n\t\tfont-weight: var(--section-header-text-weight);\n\t\tfont-size: var(--section-header-text-size);\n\t}\n\n\tbutton:hover {\n\t\tcolor: var(--body-text-color);\n\t}\n\t.selected {\n\t\tborder-color: var(--border-color-primary);\n\t\tbackground: var(--background-fill-primary);\n\t\tcolor: var(--body-text-color);\n\t}\n\n\t.bar {\n\t\tdisplay: block;\n\t\tposition: absolute;\n\t\tbottom: -2px;\n\t\tleft: 0;\n\t\tz-index: 999;\n\t\tbackground: var(--background-fill-primary);\n\t\twidth: 100%;\n\t\theight: 2px;\n\t\tcontent: \"\";\n\t}\n</style>\n"],"names":["t0_value","ctx","insert","target","button","anchor","dirty","set_data","t0","create_if_block","get_key","i","div1","append","div0","TABS","visible","$$props","elem_id","elem_classes","selected","tabs","selected_tab","writable","selected_tab_index","dispatch","createEventDispatcher","setContext","tab","current","t","change_tab","id","$$invalidate","set_store_value","$selected_tab","$selected_tab_index"],"mappings":"mTAsEMA,EAAAC,MAAE,KAAI,6HANRC,EAOQC,EAAAC,EAAAC,CAAA,uDADNC,EAAA,GAAAN,KAAAA,EAAAC,MAAE,KAAI,KAAAM,EAAAC,EAAAR,CAAA,+CATNA,EAAAC,MAAE,KAAI,2FADRC,EAEQC,EAAAC,EAAAC,CAAA,wBADNC,EAAA,GAAAN,KAAAA,EAAAC,MAAE,KAAI,KAAAM,EAAAC,EAAAR,CAAA,iEAFJC,EAAC,EAAA,EAAC,KAAOA,EAAa,CAAA,EAAAQ,oRADrBR,EAAI,CAAA,EAAU,MAAAS,EAAAT,GAAAA,MAAE,mBAArB,OAAIU,GAAA,EAAA,kPAFUV,EAAY,CAAA,EAAC,KAAK,GAAG,EAAA,gBAAA,WAA8BA,EAAO,CAAA,CAAA,cAApBA,EAAO,CAAA,CAAA,UAA/DC,EAoBKC,EAAAS,EAAAP,CAAA,EAnBJQ,EAiBKD,EAAAE,CAAA,kGAhBGb,EAAI,CAAA,mIAFKA,EAAY,CAAA,EAAC,KAAK,GAAG,EAAA,uDAA8BA,EAAO,CAAA,CAAA,yBAApBA,EAAO,CAAA,CAAA,gHAvDjDc,EAAI,CAAA,uDAaN,CAAA,QAAAC,EAAmB,EAAI,EAAAC,EACvB,CAAA,QAAAC,EAAkB,IAAI,EAAAD,GACtB,aAAAE,EAAY,EAAA,EAAAF,GACZ,SAAAG,CAAkC,EAAAH,EAEzCI,EAAI,CAAA,QAEFC,EAAeC,EAA2C,EAAK,2BAC/DC,EAAqBD,EAAiB,CAAC,sBACvC,MAAAE,EAAWC,IAKjBC,EAAWZ,EAAI,CACd,aAAea,IACdP,EAAK,KAAO,CAAA,KAAMO,EAAI,KAAM,GAAIA,EAAI,EAAE,CAAA,EACtCN,EAAa,OAAQO,GAAYA,GAAWD,EAAI,EAAE,SAE3CP,EAAK,OAAS,GAEtB,eAAiBO,GAAQ,CAClB,MAAAjB,EAAIU,EAAK,UAAWS,GAAMA,EAAE,KAAOF,EAAI,EAAE,EAC/CP,EAAK,OAAOV,EAAG,CAAC,EAChBW,EAAa,OAAQO,GACpBA,IAAYD,EAAI,GAAKP,EAAKV,CAAC,GAAG,IAAMU,EAAKA,EAAK,OAAS,CAAC,GAAG,GAAKQ,CAAO,GAGzE,aAAAP,EACA,mBAAAE,IAGQ,SAAAO,EAAWC,EAA4B,CAC/CC,EAAA,EAAAb,EAAWY,CAAE,EACbE,EAAAZ,EAAAa,EAAgBH,EAAEG,CAAA,MAClBC,EAAsBf,EAAK,UAAWS,GAAMA,EAAE,KAAOE,CAAE,EAAAI,CAAA,EACvDX,EAAS,QAAQ,kBAgBbM,EAAWD,EAAE,EAAE,EACfL,EAAS,SAAQ,CAAI,MAAOK,EAAE,KAAM,MAAOnB,CAAC,CAAA,qOAd9CS,IAAa,MAAQW,EAAWX,CAAQ"}

falcon/lib/python3.10/site-packages/gradio/templates/frontend/assets/UploadText-2a4d151d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UploadText-2a4d151d.js","sources":["../../../../js/app/src/components/UploadText.svelte"],"sourcesContent":["<script lang=\"ts\">\n\timport { _ } from \"svelte-i18n\";\n\n\texport let type: \"video\" | \"image\" | \"audio\" | \"file\" | \"csv\" = \"file\";\n\n\tconst defs = {\n\t\timage: \"interface.drop_image\",\n\t\tvideo: \"interface.drop_video\",\n\t\taudio: \"interface.drop_audio\",\n\t\tfile: \"interface.drop_file\",\n\t\tcsv: \"interface.drop_csv\"\n\t};\n</script>\n\n<div class=\"wrap\">\n\t{$_(defs[type])}\n\t<span class=\"or\">- {$_(\"or\")} -</span>\n\t{$_(\"interface.click_to_upload\")}\n</div>\n\n<style>\n\t.wrap {\n\t\tdisplay: flex;\n\t\tflex-direction: column;\n\t\tjustify-content: center;\n\t\tmin-height: var(--size-60);\n\t\tcolor: var(--block-label-text-color);\n\t\tline-height: var(--line-md);\n\t}\n\n\t.or {\n\t\tcolor: var(--body-text-color-subdued);\n\t}\n\n\t@media (--screen-md) {\n\t\t.wrap {\n\t\t\tfont-size: var(--text-lg);\n\t\t}\n\t}\n</style>\n"],"names":["ctx","t3_value","t6_value","insert","target","div","anchor","append","span","set_data","t0","t0_value","dirty","t3","t6","type","$$props","defs"],"mappings":"2LAeEA,EAAE,CAAA,EAACA,EAAI,CAAA,EAACA,EAAI,CAAA,CAAA,CAAA,EAAA,WACOC,EAAAD,KAAG,IAAI,EAAA,SAC1BE,EAAAF,KAAG,2BAA2B,EAAA,wDADd,IAAE,aAAU,IAAE,yFAFhCG,EAIKC,EAAAC,EAAAC,CAAA,gBAFJC,EAAqCF,EAAAG,CAAA,2DADpCR,EAAE,CAAA,EAACA,EAAI,CAAA,EAACA,EAAI,CAAA,CAAA,CAAA,EAAA,KAAAS,EAAAC,EAAAC,CAAA,EACOC,EAAA,GAAAX,KAAAA,EAAAD,KAAG,IAAI,EAAA,KAAAS,EAAAI,EAAAZ,CAAA,EAC1BW,EAAA,GAAAV,KAAAA,EAAAF,KAAG,2BAA2B,EAAA,KAAAS,EAAAK,EAAAZ,CAAA,qEAdpB,GAAA,CAAA,KAAAa,EAAqD,MAAM,EAAAC,QAEhEC,EAAI,CACT,MAAO,uBACP,MAAO,uBACP,MAAO,uBACP,KAAM,sBACN,IAAK"}

falcon/lib/python3.10/site-packages/gradio/templates/frontend/assets/dsv-576afacd.js

@@ -0,0 +1,6 @@
+var D={},A={},E=34,m=10,R=13;function I(r){return new Function("d","return {"+r.map(function(t,e){return JSON.stringify(t)+": d["+e+'] || ""'}).join(",")+"}")}function B(r,t){var e=I(r);return function(a,c){return t(e(a),c,r)}}function F(r){var t=Object.create(null),e=[];return r.forEach(function(a){for(var c in a)c in t||e.push(t[c]=c)}),e}function f(r,t){var e=r+"",a=e.length;return a<t?new Array(t-a+1).join(0)+e:e}function L(r){return r<0?"-"+f(-r,6):r>9999?"+"+f(r,6):f(r,4)}function S(r){var t=r.getUTCHours(),e=r.getUTCMinutes(),a=r.getUTCSeconds(),c=r.getUTCMilliseconds();return isNaN(r)?"Invalid Date":L(r.getUTCFullYear())+"-"+f(r.getUTCMonth()+1,2)+"-"+f(r.getUTCDate(),2)+(c?"T"+f(t,2)+":"+f(e,2)+":"+f(a,2)+"."+f(c,3)+"Z":a?"T"+f(t,2)+":"+f(e,2)+":"+f(a,2)+"Z":e||t?"T"+f(t,2)+":"+f(e,2)+"Z":"")}function Z(r){var t=new RegExp('["'+r+`
+\r]`),e=r.charCodeAt(0);function a(n,o){var s,i,u=c(n,function(h,l){if(s)return s(h,l-1);i=h,s=o?B(h,o):I(h)});return u.columns=i||[],u}function c(n,o){var s=[],i=n.length,u=0,h=0,l,v=i<=0,C=!1;n.charCodeAt(i-1)===m&&--i,n.charCodeAt(i-1)===R&&--i;function w(){if(v)return A;if(C)return C=!1,D;var j,d=u,p;if(n.charCodeAt(d)===E){for(;u++<i&&n.charCodeAt(u)!==E||n.charCodeAt(++u)===E;);return(j=u)>=i?v=!0:(p=n.charCodeAt(u++))===m?C=!0:p===R&&(C=!0,n.charCodeAt(u)===m&&++u),n.slice(d+1,j-1).replace(/""/g,'"')}for(;u<i;){if((p=n.charCodeAt(j=u++))===m)C=!0;else if(p===R)C=!0,n.charCodeAt(u)===m&&++u;else if(p!==e)continue;return n.slice(d,j)}return v=!0,n.slice(d,i)}for(;(l=w())!==A;){for(var T=[];l!==D&&l!==A;)T.push(l),l=w();o&&(T=o(T,h++))==null||s.push(T)}return s}function U(n,o){return n.map(function(s){return o.map(function(i){return g(s[i])}).join(r)})}function O(n,o){return o==null&&(o=F(n)),[o.map(g).join(r)].concat(U(n,o)).join(`
+`)}function M(n,o){return o==null&&(o=F(n)),U(n,o).join(`
+`)}function b(n){return n.map(N).join(`
+`)}function N(n){return n.map(g).join(r)}function g(n){return n==null?"":n instanceof Date?S(n):t.test(n+="")?'"'+n.replace(/"/g,'""')+'"':n}return{parse:a,parseRows:c,format:O,formatBody:M,formatRows:b,formatRow:N,formatValue:g}}export{Z as d};
+//# sourceMappingURL=dsv-576afacd.js.map

falcon/lib/python3.10/site-packages/gradio/templates/frontend/assets/index-0008c077.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-0008c077.js","sources":["../../../../js/icons/src/Music.svelte","../../../../node_modules/.pnpm/svelte-range-slider-pips@2.0.2/node_modules/svelte-range-slider-pips/src/RangePips.svelte","../../../../node_modules/.pnpm/svelte-range-slider-pips@2.0.2/node_modules/svelte-range-slider-pips/src/RangeSlider.svelte","../../../../js/audio/src/Audio.svelte","../../../../js/audio/src/StaticAudio.svelte","../../../../js/app/src/components/Audio/Audio.svelte","../../../../js/app/src/components/Audio/index.ts"],"sourcesContent":["<svg\n\txmlns=\"http://www.w3.org/2000/svg\"\n\twidth=\"100%\"\n\theight=\"100%\"\n\tviewBox=\"0 0 24 24\"\n\tfill=\"none\"\n\tstroke=\"currentColor\"\n\tstroke-width=\"1.5\"\n\tstroke-linecap=\"round\"\n\tstroke-linejoin=\"round\"\n\tclass=\"feather feather-music\"\n>\n\t<path d=\"M9 18V5l12-2v13\" />\n\t<circle cx=\"6\" cy=\"18\" r=\"3\" />\n\t<circle cx=\"18\" cy=\"16\" r=\"3\" />\n</svg>\n","<script>\n\n  // range slider props\n  export let range = false;\n  export let min = 0;\n  export let max = 100;\n  export let step = 1;\n  export let values = [(max + min) / 2];\n  export let vertical = false;\n  export let reversed = false;\n  export let hoverable = true;\n  export let disabled = false;\n\n  // range pips / values props\n  export let pipstep = undefined;\n  export let all = true;\n  export let first = undefined;\n  export let last = undefined;\n  export let rest = undefined;\n\n  // formatting props\n  export let prefix = \"\";\n  export let suffix = \"\";\n  export let formatter = (v,i) => v;\n\n  // stylistic props\n  export let focus = undefined;\n  export let orientationStart = undefined;\n\n  // methods\n  export let percentOf = undefined;\n  export let moveHandle = undefined;\n\n  $: pipStep = pipstep || ((max - min) / step >= ( vertical ? 50 : 100 ) ? (max - min) / ( vertical ? 10 : 20 ) : 1);\n\n  $: pipCount = parseInt((max - min) / (step * pipStep), 10);\n\n  $: pipVal = function(val) {\n    return min + val * step * pipStep;\n  };\n\n  $: isSelected = function(val) {\n    return values.some(v => v === val);\n  };\n\n  $: inRange = function(val) {\n    if (range === \"min\") {\n      return values[0] > val;\n    } else if (range === \"max\") {\n      return values[0] < val;\n    } else if (range) {\n      return values[0] < val && values[1] > val;\n    }\n  };\n\n  function labelClick(val) {\n    moveHandle( undefined, val );\n  }\n</script>\n\n<style>\n  :global(.rangeSlider) {\n    --pip: var(--range-pip, lightslategray);\n    --pip-text: var(--range-pip-text, var(--pip));\n    --pip-active: var(--range-pip-active, darkslategrey);\n    --pip-active-text: var(--range-pip-active-text, var(--pip-active));\n    --pip-hover: var(--range-pip-hover, darkslategrey);\n    --pip-hover-text: var(--range-pip-hover-text, var(--pip-hover));\n    --pip-in-range: var(--range-pip-in-range, var(--pip-active));\n    --pip-in-range-text: var(--range-pip-in-range-text, var(--pip-active-text));\n  }\n  :global(.rangePips) {\n    position: absolute;\n    height: 1em;\n    left: 0;\n    right: 0;\n    bottom: -1em;\n  }\n  :global(.rangePips.vertical) {\n    height: auto;\n    width: 1em;\n    left: 100%;\n    right: auto;\n    top: 0;\n    bottom: 0;\n  }\n  :global(.rangePips .pip) {\n    height: 0.4em;\n    position: absolute;\n    top: 0.25em;\n    width: 1px;\n    white-space: nowrap;\n  }\n  :global(.rangePips.vertical .pip) {\n    height: 1px;\n    width: 0.4em;\n    left: 0.25em;\n    top: auto;\n    bottom: auto;\n  }\n  :global(.rangePips .pipVal) {\n    position: absolute;\n    top: 0.4em;\n    transform: translate(-50%, 25%);\n  }\n  :global(.rangePips.vertical .pipVal) {\n    position: absolute;\n    top: 0;\n    left: 0.4em;\n    transform: translate(25%, -50%);\n  }\n  :global(.rangePips .pip) {\n    transition: all 0.15s ease;\n  }\n  :global(.rangePips .pipVal) {\n    transition: all 0.15s ease, font-weight 0s linear;\n  }\n  :global(.rangePips .pip) {\n    color: lightslategray;\n    color: var(--pip-text);\n    background-color: lightslategray;\n    background-color: var(--pip);\n  }\n  :global(.rangePips .pip.selected) {\n    color: darkslategrey;\n    color: var(--pip-active-text);\n    background-color: darkslategrey;\n    background-color: var(--pip-active);\n  }\n  :global(.rangePips.hoverable:not(.disabled) .pip:hover) {\n    color: darkslategrey;\n    color: var(--pip-hover-text);\n    background-color: darkslategrey;\n    background-color: var(--pip-hover);\n  }\n  :global(.rangePips .pip.in-range) {\n    color: darkslategrey;\n    color: var(--pip-in-range-text);\n    background-color: darkslategrey;\n    background-color: var(--pip-in-range);\n  }\n  :global(.rangePips .pip.selected) {\n    height: 0.75em;\n  }\n  :global(.rangePips.vertical .pip.selected) {\n    height: 1px;\n    width: 0.75em;\n  }\n  :global(.rangePips .pip.selected .pipVal) {\n    font-weight: bold;\n    top: 0.75em;\n  }\n  :global(.rangePips.vertical .pip.selected .pipVal) {\n    top: 0;\n    left: 0.75em;\n  }\n  :global(.rangePips.hoverable:not(.disabled) .pip:not(.selected):hover) {\n    transition: none;\n  }\n  :global(.rangePips.hoverable:not(.disabled) .pip:not(.selected):hover .pipVal) {\n    transition: none;\n    font-weight: bold;\n  }\n</style>\n\n<div \n  class=\"rangePips\" \n  class:disabled\n  class:hoverable \n  class:vertical \n  class:reversed \n  class:focus \n>\n  {#if ( all && first !== false ) || first }\n    <span\n      class=\"pip first\"\n      class:selected={isSelected(min)}\n      class:in-range={inRange(min)}\n      style=\"{orientationStart}: 0%;\"\n      on:click={labelClick(min)}\n      on:touchend|preventDefault={labelClick(min)}\n    >\n      {#if all === 'label' || first === 'label'}\n        <span class=\"pipVal\">\n          {#if prefix}<span class=\"pipVal-prefix\">{prefix}</span>{/if}{formatter(min,0,0)}{#if suffix}<span class=\"pipVal-suffix\">{suffix}</span>{/if}\n        </span>\n      {/if}\n    </span>\n  {/if}\n\n  {#if ( all && rest !== false ) || rest}\n    {#each Array(pipCount + 1) as _, i}\n      {#if pipVal(i) !== min && pipVal(i) !== max}\n        <span\n          class=\"pip\"\n          class:selected={isSelected(pipVal(i))}\n          class:in-range={inRange(pipVal(i))}\n          style=\"{orientationStart}: {percentOf(pipVal(i))}%;\"\n          on:click={labelClick(pipVal(i))}\n          on:touchend|preventDefault={labelClick(pipVal(i))}\n        >\n          {#if all === 'label' || rest === 'label'}\n            <span class=\"pipVal\">\n              {#if prefix}<span class=\"pipVal-prefix\">{prefix}</span>{/if}{formatter(pipVal(i),i,percentOf(pipVal(i)))}{#if suffix}<span class=\"pipVal-suffix\">{suffix}</span>{/if}\n            </span>\n          {/if}\n        </span>\n      {/if}\n    {/each}\n  {/if}\n\n  {#if ( all && last !== false ) || last}\n    <span\n      class=\"pip last\"\n      class:selected={isSelected(max)}\n      class:in-range={inRange(max)}\n      style=\"{orientationStart}: 100%;\"\n      on:click={labelClick(max)}\n      on:touchend|preventDefault={labelClick(max)}\n    >\n      {#if all === 'label' || last === 'label'}\n        <span class=\"pipVal\">\n          {#if prefix}<span class=\"pipVal-prefix\">{prefix}</span>{/if}{formatter(max,pipCount,100)}{#if suffix}<span class=\"pipVal-suffix\">{suffix}</span>{/if}\n        </span>\n      {/if}\n    </span>\n  {/if}\n  \n</div>\n","<script>\n  import { spring } from \"svelte/motion\";\n  import { createEventDispatcher } from \"svelte\";\n  import RangePips from \"./RangePips.svelte\";\n\n  // dom references\n  export let slider;\n\n  // range slider props\n  export let range = false;\n  export let pushy = false;\n  export let min = 0;\n  export let max = 100;\n  export let step = 1;\n  export let values = [(max + min) / 2];\n  export let vertical = false;\n  export let float = false;\n  export let reversed = false;\n  export let hoverable = true;\n  export let disabled = false;\n\n  // range pips / values props\n  export let pips = false;\n  export let pipstep = undefined;\n  export let all = undefined;\n  export let first = undefined;\n  export let last = undefined;\n  export let rest = undefined;\n\n  // formatting props\n  export let id = undefined;\n  export let prefix = \"\";\n  export let suffix = \"\";\n  export let formatter = (v,i,p) => v;\n  export let handleFormatter = formatter;\n\n  // stylistic props\n  export let precision = 2;\n  export let springValues = { stiffness: 0.15, damping: 0.4 };\n\n  // prepare dispatched events\n  const dispatch = createEventDispatcher();\n\n  // state management\n  let valueLength = 0;\n  let focus = false;\n  let handleActivated = false;\n  let handlePressed = false;\n  let keyboardActive = false;\n  let activeHandle = values.length - 1;\n  let startValue;\n  let previousValue;\n\n  // copy the initial values in to a spring function which\n  // will update every time the values array is modified\n\n  let springPositions;\n\n  $: {\n\n    // check that \"values\" is an array, or set it as array\n    // to prevent any errors in springs, or range trimming\n    if ( !Array.isArray( values ) ) {\n      values = [(max + min) / 2];\n      console.error( \"'values' prop should be an Array (https://github.com/simeydotme/svelte-range-slider-pips#slider-props)\" );\n    }\n    // trim the range so it remains as a min/max (only 2 handles)\n    // and also align the handles to the steps\n    values = trimRange(values.map((v) => alignValueToStep(v)));\n\n    // check if the valueLength (length of values[]) has changed,\n    // because if so we need to re-seed the spring function with the\n    // new values array.\n    if ( valueLength !== values.length ) {\n      // set the initial spring values when the slider initialises,\n      // or when values array length has changed\n      springPositions = spring(values.map((v) => percentOf(v)), springValues );\n    } else {\n      // update the value of the spring function for animated handles\n      // whenever the values has updated\n      springPositions.set(values.map((v) => percentOf(v)));\n    }\n    // set the valueLength for the next check\n    valueLength = values.length;\n  };\n\n  /**\n   * take in a value, and then calculate that value's percentage\n   * of the overall range (min-max);\n   * @param {number} val the value we're getting percent for\n   * @return {number} the percentage value\n   **/\n  $: percentOf = function (val) {\n    let perc = ((val - min) / (max - min)) * 100;\n    if (isNaN(perc) || perc <= 0) {\n      return 0;\n    } else if (perc >= 100) {\n      return 100;\n    } else {\n      return parseFloat(perc.toFixed(precision));\n    }\n  };\n\n  /**\n   * clamp a value from the range so that it always\n   * falls within the min/max values\n   * @param {number} val the value to clamp\n   * @return {number} the value after it's been clamped\n   **/\n  $: clampValue = function (val) {\n    // return the min/max if outside of that range\n    return val <= min ? min : val >= max ? max : val;\n  };\n\n  /**\n   * align the value with the steps so that it\n   * always sits on the closest (above/below) step\n   * @param {number} val the value to align\n   * @return {number} the value after it's been aligned\n   **/\n  $: alignValueToStep = function (val) {\n    // sanity check for performance\n    if (val <= min) {\n      return min;\n    } else if (val >= max) {\n      return max;\n    }\n\n    // find the middle-point between steps\n    // and see if the value is closer to the\n    // next step, or previous step\n    let remainder = (val - min) % step;\n    let aligned = val - remainder;\n    if (Math.abs(remainder) * 2 >= step) {\n      aligned += remainder > 0 ? step : -step;\n    }\n    // make sure the value is within acceptable limits\n    aligned = clampValue(aligned);\n    // make sure the returned value is set to the precision desired\n    // this is also because javascript often returns weird floats\n    // when dealing with odd numbers and percentages\n\n    return parseFloat(aligned.toFixed(precision));\n  };\n\n  /**\n   * the orientation of the handles/pips based on the\n   * input values of vertical and reversed\n   **/\n  $: orientationStart = vertical ? reversed ? 'top' : 'bottom' : reversed ? 'right' : 'left';\n  $: orientationEnd = vertical ? reversed ? 'bottom' : 'top' : reversed ? 'left' : 'right';\n\n  /**\n   * helper func to get the index of an element in it's DOM container\n   * @param {object} el dom object reference we want the index of\n   * @returns {number} the index of the input element\n   **/\n  function index(el) {\n    if (!el) return -1;\n    var i = 0;\n    while ((el = el.previousElementSibling)) {\n      i++;\n    }\n    return i;\n  }\n\n  /**\n   * normalise a mouse or touch event to return the\n   * client (x/y) object for that event\n   * @param {event} e a mouse/touch event to normalise\n   * @returns {object} normalised event client object (x,y)\n   **/\n  function normalisedClient(e) {\n    if (e.type.includes(\"touch\")) {\n      return e.touches[0];\n    } else {\n      return e;\n    }\n  }\n\n  /**\n   * check if an element is a handle on the slider\n   * @param {object} el dom object reference we want to check\n   * @returns {boolean}\n   **/\n  function targetIsHandle(el) {\n    const handles = slider.querySelectorAll(\".handle\");\n    const isHandle = Array.prototype.includes.call(handles, el);\n    const isChild = Array.prototype.some.call(handles, (e) => e.contains(el));\n    return isHandle || isChild;\n  }\n\n  /**\n   * trim the values array based on whether the property\n   * for 'range' is 'min', 'max', or truthy. This is because we\n   * do not want more than one handle for a min/max range, and we do\n   * not want more than two handles for a true range.\n   * @param {array} values the input values for the rangeSlider\n   * @return {array} the range array for creating a rangeSlider\n   **/\n  function trimRange(values) {\n    if (range === \"min\" || range === \"max\") {\n      return values.slice(0, 1);\n    } else if (range) {\n      return values.slice(0, 2);\n    } else {\n      return values;\n    }\n  }\n\n  /**\n   * helper to return the slider dimensions for finding\n   * the closest handle to user interaction\n   * @return {object} the range slider DOM client rect\n   **/\n  function getSliderDimensions() {\n    return slider.getBoundingClientRect();\n  }\n\n  /**\n   * helper to return closest handle to user interaction\n   * @param {object} clientPos the client{x,y} positions to check against\n   * @return {number} the index of the closest handle to clientPos\n   **/\n  function getClosestHandle(clientPos) {\n    // first make sure we have the latest dimensions\n    // of the slider, as it may have changed size\n    const dims = getSliderDimensions();\n    // calculate the interaction position, percent and value\n    let handlePos = 0;\n    let handlePercent = 0;\n    let handleVal = 0;\n    if (vertical) {\n      handlePos = clientPos.clientY - dims.top;\n      handlePercent = (handlePos / dims.height) * 100;\n      handlePercent = reversed ? handlePercent : 100 - handlePercent;\n    } else {\n      handlePos = clientPos.clientX - dims.left;\n      handlePercent = (handlePos / dims.width) * 100;\n      handlePercent = reversed ? 100 - handlePercent : handlePercent;\n    }\n    handleVal = ((max - min) / 100) * handlePercent + min;\n\n    let closest;\n\n    // if we have a range, and the handles are at the same\n    // position, we want a simple check if the interaction\n    // value is greater than return the second handle\n    if (range === true && values[0] === values[1]) {\n      if (handleVal > values[1]) {\n        return 1;\n      } else {\n        return 0;\n      }\n      // if there are multiple handles, and not a range, then\n      // we sort the handles values, and return the first one closest\n      // to the interaction value\n    } else {\n      closest = values.indexOf(\n        [...values].sort((a, b) => Math.abs(handleVal - a) - Math.abs(handleVal - b))[0]\n      );\n    }\n    return closest;\n  }\n\n  /**\n   * take the interaction position on the slider, convert\n   * it to a value on the range, and then send that value\n   * through to the moveHandle() method to set the active\n   * handle's position\n   * @param {object} clientPos the client{x,y} of the interaction\n   **/\n  function handleInteract(clientPos) {\n    // first make sure we have the latest dimensions\n    // of the slider, as it may have changed size\n    const dims = getSliderDimensions();\n    // calculate the interaction position, percent and value\n    let handlePos = 0;\n    let handlePercent = 0;\n    let handleVal = 0;\n    if (vertical) {\n      handlePos = clientPos.clientY - dims.top;\n      handlePercent = (handlePos / dims.height) * 100;\n      handlePercent = reversed ? handlePercent : 100 - handlePercent;\n    } else {\n      handlePos = clientPos.clientX - dims.left;\n      handlePercent = (handlePos / dims.width) * 100;\n      handlePercent = reversed ? 100 - handlePercent : handlePercent;\n    }\n    handleVal = ((max - min) / 100) * handlePercent + min;\n    // move handle to the value\n    moveHandle(activeHandle, handleVal);\n  }\n\n  /**\n   * move a handle to a specific value, respecting the clamp/align rules\n   * @param {number} index the index of the handle we want to move\n   * @param {number} value the value to move the handle to\n   * @return {number} the value that was moved to (after alignment/clamping)\n   **/\n  function moveHandle(index, value) {\n    // align & clamp the value so we're not doing extra\n    // calculation on an out-of-range value down below\n    value = alignValueToStep(value);\n    // use the active handle if handle index is not provided\n    if ( typeof index === 'undefined' ) {\n      index = activeHandle;\n    }\n    // if this is a range slider perform special checks\n    if (range) {\n      // restrict the handles of a range-slider from\n      // going past one-another unless \"pushy\" is true\n      if (index === 0 && value > values[1]) {\n        if (pushy) {\n          values[1] = value;\n        } else {\n          value = values[1];\n        }\n      } else if (index === 1 && value < values[0]) {\n        if (pushy) {\n          values[0] = value;\n        } else {\n          value = values[0];\n        }\n      }\n    }\n\n    // if the value has changed, update it\n    if (values[index] !== value) {\n      values[index] = value;\n    }\n\n    // fire the change event when the handle moves,\n    // and store the previous value for the next time\n    if (previousValue !== value) {\n      eChange();\n      previousValue = value;\n    }\n    return value;\n  }\n\n  /**\n   * helper to find the beginning range value for use with css style\n   * @param {array} values the input values for the rangeSlider\n   * @return {number} the beginning of the range\n   **/\n  function rangeStart(values) {\n    if (range === \"min\") {\n      return 0;\n    } else {\n      return values[0];\n    }\n  }\n\n  /**\n   * helper to find the ending range value for use with css style\n   * @param {array} values the input values for the rangeSlider\n   * @return {number} the end of the range\n   **/\n  function rangeEnd(values) {\n    if (range === \"max\") {\n      return 0;\n    } else if (range === \"min\") {\n      return 100 - values[0];\n    } else {\n      return 100 - values[1];\n    }\n  }\n\n  /**\n   * when the user has unfocussed (blurred) from the\n   * slider, deactivate all handles\n   * @param {event} e the event from browser\n   **/\n  function sliderBlurHandle(e) {\n    if (keyboardActive) {\n      focus = false;\n      handleActivated = false;\n      handlePressed = false;\n    }\n  }\n\n  /**\n   * when the user focusses the handle of a slider\n   * set it to be active\n   * @param {event} e the event from browser\n   **/\n  function sliderFocusHandle(e) {\n    if ( !disabled ) {\n      activeHandle = index(e.target);\n      focus = true;\n    }\n  }\n\n  /**\n   * handle the keyboard accessible features by checking the\n   * input type, and modfier key then moving handle by appropriate amount\n   * @param {event} e the event from browser\n   **/\n  function sliderKeydown(e) {\n    if ( !disabled ) {\n      const handle = index(e.target);\n      let jump = e.ctrlKey || e.metaKey || e.shiftKey ? step * 10 : step;\n      let prevent = false;\n\n      switch (e.key) {\n        case \"PageDown\":\n          jump *= 10;\n        case \"ArrowRight\":\n        case \"ArrowUp\":\n          moveHandle(handle, values[handle] + jump);\n          prevent = true;\n          break;\n        case \"PageUp\":\n          jump *= 10;\n        case \"ArrowLeft\":\n        case \"ArrowDown\":\n          moveHandle(handle, values[handle] - jump);\n          prevent = true;\n          break;\n        case \"Home\":\n          moveHandle(handle, min);\n          prevent = true;\n          break;\n        case \"End\":\n          moveHandle(handle, max);\n          prevent = true;\n          break;\n      }\n      if (prevent) {\n        e.preventDefault();\n        e.stopPropagation();\n      }\n    }\n  }\n\n  /**\n   * function to run when the user touches\n   * down on the slider element anywhere\n   * @param {event} e the event from browser\n   **/\n  function sliderInteractStart(e) {\n    if ( !disabled ) {\n      const el = e.target;\n      const clientPos = normalisedClient(e);\n      // set the closest handle as active\n      focus = true;\n      handleActivated = true;\n      handlePressed = true;\n      activeHandle = getClosestHandle(clientPos);\n\n      // fire the start event\n      startValue = previousValue = alignValueToStep(values[activeHandle]);\n      eStart();\n\n      // for touch devices we want the handle to instantly\n      // move to the position touched for more responsive feeling\n      if (e.type === \"touchstart\" && !el.matches(\".pipVal\")) {\n        handleInteract(clientPos);\n      }\n    }\n  }\n\n  /**\n   * function to run when the user stops touching\n   * down on the slider element anywhere\n   * @param {event} e the event from browser\n   **/\n  function sliderInteractEnd(e) {\n    // fire the stop event for touch devices\n    if (e.type === \"touchend\") {\n      eStop();\n    }\n    handlePressed = false;\n  }\n\n  /**\n   * unfocus the slider if the user clicked off of\n   * it, somewhere else on the screen\n   * @param {event} e the event from browser\n   **/\n  function bodyInteractStart(e) {\n    keyboardActive = false;\n    if (focus && e.target !== slider && !slider.contains(e.target)) {\n      focus = false;\n    }\n  }\n\n  /**\n   * send the clientX through to handle the interaction\n   * whenever the user moves acros screen while active\n   * @param {event} e the event from browser\n   **/\n  function bodyInteract(e) {\n    if ( !disabled ) {\n      if (handleActivated) {\n        handleInteract(normalisedClient(e));\n      }\n    }\n  }\n\n  /**\n   * if user triggers mouseup on the body while\n   * a handle is active (without moving) then we\n   * trigger an interact event there\n   * @param {event} e the event from browser\n   **/\n  function bodyMouseUp(e) {\n    if ( !disabled ) {\n      const el = e.target;\n      // this only works if a handle is active, which can\n      // only happen if there was sliderInteractStart triggered\n      // on the slider, already\n      if (handleActivated) {\n        if (el === slider || slider.contains(el)) {\n          focus = true;\n          // don't trigger interact if the target is a handle (no need) or\n          // if the target is a label (we want to move to that value from rangePips)\n          if (!targetIsHandle(el) && !el.matches(\".pipVal\")) {\n            handleInteract(normalisedClient(e));\n          }\n        }\n        // fire the stop event for mouse device\n        // when the body is triggered with an active handle\n        eStop();\n      }\n    }\n    handleActivated = false;\n    handlePressed = false;\n  }\n\n  /**\n   * if user triggers touchend on the body then we\n   * defocus the slider completely\n   * @param {event} e the event from browser\n   **/\n  function bodyTouchEnd(e) {\n    handleActivated = false;\n    handlePressed = false;\n  }\n\n  function bodyKeyDown(e) {\n    if ( !disabled ) {\n      if (e.target === slider || slider.contains(e.target)) {\n        keyboardActive = true;\n      }\n    }\n  }\n\n  function eStart() {\n    !disabled && dispatch(\"start\", {\n      activeHandle,\n      value: startValue,\n      values: values.map((v) => alignValueToStep(v)),\n    });\n  }\n\n  function eStop() {\n    !disabled && dispatch(\"stop\", {\n      activeHandle,\n      startValue: startValue,\n      value: values[activeHandle],\n      values: values.map((v) => alignValueToStep(v)),\n    });\n  }\n\n  function eChange() {\n    !disabled && dispatch(\"change\", {\n      activeHandle,\n      startValue: startValue,\n      previousValue:\n        typeof previousValue === \"undefined\" ? startValue : previousValue,\n      value: values[activeHandle],\n      values: values.map((v) => alignValueToStep(v)),\n    });\n  }\n</script>\n\n<style>\n  :global(.rangeSlider) {\n    --slider: var(--range-slider, #d7dada);\n    --handle-inactive: var(--range-handle-inactive, #99a2a2);\n    --handle: var(--range-handle, #838de7);\n    --handle-focus: var(--range-handle-focus, #4a40d4);\n    --handle-border: var(--range-handle-border, var(--handle));\n    --range-inactive: var(--range-range-inactive, var(--handle-inactive));\n    --range: var(--range-range, var(--handle-focus));\n    --float-inactive: var(--range-float-inactive, var(--handle-inactive));\n    --float: var(--range-float, var(--handle-focus));\n    --float-text: var(--range-float-text, white);\n  }\n  :global(.rangeSlider) {\n    position: relative;\n    border-radius: 100px;\n    height: 0.5em;\n    margin: 1em;\n    transition: opacity 0.2s ease;\n    user-select: none;\n  }\n  :global(.rangeSlider *) {\n    user-select: none;\n  }\n  :global(.rangeSlider.pips) {\n    margin-bottom: 1.8em;\n  }\n  :global(.rangeSlider.pip-labels) {\n    margin-bottom: 2.8em;\n  }\n  :global(.rangeSlider.vertical) {\n    display: inline-block;\n    border-radius: 100px;\n    width: 0.5em;\n    min-height: 200px;\n  }\n  :global(.rangeSlider.vertical.pips) {\n    margin-right: 1.8em;\n    margin-bottom: 1em;\n  }\n  :global(.rangeSlider.vertical.pip-labels) {\n    margin-right: 2.8em;\n    margin-bottom: 1em;\n  }\n  :global(.rangeSlider .rangeHandle) {\n    position: absolute;\n    display: block;\n    height: 1.4em;\n    width: 1.4em;\n    top: 0.25em;\n    bottom: auto;\n    transform: translateY(-50%) translateX(-50%);\n    z-index: 2;\n  }\n  :global(.rangeSlider.reversed .rangeHandle) {\n    transform: translateY(-50%) translateX(50%);\n  }\n  :global(.rangeSlider.vertical .rangeHandle) {\n    left: 0.25em;\n    top: auto;\n    transform: translateY(50%) translateX(-50%);\n  }\n  :global(.rangeSlider.vertical.reversed .rangeHandle) {\n    transform: translateY(-50%) translateX(-50%);\n  }\n  :global(.rangeSlider .rangeNub),\n  :global(.rangeSlider .rangeHandle:before) {\n    position: absolute;\n    left: 0;\n    top: 0;\n    display: block;\n    border-radius: 10em;\n    height: 100%;\n    width: 100%;\n    transition: box-shadow 0.2s ease;\n  }\n  :global(.rangeSlider .rangeHandle:before) {\n    content: \"\";\n    left: 1px;\n    top: 1px;\n    bottom: 1px;\n    right: 1px;\n    height: auto;\n    width: auto;\n    box-shadow: 0 0 0 0px var(--handle-border);\n    opacity: 0;\n  }\n  :global(.rangeSlider.hoverable:not(.disabled) .rangeHandle:hover:before) {\n    box-shadow: 0 0 0 8px var(--handle-border);\n    opacity: 0.2;\n  }\n  :global(.rangeSlider.hoverable:not(.disabled) .rangeHandle.press:before),\n  :global(.rangeSlider.hoverable:not(.disabled) .rangeHandle.press:hover:before) {\n    box-shadow: 0 0 0 12px var(--handle-border);\n    opacity: 0.4;\n  }\n  :global(.rangeSlider.range:not(.min):not(.max) .rangeNub) {\n    border-radius: 10em 10em 10em 1.6em;\n  }\n  :global(.rangeSlider.range .rangeHandle:nth-of-type(1) .rangeNub) {\n    transform: rotate(-135deg);\n  }\n  :global(.rangeSlider.range .rangeHandle:nth-of-type(2) .rangeNub) {\n    transform: rotate(45deg);\n  }\n  :global(.rangeSlider.range.reversed .rangeHandle:nth-of-type(1) .rangeNub) {\n    transform: rotate(45deg);\n  }\n  :global(.rangeSlider.range.reversed .rangeHandle:nth-of-type(2) .rangeNub) {\n    transform: rotate(-135deg);\n  }\n  :global(.rangeSlider.range.vertical .rangeHandle:nth-of-type(1) .rangeNub) {\n    transform: rotate(135deg);\n  }\n  :global(.rangeSlider.range.vertical .rangeHandle:nth-of-type(2) .rangeNub) {\n    transform: rotate(-45deg);\n  }\n  :global(.rangeSlider.range.vertical.reversed .rangeHandle:nth-of-type(1) .rangeNub) {\n    transform: rotate(-45deg);\n  }\n  :global(.rangeSlider.range.vertical.reversed .rangeHandle:nth-of-type(2) .rangeNub) {\n    transform: rotate(135deg);\n  }\n  :global(.rangeSlider .rangeFloat) {\n    display: block;\n    position: absolute;\n    left: 50%;\n    top: -0.5em;\n    transform: translate(-50%, -100%);\n    font-size: 1em;\n    text-align: center;\n    opacity: 0;\n    pointer-events: none;\n    white-space: nowrap;\n    transition: all 0.2s ease;\n    font-size: 0.9em;\n    padding: 0.2em 0.4em;\n    border-radius: 0.2em;\n  }\n  :global(.rangeSlider .rangeHandle.active .rangeFloat),\n  :global(.rangeSlider.hoverable .rangeHandle:hover .rangeFloat) {\n    opacity: 1;\n    top: -0.2em;\n    transform: translate(-50%, -100%);\n  }\n  :global(.rangeSlider .rangeBar) {\n    position: absolute;\n    display: block;\n    transition: background 0.2s ease;\n    border-radius: 1em;\n    height: 0.5em;\n    top: 0;\n    user-select: none;\n    z-index: 1;\n  }\n  :global(.rangeSlider.vertical .rangeBar) {\n    width: 0.5em;\n    height: auto;\n  }\n  :global(.rangeSlider) {\n    background-color: #d7dada;\n    background-color: var(--slider);\n  }\n  :global(.rangeSlider .rangeBar) {\n    background-color: #99a2a2;\n    background-color: var(--range-inactive);\n  }\n  :global(.rangeSlider.focus .rangeBar) {\n    background-color: #838de7;\n    background-color: var(--range);\n  }\n  :global(.rangeSlider .rangeNub) {\n    background-color: #99a2a2;\n    background-color: var(--handle-inactive);\n  }\n  :global(.rangeSlider.focus .rangeNub) {\n    background-color: #838de7;\n    background-color: var(--handle);\n  }\n  :global(.rangeSlider .rangeHandle.active .rangeNub) {\n    background-color: #4a40d4;\n    background-color: var(--handle-focus);\n  }\n  :global(.rangeSlider .rangeFloat) {\n    color: white;\n    color: var(--float-text);\n    background-color: #99a2a2;\n    background-color: var(--float-inactive);\n  }\n  :global(.rangeSlider.focus .rangeFloat) {\n    background-color: #4a40d4;\n    background-color: var(--float);\n  }\n  :global(.rangeSlider.disabled) {\n    opacity: 0.5;\n  }\n  :global(.rangeSlider.disabled .rangeNub) {\n    background-color: #d7dada;\n    background-color: var(--slider);\n  }\n</style>\n\n<div\n  {id}\n  bind:this={slider}\n  class=\"rangeSlider\"\n  class:range\n  class:disabled\n  class:hoverable\n  class:vertical\n  class:reversed\n  class:focus\n  class:min={range === 'min'}\n  class:max={range === 'max'}\n  class:pips\n  class:pip-labels={all === 'label' || first === 'label' || last === 'label' || rest === 'label'}\n  on:mousedown={sliderInteractStart}\n  on:mouseup={sliderInteractEnd}\n  on:touchstart|preventDefault={sliderInteractStart}\n  on:touchend|preventDefault={sliderInteractEnd}\n>\n  {#each values as value, index}\n    <span\n      role=\"slider\"\n      class=\"rangeHandle\"\n      class:active={focus && activeHandle === index}\n      class:press={handlePressed && activeHandle === index}\n      data-handle={index}\n      on:blur={sliderBlurHandle}\n      on:focus={sliderFocusHandle}\n      on:keydown={sliderKeydown}\n      style=\"{orientationStart}: {$springPositions[index]}%; z-index: {activeHandle === index ? 3 : 2};\"\n      aria-valuemin={range === true && index === 1 ? values[0] : min}\n      aria-valuemax={range === true && index === 0 ? values[1] : max}\n      aria-valuenow={value}\n      aria-valuetext=\"{prefix}{handleFormatter(value,index,percentOf(value))}{suffix}\"\n      aria-orientation={vertical ? 'vertical' : 'horizontal'}\n      aria-disabled={disabled}\n      {disabled}\n      tabindex=\"{ disabled ? -1 : 0 }\"\n    >\n      <span class=\"rangeNub\" />\n      {#if float}\n        <span class=\"rangeFloat\">\n          {#if prefix}<span class=\"rangeFloat-prefix\">{prefix}</span>{/if}{handleFormatter(value,index,percentOf(value))}{#if suffix}<span class=\"rangeFloat-suffix\">{suffix}</span>{/if}\n        </span>\n      {/if}\n    </span>\n  {/each}\n  {#if range}\n    <span\n      class=\"rangeBar\"\n      style=\"{orientationStart}: {rangeStart($springPositions)}%; \n             {orientationEnd}: {rangeEnd($springPositions)}%;\" />\n  {/if}\n  {#if pips}\n    <RangePips\n      {values}\n      {min}\n      {max}\n      {step}\n      {range}\n      {vertical}\n      {reversed}\n      {orientationStart}\n      {hoverable}\n      {disabled}\n      {all}\n      {first}\n      {last}\n      {rest}\n      {pipstep}\n      {prefix}\n      {suffix}\n      {formatter}\n      {focus}\n      {percentOf}\n      {moveHandle}\n    />\n  {/if}\n</div>\n\n<svelte:window\n  on:mousedown={bodyInteractStart}\n  on:touchstart={bodyInteractStart}\n  on:mousemove={bodyInteract}\n  on:touchmove={bodyInteract}\n  on:mouseup={bodyMouseUp}\n  on:touchend={bodyTouchEnd}\n  on:keydown={bodyKeyDown} />\n","<script context=\"module\" lang=\"ts\">\n\timport type { FileData } from \"@gradio/upload\";\n\timport { Button } from \"@gradio/button\";\n\texport interface AudioData extends FileData {\n\t\tcrop_min?: number;\n\t\tcrop_max?: number;\n\t}\n</script>\n\n<script lang=\"ts\">\n\timport { onDestroy, createEventDispatcher, tick } from \"svelte\";\n\timport { Upload, ModifyUpload } from \"@gradio/upload\";\n\timport { BlockLabel } from \"@gradio/atoms\";\n\timport { Music } from \"@gradio/icons\";\n\t// @ts-ignore\n\timport Range from \"svelte-range-slider-pips\";\n\n\timport type { IBlobEvent, IMediaRecorder } from \"extendable-media-recorder\";\n\n\texport let value: null | { name: string; data: string } = null;\n\texport let label: string;\n\texport let show_label: boolean = true;\n\texport let name: string = \"\";\n\texport let source: \"microphone\" | \"upload\" | \"none\";\n\texport let pending: boolean = false;\n\texport let streaming: boolean = false;\n\texport let autoplay: boolean;\n\n\t// TODO: make use of this\n\t// export let type: \"normal\" | \"numpy\" = \"normal\";\n\n\tlet recording = false;\n\tlet recorder: IMediaRecorder;\n\tlet mode = \"\";\n\tlet header: Uint8Array | undefined = undefined;\n\tlet pending_stream: Array<Uint8Array> = [];\n\tlet submit_pending_stream_on_pending_end: boolean = false;\n\tlet player: HTMLAudioElement;\n\tlet inited = false;\n\tlet crop_values = [0, 100];\n\tconst STREAM_TIMESLICE = 500;\n\tconst NUM_HEADER_BYTES = 44;\n\tlet audio_chunks: Array<Blob> = [];\n\tlet audio_blob;\n\tlet module_promises:\n\t\t| [\n\t\t\t\tPromise<typeof import(\"extendable-media-recorder\")>,\n\t\t\t\tPromise<typeof import(\"extendable-media-recorder-wav-encoder\")>\n\t\t  ];\n\n\tfunction get_modules() {\n\t\tmodule_promises = [\n\t\t\timport(\"extendable-media-recorder\"),\n\t\t\timport(\"extendable-media-recorder-wav-encoder\")\n\t\t];\n\t}\n\n\tif (streaming) {\n\t\tget_modules();\n\t}\n\n\tconst dispatch = createEventDispatcher<{\n\t\tchange: AudioData;\n\t\tstream: AudioData;\n\t\tedit: AudioData;\n\t\tplay: undefined;\n\t\tpause: undefined;\n\t\tstop: undefined;\n\t\tend: undefined;\n\t\tdrag: boolean;\n\t\terror: string;\n\t\tupload: FileData;\n\t\tclear: undefined;\n\t\tstart_recording: undefined;\n\t\tstop_recording: undefined;\n\t}>();\n\n\tfunction blob_to_data_url(blob: Blob): Promise<string> {\n\t\treturn new Promise((fulfill, reject) => {\n\t\t\tlet reader = new FileReader();\n\t\t\treader.onerror = reject;\n\t\t\treader.onload = () => fulfill(reader.result as string);\n\t\t\treader.readAsDataURL(blob);\n\t\t});\n\t}\n\n\tconst dispatch_blob = async (\n\t\tblobs: Array<Uint8Array> | Blob[],\n\t\tevent: \"stream\" | \"change\"\n\t) => {\n\t\tlet audio_blob = new Blob(blobs, { type: \"audio/wav\" });\n\t\tvalue = {\n\t\t\tdata: await blob_to_data_url(audio_blob),\n\t\t\tname: \"audio.wav\"\n\t\t};\n\t\tdispatch(event, value);\n\t};\n\n\tasync function prepare_audio() {\n\t\tlet stream: MediaStream | null;\n\n\t\ttry {\n\t\t\tstream = await navigator.mediaDevices.getUserMedia({ audio: true });\n\t\t} catch (err) {\n\t\t\tif (err instanceof DOMException && err.name == \"NotAllowedError\") {\n\t\t\t\tdispatch(\n\t\t\t\t\t\"error\",\n\t\t\t\t\t\"Please allow access to the microphone for recording.\"\n\t\t\t\t);\n\t\t\t\treturn;\n\t\t\t} else {\n\t\t\t\tthrow err;\n\t\t\t}\n\t\t}\n\n\t\tif (stream == null) return;\n\n\t\tif (streaming) {\n\t\t\tconst [{ MediaRecorder, register }, { connect }] = await Promise.all(\n\t\t\t\tmodule_promises\n\t\t\t);\n\n\t\t\tawait register(await connect());\n\n\t\t\trecorder = new MediaRecorder(stream, { mimeType: \"audio/wav\" });\n\n\t\t\tasync function handle_chunk(event: IBlobEvent) {\n\t\t\t\tlet buffer = await event.data.arrayBuffer();\n\t\t\t\tlet payload = new Uint8Array(buffer);\n\t\t\t\tif (!header) {\n\t\t\t\t\theader = new Uint8Array(buffer.slice(0, NUM_HEADER_BYTES));\n\t\t\t\t\tpayload = new Uint8Array(buffer.slice(NUM_HEADER_BYTES));\n\t\t\t\t}\n\t\t\t\tif (pending) {\n\t\t\t\t\tpending_stream.push(payload);\n\t\t\t\t} else {\n\t\t\t\t\tlet blobParts = [header].concat(pending_stream, [payload]);\n\t\t\t\t\tdispatch_blob(blobParts, \"stream\");\n\t\t\t\t\tpending_stream = [];\n\t\t\t\t}\n\t\t\t}\n\t\t\trecorder.addEventListener(\"dataavailable\", handle_chunk);\n\t\t} else {\n\t\t\trecorder = new MediaRecorder(stream);\n\n\t\t\trecorder.addEventListener(\"dataavailable\", (event) => {\n\t\t\t\taudio_chunks.push(event.data);\n\t\t\t});\n\n\t\t\trecorder.addEventListener(\"stop\", async () => {\n\t\t\t\trecording = false;\n\t\t\t\tawait dispatch_blob(audio_chunks, \"change\");\n\t\t\t\taudio_chunks = [];\n\t\t\t});\n\t\t}\n\n\t\tinited = true;\n\t}\n\n\t$: if (submit_pending_stream_on_pending_end && pending === false) {\n\t\tsubmit_pending_stream_on_pending_end = false;\n\t\tif (header && pending_stream) {\n\t\t\tlet blobParts: Array<Uint8Array> = [header].concat(pending_stream);\n\t\t\tpending_stream = [];\n\t\t\tdispatch_blob(blobParts, \"stream\");\n\t\t}\n\t}\n\n\tasync function record() {\n\t\trecording = true;\n\t\tdispatch(\"start_recording\");\n\t\tif (!inited) await prepare_audio();\n\t\theader = undefined;\n\t\tif (streaming) {\n\t\t\trecorder.start(STREAM_TIMESLICE);\n\t\t} else {\n\t\t\trecorder.start();\n\t\t}\n\t}\n\n\tonDestroy(() => {\n\t\tif (recorder && recorder.state !== \"inactive\") {\n\t\t\trecorder.stop();\n\t\t}\n\t});\n\n\tconst stop = async () => {\n\t\tdispatch(\"stop_recording\");\n\t\trecorder.stop();\n\t\tif (streaming) {\n\t\t\trecording = false;\n\t\t\tif (pending) {\n\t\t\t\tsubmit_pending_stream_on_pending_end = true;\n\t\t\t}\n\t\t}\n\t};\n\n\tfunction clear() {\n\t\tdispatch(\"change\");\n\t\tdispatch(\"clear\");\n\t\tmode = \"\";\n\t\tvalue = null;\n\t}\n\n\tfunction loaded(node: HTMLAudioElement) {\n\t\tfunction clamp_playback() {\n\t\t\tconst start_time = (crop_values[0] / 100) * node.duration;\n\t\t\tconst end_time = (crop_values[1] / 100) * node.duration;\n\t\t\tif (node.currentTime < start_time) {\n\t\t\t\tnode.currentTime = start_time;\n\t\t\t}\n\n\t\t\tif (node.currentTime > end_time) {\n\t\t\t\tnode.currentTime = start_time;\n\t\t\t\tnode.pause();\n\t\t\t}\n\t\t}\n\n\t\tnode.addEventListener(\"timeupdate\", clamp_playback);\n\n\t\treturn {\n\t\t\tdestroy: () => node.removeEventListener(\"timeupdate\", clamp_playback)\n\t\t};\n\t}\n\n\tfunction handle_change({\n\t\tdetail: { values }\n\t}: {\n\t\tdetail: { values: [number, number] };\n\t}) {\n\t\tif (!value) return;\n\n\t\tdispatch(\"change\", {\n\t\t\tdata: value.data,\n\t\t\tname,\n\t\t\tcrop_min: values[0],\n\t\t\tcrop_max: values[1]\n\t\t});\n\n\t\tdispatch(\"edit\");\n\t}\n\n\tfunction handle_load({\n\t\tdetail\n\t}: {\n\t\tdetail: {\n\t\t\tdata: string;\n\t\t\tname: string;\n\t\t\tsize: number;\n\t\t\tis_example: boolean;\n\t\t};\n\t}) {\n\t\tvalue = detail;\n\t\tdispatch(\"change\", { data: detail.data, name: detail.name });\n\t\tdispatch(\"upload\", detail);\n\t}\n\n\tfunction handle_ended() {\n\t\tdispatch(\"stop\");\n\t\tdispatch(\"end\");\n\t}\n\n\tlet old_val: any;\n\tfunction value_has_changed(val: any) {\n\t\tif (val === old_val) return false;\n\t\telse {\n\t\t\told_val = val;\n\t\t\treturn true;\n\t\t}\n\t}\n\n\texport let dragging = false;\n\t$: dispatch(\"drag\", dragging);\n\t$: autoplay && player && value_has_changed(value?.data) && player.play();\n</script>\n\n<BlockLabel\n\t{show_label}\n\tIcon={Music}\n\tfloat={source === \"upload\" && value === null}\n\tlabel={label || \"Audio\"}\n/>\n{#if value === null || streaming}\n\t{#if source === \"microphone\"}\n\t\t<div class=\"mic-wrap\">\n\t\t\t{#if recording}\n\t\t\t\t<Button size=\"sm\" on:click={stop}>\n\t\t\t\t\t<span class=\"record-icon\">\n\t\t\t\t\t\t<span class=\"pinger\" />\n\t\t\t\t\t\t<span class=\"dot\" />\n\t\t\t\t\t</span>\n\t\t\t\t\tStop recording\n\t\t\t\t</Button>\n\t\t\t{:else}\n\t\t\t\t<Button size=\"sm\" on:click={record}>\n\t\t\t\t\t<span class=\"record-icon\">\n\t\t\t\t\t\t<span class=\"dot\" />\n\t\t\t\t\t</span>\n\t\t\t\t\tRecord from microphone\n\t\t\t\t</Button>\n\t\t\t{/if}\n\t\t</div>\n\t{:else if source === \"upload\"}\n\t\t<!-- explicitly listed out audio mimetypes due to iOS bug not recognizing audio/* -->\n\t\t<Upload\n\t\t\tfiletype=\"audio/aac,audio/midi,audio/mpeg,audio/ogg,audio/wav,audio/x-wav,audio/opus,audio/webm,audio/flac,audio/vnd.rn-realaudio,audio/x-ms-wma,audio/x-aiff,audio/amr,audio/*\"\n\t\t\ton:load={handle_load}\n\t\t\tbind:dragging\n\t\t>\n\t\t\t<slot />\n\t\t</Upload>\n\t{/if}\n{:else}\n\t<ModifyUpload\n\t\ton:clear={clear}\n\t\ton:edit={() => (mode = \"edit\")}\n\t\teditable\n\t\tabsolute={true}\n\t/>\n\n\t<audio\n\t\tuse:loaded\n\t\tcontrols\n\t\tbind:this={player}\n\t\tpreload=\"metadata\"\n\t\tsrc={value.data}\n\t\ton:play\n\t\ton:pause\n\t\ton:ended={handle_ended}\n\t/>\n\n\t{#if mode === \"edit\" && player?.duration}\n\t\t<Range\n\t\t\tbind:values={crop_values}\n\t\t\trange\n\t\t\tmin={0}\n\t\t\tmax={100}\n\t\t\tstep={1}\n\t\t\ton:change={handle_change}\n\t\t/>\n\t{/if}\n{/if}\n\n<style>\n\t.mic-wrap {\n\t\tpadding: var(--size-2);\n\t}\n\n\t.record-icon {\n\t\tdisplay: flex;\n\t\tposition: relative;\n\t\tmargin-right: var(--size-2);\n\t\twidth: 6px;\n\t\theight: 6px;\n\t}\n\n\t.dot {\n\t\tdisplay: inline-flex;\n\t\tposition: relative;\n\t\tborder-radius: var(--radius-full);\n\t\tbackground: var(--color-red-500);\n\t\twidth: 6px;\n\t\theight: 6px;\n\t}\n\n\t.pinger {\n\t\tdisplay: inline-flex;\n\t\tposition: absolute;\n\t\topacity: 0.9;\n\t\tanimation: ping 1s cubic-bezier(0, 0, 0.2, 1) infinite;\n\t\tborder-radius: var(--radius-full);\n\t\tbackground: var(--color-red-500);\n\t\twidth: var(--size-full);\n\t\theight: var(--size-full);\n\t}\n\n\t@keyframes ping {\n\t\t75%,\n\t\t100% {\n\t\t\ttransform: scale(2);\n\t\t\topacity: 0;\n\t\t}\n\t}\n\n\taudio {\n\t\tpadding: var(--size-2);\n\t\twidth: var(--size-full);\n\t\theight: var(--size-14);\n\t}\n</style>\n","<script context=\"module\" lang=\"ts\">\n\timport type { FileData } from \"@gradio/upload\";\n\timport { Empty } from \"@gradio/atoms\";\n\texport interface AudioData extends FileData {\n\t\tcrop_min?: number;\n\t\tcrop_max?: number;\n\t}\n</script>\n\n<script lang=\"ts\">\n\timport { createEventDispatcher } from \"svelte\";\n\timport { BlockLabel } from \"@gradio/atoms\";\n\n\timport { Music } from \"@gradio/icons\";\n\n\texport let value: null | { name: string; data: string } = null;\n\texport let label: string;\n\texport let name: string;\n\texport let show_label: boolean = true;\n\texport let autoplay: boolean;\n\n\tconst dispatch = createEventDispatcher<{\n\t\tchange: AudioData;\n\t\tplay: undefined;\n\t\tpause: undefined;\n\t\tend: undefined;\n\t\tstop: undefined;\n\t}>();\n\n\t$: value &&\n\t\tdispatch(\"change\", {\n\t\t\tname: name,\n\t\t\tdata: value?.data\n\t\t});\n\n\tlet el: HTMLAudioElement;\n\n\tlet old_val: any;\n\tfunction value_has_changed(val: any) {\n\t\tif (val === old_val) return false;\n\t\telse {\n\t\t\told_val = val;\n\t\t\treturn true;\n\t\t}\n\t}\n\n\t$: autoplay && el && value_has_changed(value) && el.play();\n\n\tfunction handle_ended() {\n\t\tdispatch(\"stop\");\n\t\tdispatch(\"end\");\n\t}\n</script>\n\n<BlockLabel {show_label} Icon={Music} float={false} label={label || \"Audio\"} />\n{#if value === null}\n\t<Empty size=\"small\">\n\t\t<Music />\n\t</Empty>\n{:else}\n\t<audio\n\t\tbind:this={el}\n\t\tcontrols\n\t\tpreload=\"metadata\"\n\t\tsrc={value.data}\n\t\ton:play\n\t\ton:pause\n\t\ton:ended={handle_ended}\n\t/>\n{/if}\n\n<style>\n\taudio {\n\t\tpadding: var(--size-2);\n\t\twidth: var(--size-full);\n\t\theight: var(--size-14);\n\t}\n</style>\n","<script lang=\"ts\">\n\timport { createEventDispatcher } from \"svelte\";\n\timport { _ } from \"svelte-i18n\";\n\timport UploadText from \"../UploadText.svelte\";\n\n\timport type { FileData } from \"@gradio/upload\";\n\timport type { LoadingStatus } from \"../StatusTracker/types\";\n\n\timport { Audio, StaticAudio } from \"@gradio/audio\";\n\timport StatusTracker from \"../StatusTracker/StatusTracker.svelte\";\n\timport { Block } from \"@gradio/atoms\";\n\n\timport { normalise_file } from \"@gradio/upload\";\n\n\tconst dispatch = createEventDispatcher<{\n\t\tchange: typeof value;\n\t\tstream: typeof value;\n\t\terror: string;\n\t}>();\n\n\texport let elem_id: string = \"\";\n\texport let elem_classes: Array<string> = [];\n\texport let visible: boolean = true;\n\texport let mode: \"static\" | \"dynamic\";\n\texport let value: null | FileData | string = null;\n\texport let name: string;\n\texport let source: \"microphone\" | \"upload\";\n\texport let label: string;\n\texport let root: string;\n\texport let show_label: boolean;\n\texport let pending: boolean;\n\texport let streaming: boolean;\n\texport let root_url: null | string;\n\texport let container: boolean = false;\n\texport let scale: number = 1;\n\texport let min_width: number | undefined = undefined;\n\texport let loading_status: LoadingStatus;\n\texport let autoplay: boolean = false;\n\n\tlet _value: null | FileData;\n\t$: _value = normalise_file(value, root, root_url);\n\n\tlet dragging: boolean;\n</script>\n\n<Block\n\tvariant={mode === \"dynamic\" && value === null && source === \"upload\"\n\t\t? \"dashed\"\n\t\t: \"solid\"}\n\tborder_mode={dragging ? \"focus\" : \"base\"}\n\tpadding={false}\n\t{elem_id}\n\t{elem_classes}\n\t{visible}\n\t{container}\n\t{scale}\n\t{min_width}\n>\n\t<StatusTracker {...loading_status} />\n\n\t{#if mode === \"dynamic\"}\n\t\t<Audio\n\t\t\t{label}\n\t\t\t{show_label}\n\t\t\tvalue={_value}\n\t\t\ton:change={({ detail }) => {\n\t\t\t\tvalue = detail;\n\t\t\t\tdispatch(\"change\", value);\n\t\t\t}}\n\t\t\ton:stream={({ detail }) => {\n\t\t\t\tvalue = detail;\n\t\t\t\tdispatch(\"stream\", value);\n\t\t\t}}\n\t\t\ton:drag={({ detail }) => (dragging = detail)}\n\t\t\t{name}\n\t\t\t{source}\n\t\t\t{pending}\n\t\t\t{streaming}\n\t\t\t{autoplay}\n\t\t\ton:edit\n\t\t\ton:play\n\t\t\ton:pause\n\t\t\ton:stop\n\t\t\ton:end\n\t\t\ton:start_recording\n\t\t\ton:stop_recording\n\t\t\ton:upload\n\t\t\ton:error={({ detail }) => {\n\t\t\t\tloading_status = loading_status || {};\n\t\t\t\tloading_status.status = \"error\";\n\t\t\t\tloading_status.message = detail;\n\t\t\t}}\n\t\t>\n\t\t\t<UploadText type=\"audio\" />\n\t\t</Audio>\n\t{:else}\n\t\t<StaticAudio\n\t\t\t{autoplay}\n\t\t\t{show_label}\n\t\t\tvalue={_value}\n\t\t\tname={_value?.name || \"audio_file\"}\n\t\t\t{label}\n\t\t/>\n\t{/if}\n</Block>\n","export { default as Component } from \"./Audio.svelte\";\nexport const modes = [\"static\", \"dynamic\"];\n\nexport const document = () => ({\n\ttype: {\n\t\tinput_payload: \"{ name: string; data: string }\",\n\t\tresponse_object: \"{ name: string; data: string, is_file: boolean }\"\n\t},\n\tdescription: {\n\t\tinput_payload: \"audio data as object with filename and base64 string\",\n\t\tresponse_object:\n\t\t\t\"object that includes path to audio file. The URL: {ROOT}file={name} contains the data\"\n\t},\n\texample_data: {\n\t\tname: \"audio.wav\",\n\t\tdata: \"data:audio/wav;base64,UklGRiQAAABXQVZFZm10IBAAAAABAAEARKwAAIhYAQACABAAZGF0YQAAAAA=\"\n\t}\n});\n"],"names":["insert","target","svg","anchor","append","path","circle0","circle1","if_block","ctx","create_if_block_10","toggle_class","span","is_function","t_value","create_if_block_12","create_if_block_11","dirty","set_data","t","i","create_if_block_6","attr","span_style_value","create_if_block_8","create_if_block_7","create_if_block_1","create_if_block_3","create_if_block_2","if_block0","create_if_block_9","if_block1","create_if_block_4","if_block2","create_if_block","div","range","$$props","min","max","step","values","vertical","reversed","hoverable","disabled","pipstep","all","first","last","rest","prefix","suffix","formatter","v","focus","orientationStart","percentOf","moveHandle","labelClick","val","$$invalidate","pipStep","pipCount","pipVal","isSelected","inRange","span1","span1_aria_valuemin_value","span1_aria_valuemax_value","span0","index","el","normalisedClient","e","slider","pushy","float","pips","id","p","handleFormatter","precision","springValues","dispatch","createEventDispatcher","valueLength","handleActivated","handlePressed","keyboardActive","activeHandle","startValue","previousValue","springPositions","targetIsHandle","handles","isHandle","isChild","trimRange","getSliderDimensions","getClosestHandle","clientPos","dims","handlePos","handlePercent","handleVal","closest","a","b","handleInteract","value","alignValueToStep","eChange","rangeStart","rangeEnd","sliderBlurHandle","sliderFocusHandle","sliderKeydown","handle","jump","prevent","sliderInteractStart","eStart","sliderInteractEnd","eStop","bodyInteractStart","bodyInteract","bodyMouseUp","bodyTouchEnd","bodyKeyDown","$$value","clampValue","remainder","aligned","perc","$$subscribe_springPositions","spring","orientationEnd","src_url_equal","audio","audio_src_value","current","span2","Music","blocklabel_changes","STREAM_TIMESLICE","NUM_HEADER_BYTES","blob_to_data_url","blob","fulfill","reject","reader","label","show_label","name","source","pending","streaming","autoplay","recording","recorder","mode","header","pending_stream","submit_pending_stream_on_pending_end","player","inited","crop_values","audio_chunks","module_promises","get_modules","dispatch_blob","blobs","event","audio_blob","prepare_audio","stream","err","MediaRecorder","register","connect","handle_chunk","buffer","payload","blobParts","record","onDestroy","stop","clear","loaded","node","clamp_playback","start_time","end_time","handle_change","handle_load","detail","handle_ended","old_val","value_has_changed","dragging","edit_handler","elem_id","elem_classes","visible","root","root_url","container","scale","min_width","loading_status","_value","normalise_file","modes","document"],"mappings":"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","x_google_ignoreList":[1,2]}