Upload folder using huggingface_hub

README.md

@@ -1,15 +1,10 @@
 
 ---
-tags: [gradio-custom-component,gradio-template-Dropdown,test,cool,dropdown]
-title: gradio_test3 V0.0.1
-colorFrom: pink
-colorTo: yellow
+tags: [gradio-custom-component,gradio-template-Fallback,test,no-template]
+title: gradio_test3 V0.0.2
+colorFrom: gray
+colorTo: purple
 sdk: docker
 pinned: false
 license: apache-2.0
 ---
-
-
-# gradio_test3
-
-This is a test component

app.py

@@ -3,14 +3,9 @@ import gradio as gr
 from gradio_test3 import Test3
 
 
-example = Test3().example_inputs()
-
-demo = gr.Interface(
-    lambda x:x,
-    Test3(),  # interactive version of your component
-    Test3(),  # static version of your component
-    # examples=[[example]],  # uncomment this line to view the "example version" of your component
-)
+with gr.Blocks() as demo:
+    gr.Markdown("# Change the value (keep it JSON) and the front-end will update automatically.")
+    Test3(value={"message": "Hello from Gradio!"}, label="Static")
 
 
 demo.launch()

requirements.txt

@@ -1 +1 @@
-gradio_test3-0.0.1-py3-none-any.whl
+gradio_test3-0.0.2-py3-none-any.whl

src/backend/gradio_test3/test3.py

@@ -1,186 +1,15 @@
-"""gr.Dropdown() component."""
+from gradio.components.base import Component
 
-from __future__ import annotations
 
-import warnings
-from typing import Any, Callable, Literal
+class Test3(Component):
+    def preprocess(self, payload):
+        return payload
 
-from gradio_client.documentation import document, set_documentation_group
-
-from gradio.components.base import FormComponent
-from gradio.events import Events
-
-set_documentation_group("component")
-
-
-@document()
-class Test3(FormComponent):
-    """
-    Creates a dropdown of choices from which entries can be selected.
-    Preprocessing: passes the value of the selected dropdown entry as a {str} or its index as an {int} into the function, depending on `type`.
-    Postprocessing: expects a {str} corresponding to the value of the dropdown entry to be selected.
-    Examples-format: a {str} representing the drop down value to select.
-    Demos: sentence_builder, titanic_survival
-    """
-
-    EVENTS = [Events.change, Events.input, Events.select, Events.focus, Events.blur]
-
-    def __init__(
-        self,
-        choices: list[str | int | float | tuple[str, str | int | float]] | None = None,
-        *,
-        value: str | int | float | list[str | int | float] | Callable | None = None,
-        type: Literal["value", "index"] = "value",
-        multiselect: bool | None = None,
-        allow_custom_value: bool = False,
-        max_choices: int | None = None,
-        filterable: bool = True,
-        label: str | None = None,
-        info: str | None = None,
-        every: float | None = None,
-        show_label: bool | None = None,
-        container: bool = True,
-        scale: int | None = None,
-        min_width: int = 160,
-        interactive: bool | None = None,
-        visible: bool = True,
-        elem_id: str | None = None,
-        elem_classes: list[str] | str | None = None,
-        render: bool = True,
-    ):
-        """
-        Parameters:
-            choices: A list of string options to choose from. An option can also be a tuple of the form (name, value), where name is the displayed name of the dropdown choice and value is the value to be passed to the function, or returned by the function.
-            value: default value(s) selected in dropdown. If None, no value is selected by default. If callable, the function will be called whenever the app loads to set the initial value of the component.
-            type: Type of value to be returned by component. "value" returns the string of the choice selected, "index" returns the index of the choice selected.
-            multiselect: if True, multiple choices can be selected.
-            allow_custom_value: If True, allows user to enter a custom value that is not in the list of choices.
-            max_choices: maximum number of choices that can be selected. If None, no limit is enforced.
-            filterable: If True, user will be able to type into the dropdown and filter the choices by typing. Can only be set to False if `allow_custom_value` is False.
-            label: The label for this component. Appears above the component and is also used as the header if there are a table of examples for this component. If None and used in a `gr.Interface`, the label will be the name of the parameter this component is assigned to.
-            info: additional component description.
-            every: If `value` is a callable, run the function 'every' number of seconds while the client connection is open. Has no effect otherwise. Queue must be enabled. The event can be accessed (e.g. to cancel it) via this component's .load_event attribute.
-            show_label: if True, will display label.
-            container: If True, will place the component in a container - providing some extra padding around the border.
-            scale: relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer.
-            min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
-            interactive: if True, choices in this dropdown will be selectable; if False, selection will be disabled. If not provided, this is inferred based on whether the component is used as an input or output.
-            visible: If False, component will be hidden.
-            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
-            elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
-            render: If False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
-        """
-        self.choices = (
-            # Although we expect choices to be a list of tuples, it can be a list of tuples if the Gradio app
-            # is loaded with gr.load() since Python tuples are converted to lists in JSON.
-            [tuple(c) if isinstance(c, (tuple, list)) else (str(c), c) for c in choices]
-            if choices
-            else []
-        )
-        valid_types = ["value", "index"]
-        if type not in valid_types:
-            raise ValueError(
-                f"Invalid value for parameter `type`: {type}. Please choose from one of: {valid_types}"
-            )
-        self.type = type
-        self.multiselect = multiselect
-        if multiselect and isinstance(value, str):
-            value = [value]
-        if not multiselect and max_choices is not None:
-            warnings.warn(
-                "The `max_choices` parameter is ignored when `multiselect` is False."
-            )
-        if not filterable and allow_custom_value:
-            filterable = True
-            warnings.warn(
-                "The `filterable` parameter cannot be set to False when `allow_custom_value` is True. Setting `filterable` to True."
-            )
-        self.max_choices = max_choices
-        self.allow_custom_value = allow_custom_value
-        self.filterable = filterable
-        super().__init__(
-            label=label,
-            info=info,
-            every=every,
-            show_label=show_label,
-            container=container,
-            scale=scale,
-            min_width=min_width,
-            interactive=interactive,
-            visible=visible,
-            elem_id=elem_id,
-            elem_classes=elem_classes,
-            render=render,
-            value=value,
-        )
-
-    def api_info(self) -> dict[str, Any]:
-        if self.multiselect:
-            json_type = {
-                "type": "array",
-                "items": {"type": "string", "enum": [c[1] for c in self.choices]},
-            }
-        else:
-            json_type = {
-                "type": "string",
-                "enum": [c[1] for c in self.choices],
-            }
-        return json_type
-
-    def example_inputs(self) -> Any:
-        if self.multiselect:
-            return [self.choices[0][1]] if self.choices else []
-        else:
-            return self.choices[0][1] if self.choices else None
-
-    def preprocess(
-        self, payload: str | int | float | list[str | int | float] | None
-    ) -> str | int | float | list[str | int | float] | list[int | None] | None:
-        if self.type == "value":
-            return payload
-        elif self.type == "index":
-            choice_values = [value for _, value in self.choices]
-            if payload is None:
-                return None
-            elif self.multiselect:
-                assert isinstance(payload, list)
-                return [
-                    choice_values.index(choice) if choice in choice_values else None
-                    for choice in payload
-                ]
-            else:
-                return (
-                    choice_values.index(payload) if payload in choice_values else None
-                )
-        else:
-            raise ValueError(
-                f"Unknown type: {self.type}. Please choose from: 'value', 'index'."
-            )
-
-    def _warn_if_invalid_choice(self, value):
-        if self.allow_custom_value or value in [value for _, value in self.choices]:
-            return
-        warnings.warn(
-            f"The value passed into gr.Dropdown() is not in the list of choices. Please update the list of choices to include: {value} or set allow_custom_value=True."
-        )
-
-    def postprocess(
-        self, value: str | int | float | list[str | int | float] | None
-    ) -> str | int | float | list[str | int | float] | None:
-        if value is None:
-            return None
-        if self.multiselect:
-            if not isinstance(value, list):
-                value = [value]
-            [self._warn_if_invalid_choice(_y) for _y in value]
-        else:
-            self._warn_if_invalid_choice(value)
+    def postprocess(self, value):
         return value
 
-    def as_example(self, input_data):
-        if self.multiselect:
-            return [
-                next((c[0] for c in self.choices if c[1] == data), None)
-                for data in input_data
-            ]
-        return next((c[0] for c in self.choices if c[1] == input_data), None)
+    def example_inputs(self):
+        return {"foo": "bar"}
+
+    def api_info(self):
+        return {"type": {}, "description": "any valid json"}

src/backend/gradio_test3/test3.pyi

@@ -1,373 +1,16 @@
-"""gr.Dropdown() component."""
-
-from __future__ import annotations
-
-import warnings
-from typing import Any, Callable, Literal
-
-from gradio_client.documentation import document, set_documentation_group
-
-from gradio.components.base import FormComponent
-from gradio.events import Events
-
-set_documentation_group("component")
+from gradio.components.base import Component
 
 from gradio.events import Dependency
 
-@document()
-class Test3(FormComponent):
-    """
-    Creates a dropdown of choices from which entries can be selected.
-    Preprocessing: passes the value of the selected dropdown entry as a {str} or its index as an {int} into the function, depending on `type`.
-    Postprocessing: expects a {str} corresponding to the value of the dropdown entry to be selected.
-    Examples-format: a {str} representing the drop down value to select.
-    Demos: sentence_builder, titanic_survival
-    """
-
-    EVENTS = [Events.change, Events.input, Events.select, Events.focus, Events.blur]
-
-    def __init__(
-        self,
-        choices: list[str | int | float | tuple[str, str | int | float]] | None = None,
-        *,
-        value: str | int | float | list[str | int | float] | Callable | None = None,
-        type: Literal["value", "index"] = "value",
-        multiselect: bool | None = None,
-        allow_custom_value: bool = False,
-        max_choices: int | None = None,
-        filterable: bool = True,
-        label: str | None = None,
-        info: str | None = None,
-        every: float | None = None,
-        show_label: bool | None = None,
-        container: bool = True,
-        scale: int | None = None,
-        min_width: int = 160,
-        interactive: bool | None = None,
-        visible: bool = True,
-        elem_id: str | None = None,
-        elem_classes: list[str] | str | None = None,
-        render: bool = True,
-    ):
-        """
-        Parameters:
-            choices: A list of string options to choose from. An option can also be a tuple of the form (name, value), where name is the displayed name of the dropdown choice and value is the value to be passed to the function, or returned by the function.
-            value: default value(s) selected in dropdown. If None, no value is selected by default. If callable, the function will be called whenever the app loads to set the initial value of the component.
-            type: Type of value to be returned by component. "value" returns the string of the choice selected, "index" returns the index of the choice selected.
-            multiselect: if True, multiple choices can be selected.
-            allow_custom_value: If True, allows user to enter a custom value that is not in the list of choices.
-            max_choices: maximum number of choices that can be selected. If None, no limit is enforced.
-            filterable: If True, user will be able to type into the dropdown and filter the choices by typing. Can only be set to False if `allow_custom_value` is False.
-            label: The label for this component. Appears above the component and is also used as the header if there are a table of examples for this component. If None and used in a `gr.Interface`, the label will be the name of the parameter this component is assigned to.
-            info: additional component description.
-            every: If `value` is a callable, run the function 'every' number of seconds while the client connection is open. Has no effect otherwise. Queue must be enabled. The event can be accessed (e.g. to cancel it) via this component's .load_event attribute.
-            show_label: if True, will display label.
-            container: If True, will place the component in a container - providing some extra padding around the border.
-            scale: relative width compared to adjacent Components in a Row. For example, if Component A has scale=2, and Component B has scale=1, A will be twice as wide as B. Should be an integer.
-            min_width: minimum pixel width, will wrap if not sufficient screen space to satisfy this value. If a certain scale value results in this Component being narrower than min_width, the min_width parameter will be respected first.
-            interactive: if True, choices in this dropdown will be selectable; if False, selection will be disabled. If not provided, this is inferred based on whether the component is used as an input or output.
-            visible: If False, component will be hidden.
-            elem_id: An optional string that is assigned as the id of this component in the HTML DOM. Can be used for targeting CSS styles.
-            elem_classes: An optional list of strings that are assigned as the classes of this component in the HTML DOM. Can be used for targeting CSS styles.
-            render: If False, component will not render be rendered in the Blocks context. Should be used if the intention is to assign event listeners now but render the component later.
-        """
-        self.choices = (
-            # Although we expect choices to be a list of tuples, it can be a list of tuples if the Gradio app
-            # is loaded with gr.load() since Python tuples are converted to lists in JSON.
-            [tuple(c) if isinstance(c, (tuple, list)) else (str(c), c) for c in choices]
-            if choices
-            else []
-        )
-        valid_types = ["value", "index"]
-        if type not in valid_types:
-            raise ValueError(
-                f"Invalid value for parameter `type`: {type}. Please choose from one of: {valid_types}"
-            )
-        self.type = type
-        self.multiselect = multiselect
-        if multiselect and isinstance(value, str):
-            value = [value]
-        if not multiselect and max_choices is not None:
-            warnings.warn(
-                "The `max_choices` parameter is ignored when `multiselect` is False."
-            )
-        if not filterable and allow_custom_value:
-            filterable = True
-            warnings.warn(
-                "The `filterable` parameter cannot be set to False when `allow_custom_value` is True. Setting `filterable` to True."
-            )
-        self.max_choices = max_choices
-        self.allow_custom_value = allow_custom_value
-        self.filterable = filterable
-        super().__init__(
-            label=label,
-            info=info,
-            every=every,
-            show_label=show_label,
-            container=container,
-            scale=scale,
-            min_width=min_width,
-            interactive=interactive,
-            visible=visible,
-            elem_id=elem_id,
-            elem_classes=elem_classes,
-            render=render,
-            value=value,
-        )
-
-    def api_info(self) -> dict[str, Any]:
-        if self.multiselect:
-            json_type = {
-                "type": "array",
-                "items": {"type": "string", "enum": [c[1] for c in self.choices]},
-            }
-        else:
-            json_type = {
-                "type": "string",
-                "enum": [c[1] for c in self.choices],
-            }
-        return json_type
-
-    def example_inputs(self) -> Any:
-        if self.multiselect:
-            return [self.choices[0][1]] if self.choices else []
-        else:
-            return self.choices[0][1] if self.choices else None
-
-    def preprocess(
-        self, payload: str | int | float | list[str | int | float] | None
-    ) -> str | int | float | list[str | int | float] | list[int | None] | None:
-        if self.type == "value":
-            return payload
-        elif self.type == "index":
-            choice_values = [value for _, value in self.choices]
-            if payload is None:
-                return None
-            elif self.multiselect:
-                assert isinstance(payload, list)
-                return [
-                    choice_values.index(choice) if choice in choice_values else None
-                    for choice in payload
-                ]
-            else:
-                return (
-                    choice_values.index(payload) if payload in choice_values else None
-                )
-        else:
-            raise ValueError(
-                f"Unknown type: {self.type}. Please choose from: 'value', 'index'."
-            )
-
-    def _warn_if_invalid_choice(self, value):
-        if self.allow_custom_value or value in [value for _, value in self.choices]:
-            return
-        warnings.warn(
-            f"The value passed into gr.Dropdown() is not in the list of choices. Please update the list of choices to include: {value} or set allow_custom_value=True."
-        )
+class Test3(Component):
+    def preprocess(self, payload):
+        return payload
 
-    def postprocess(
-        self, value: str | int | float | list[str | int | float] | None
-    ) -> str | int | float | list[str | int | float] | None:
-        if value is None:
-            return None
-        if self.multiselect:
-            if not isinstance(value, list):
-                value = [value]
-            [self._warn_if_invalid_choice(_y) for _y in value]
-        else:
-            self._warn_if_invalid_choice(value)
+    def postprocess(self, value):
         return value
 
-    def as_example(self, input_data):
-        if self.multiselect:
-            return [
-                next((c[0] for c in self.choices if c[1] == data), None)
-                for data in input_data
-            ]
-        return next((c[0] for c in self.choices if c[1] == input_data), None)
+    def example_inputs(self):
+        return {"foo": "bar"}
 
-    
-    def change(self,
-        fn: Callable | None,
-        inputs: Component | Sequence[Component] | set[Component] | None = None,
-        outputs: Component | Sequence[Component] | None = None,
-        api_name: str | None | Literal[False] = None,
-        status_tracker: None = None,
-        scroll_to_output: bool = False,
-        show_progress: Literal["full", "minimal", "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,
-        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
-        js: str | None = None,) -> Dependency:
-        """
-        Parameters:
-            fn: the function to call when this event is triggered. 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: Defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
-            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.
-            trigger_mode: If "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` event) would allow a second submission after the pending event is complete.
-            js: Optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
-        """
-        ...
-    
-    def input(self,
-        fn: Callable | None,
-        inputs: Component | Sequence[Component] | set[Component] | None = None,
-        outputs: Component | Sequence[Component] | None = None,
-        api_name: str | None | Literal[False] = None,
-        status_tracker: None = None,
-        scroll_to_output: bool = False,
-        show_progress: Literal["full", "minimal", "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,
-        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
-        js: str | None = None,) -> Dependency:
-        """
-        Parameters:
-            fn: the function to call when this event is triggered. 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: Defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
-            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.
-            trigger_mode: If "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` event) would allow a second submission after the pending event is complete.
-            js: Optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
-        """
-        ...
-    
-    def select(self,
-        fn: Callable | None,
-        inputs: Component | Sequence[Component] | set[Component] | None = None,
-        outputs: Component | Sequence[Component] | None = None,
-        api_name: str | None | Literal[False] = None,
-        status_tracker: None = None,
-        scroll_to_output: bool = False,
-        show_progress: Literal["full", "minimal", "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,
-        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
-        js: str | None = None,) -> Dependency:
-        """
-        Parameters:
-            fn: the function to call when this event is triggered. 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: Defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
-            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.
-            trigger_mode: If "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` event) would allow a second submission after the pending event is complete.
-            js: Optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
-        """
-        ...
-    
-    def focus(self,
-        fn: Callable | None,
-        inputs: Component | Sequence[Component] | set[Component] | None = None,
-        outputs: Component | Sequence[Component] | None = None,
-        api_name: str | None | Literal[False] = None,
-        status_tracker: None = None,
-        scroll_to_output: bool = False,
-        show_progress: Literal["full", "minimal", "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,
-        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
-        js: str | None = None,) -> Dependency:
-        """
-        Parameters:
-            fn: the function to call when this event is triggered. 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: Defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
-            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.
-            trigger_mode: If "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` event) would allow a second submission after the pending event is complete.
-            js: Optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
-        """
-        ...
-    
-    def blur(self,
-        fn: Callable | None,
-        inputs: Component | Sequence[Component] | set[Component] | None = None,
-        outputs: Component | Sequence[Component] | None = None,
-        api_name: str | None | Literal[False] = None,
-        status_tracker: None = None,
-        scroll_to_output: bool = False,
-        show_progress: Literal["full", "minimal", "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,
-        trigger_mode: Literal["once", "multiple", "always_last"] | None = None,
-        js: str | None = None,) -> Dependency:
-        """
-        Parameters:
-            fn: the function to call when this event is triggered. 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: Defines how the endpoint appears in the API docs. Can be a string, None, or False. If False, the endpoint will not be exposed in the api docs. If set to None, the endpoint will be exposed in the api docs as an unnamed endpoint, although this behavior will be changed in Gradio 4.0. If set to a string, the endpoint will be exposed in the api docs with the given name.
-            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.
-            trigger_mode: If "once" (default for all events except `.change()`) would not allow any submissions while an event is pending. If set to "multiple", unlimited submissions are allowed while pending, and "always_last" (default for `.change()` event) would allow a second submission after the pending event is complete.
-            js: Optional frontend js method to run before running 'fn'. Input arguments for js method are values of 'inputs' and 'outputs', return should be a list of values for output components.
-        """
-        ...
+    def api_info(self):
+        return {"type": {}, "description": "any valid json"}

src/demo/app.py

@@ -3,14 +3,9 @@ import gradio as gr
 from gradio_test3 import Test3
 
 
-example = Test3().example_inputs()
-
-demo = gr.Interface(
-    lambda x:x,
-    Test3(),  # interactive version of your component
-    Test3(),  # static version of your component
-    # examples=[[example]],  # uncomment this line to view the "example version" of your component
-)
+with gr.Blocks() as demo:
+    gr.Markdown("# Change the value (keep it JSON) and the front-end will update automatically.")
+    Test3(value={"message": "Hello from Gradio!"}, label="Static")
 
 
 demo.launch()

src/frontend/Index.svelte

@@ -1,96 +1,35 @@
-<script context="module" lang="ts">
-	export { default as BaseDropdown } from "./shared/Dropdown.svelte";
-	export { default as BaseMultiselect } from "./shared/Multiselect.svelte";
-	export { default as BaseExample } from "./Example.svelte";
-</script>
-
 <script lang="ts">
-	import type { Gradio, SelectData } from "@gradio/utils";
-	import Multiselect from "./shared/Multiselect.svelte";
-	import Dropdown from "./shared/Dropdown.svelte";
-	import { Block } from "@gradio/atoms";
+	import { JsonView } from "@zerodevx/svelte-json-view";
+
+	import type { Gradio } from "@gradio/utils";
+	import { Block, Info } from "@gradio/atoms";
 	import { StatusTracker } from "@gradio/statustracker";
 	import type { LoadingStatus } from "@gradio/statustracker";
+	import type { SelectData } from "@gradio/utils";
 
-	export let label = "Dropdown";
-	export let info: string | undefined = undefined;
 	export let elem_id = "";
 	export let elem_classes: string[] = [];
 	export let visible = true;
-	export let value: string | string[];
-	export let value_is_output = false;
-	export let multiselect = false;
-	export let max_choices: number | null = null;
-	export let choices: [string, string | number][];
-	export let show_label: boolean;
-	export let filterable: boolean;
+	export let value = false;
 	export let container = true;
 	export let scale: number | null = null;
 	export let min_width: number | undefined = undefined;
 	export let loading_status: LoadingStatus;
-	export let allow_custom_value = false;
 	export let gradio: Gradio<{
 		change: never;
-		input: never;
 		select: SelectData;
-		blur: never;
-		focus: never;
+		input: never;
 	}>;
-	export let interactive: boolean;
 </script>
 
-<Block
-	{visible}
-	{elem_id}
-	{elem_classes}
-	padding={container}
-	allow_overflow={false}
-	{scale}
-	{min_width}
->
-	<StatusTracker
-		autoscroll={gradio.autoscroll}
-		i18n={gradio.i18n}
-		{...loading_status}
-	/>
-
-	{#if multiselect}
-		<Multiselect
-			bind:value
-			bind:value_is_output
-			{choices}
-			{max_choices}
-			{label}
-			{info}
-			{show_label}
-			{allow_custom_value}
-			{filterable}
-			{container}
+<Block {visible} {elem_id} {elem_classes} {container} {scale} {min_width}>
+	{#if loading_status}
+		<StatusTracker
+			autoscroll={gradio.autoscroll}
 			i18n={gradio.i18n}
-			on:change={() => gradio.dispatch("change")}
-			on:input={() => gradio.dispatch("input")}
-			on:select={(e) => gradio.dispatch("select", e.detail)}
-			on:blur={() => gradio.dispatch("blur")}
-			on:focus={() => gradio.dispatch("focus")}
-			disabled={!interactive}
-		/>
-	{:else}
-		<Dropdown
-			bind:value
-			bind:value_is_output
-			{choices}
-			{label}
-			{info}
-			{show_label}
-			{filterable}
-			{allow_custom_value}
-			{container}
-			on:change={() => gradio.dispatch("change")}
-			on:input={() => gradio.dispatch("input")}
-			on:select={(e) => gradio.dispatch("select", e.detail)}
-			on:blur={() => gradio.dispatch("blur")}
-			on:focus={() => gradio.dispatch("focus")}
-			disabled={!interactive}
+			{...loading_status}
 		/>
 	{/if}
+
+	<JsonView json={value} />
 </Block>

src/frontend/package-lock.json

@@ -1,18 +1,18 @@
 {
   "name": "gradio_test3",
-  "version": "0.3.1",
+  "version": "0.2.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "gradio_test3",
-      "version": "0.3.1",
+      "version": "0.2.1",
       "license": "ISC",
       "dependencies": {
         "@gradio/atoms": "0.2.1",
-        "@gradio/icons": "0.2.0",
         "@gradio/statustracker": "0.3.1",
-        "@gradio/utils": "0.2.0"
+        "@gradio/utils": "0.2.0",
+        "@zerodevx/svelte-json-view": "^1.0.7"
       }
     },
     "node_modules/@ampproject/remapping": {
@@ -500,6 +500,14 @@
       "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw==",
       "peer": true
     },
+    "node_modules/@zerodevx/svelte-json-view": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/@zerodevx/svelte-json-view/-/svelte-json-view-1.0.7.tgz",
+      "integrity": "sha512-yW0MV+9BCKOwzt3h86y3xDqYdI5st+Rxk+L5pa0Utq7nlPD+VvxyhL7R1gJoLxQvWwjyAvY/fyUCFTdwDyI14w==",
+      "peerDependencies": {
+        "svelte": "^3.57.0 || ^4.0.0"
+      }
+    },
     "node_modules/acorn": {
       "version": "8.11.2",
       "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz",

src/frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gradio_test3",
-  "version": "0.3.1",
+  "version": "0.2.1",
   "description": "Gradio UI packages",
   "type": "module",
   "author": "",
@@ -14,8 +14,8 @@
   },
   "dependencies": {
     "@gradio/atoms": "0.2.1",
-    "@gradio/icons": "0.2.0",
     "@gradio/statustracker": "0.3.1",
-    "@gradio/utils": "0.2.0"
+    "@gradio/utils": "0.2.0",
+    "@zerodevx/svelte-json-view": "^1.0.7"
   }
 }

src/pyproject.toml

@@ -8,13 +8,13 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gradio_test3"
-version = "0.0.1"
-description = "This is a test component"
+version = "0.0.2"
+description = "This is a test component."
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.8"
 authors = [{ name = "YOUR NAME", email = "[email protected]" }]
-keywords = ["gradio-custom-component", "gradio-template-Dropdown", "test", "cool", "dropdown"]
+keywords = ["gradio-custom-component", "gradio-template-Fallback", "test", "no-template"]
 # Add dependencies here
 dependencies = ["gradio>=4.0,<5.0"]
 classifiers = [