mirror/gradio
2
0
Fork 0
mirror of https://github.com/gradio-app/gradio.git synced 2025-03-31 12:20:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

Adds support for kwargs and default arguments in the python client, and improves how parameter information is displayed in the "view API" page (#7732)

Browse Source 
* changes

* changes

* add changeset

* improvements to api docs ui

* add changeset

* ux design work

* further styling

* feedback

* add changeset

* get parameter name

* fix code snippet

* construct args

* add changeset

* construct_args

* utils

* changes

* add catches

* fixes

* valid

* fix tests

* js lint

* add tests

* add changeset

* format

* client

* doc

* fixes

* changes

* api docs fixes

* fix .view_api()

* updating guide wip

* guide

* updated guides'

* fix

* guide fixes

* filepath

* address review

---------

Co-authored-by: gradio-pr-bot <gradio-pr-bot@users.noreply.github.com>
This commit is contained in:
Abubakar Abid 2024-03-21 17:18:13 -07:00 committed by GitHub
parent 755157f99c
commit 2efb05ed99
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
21 changed files with 706 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.changeset/tiny-bars-greet.md Normal file
View File

@ -0,0 +1,8 @@
---
"@gradio/app": minor
"@gradio/atoms": minor
"gradio": minor
"gradio_client": minor
---
feat:Adds support for kwargs and default arguments in the python client, and improves how parameter information is displayed in the "view API" page

45
client/python/gradio_client/client.py
View File

@ -33,6 +33,7 @@ from packaging import version
from gradio_client import utils
from gradio_client.compatibility import EndpointV3Compatibility
from gradio_client.data_classes import ParameterInfo
from gradio_client.documentation import document
from gradio_client.exceptions import AuthenticationError
from gradio_client.utils import (
@ -400,6 +401,7 @@ class Client:
*args,
api_name: str | None = None,
fn_index: int | None = None,
**kwargs,
) -> Any:
"""
Calls the Gradio API and returns the result (this is a blocking call).
@ -421,7 +423,9 @@ class Client:
raise ValueError(
"Cannot call predict on this function as it may run forever. Use submit instead."
)
return self.submit(*args, api_name=api_name, fn_index=fn_index).result()
return self.submit(
*args, api_name=api_name, fn_index=fn_index, **kwargs
).result()
def new_helper(self, fn_index: int) -> Communicator:
return Communicator(
@ -437,6 +441,7 @@ class Client:
api_name: str | None = None,
fn_index: int | None = None,
result_callbacks: Callable | list[Callable] | None = None,
**kwargs,
) -> Job:
"""
Creates and returns a Job object which calls the Gradio API in a background thread. The job can be used to retrieve the status and result of the remote API call.
@ -458,9 +463,13 @@ class Client:
>> 9.0
"""
inferred_fn_index = self._infer_fn_index(api_name, fn_index)
endpoint = self.endpoints[inferred_fn_index]
if isinstance(endpoint, Endpoint):
args = utils.construct_args(endpoint.parameters_info, args, kwargs)
helper = None
if self.endpoints[inferred_fn_index].protocol in (
if endpoint.protocol in (
"ws",
"sse",
"sse_v1",
@ -469,7 +478,7 @@ class Client:
"sse_v3",
):
helper = self.new_helper(inferred_fn_index)
end_to_end_fn = self.endpoints[inferred_fn_index].make_end_to_end_fn(helper)
end_to_end_fn = endpoint.make_end_to_end_fn(helper)
future = self.executor.submit(end_to_end_fn, *args)
job = Job(
@ -637,9 +646,12 @@ class Client:
def _render_endpoints_info(
self,
name_or_index: str | int,
endpoints_info: dict[str, list[dict[str, Any]]],
endpoints_info: dict[str, list[ParameterInfo]],
) -> str:
parameter_names = [p["label"] for p in endpoints_info["parameters"]]
parameter_info = endpoints_info["parameters"]
parameter_names = [
p.get("parameter_name") or p["label"] for p in parameter_info
]
parameter_names = [utils.sanitize_parameter_names(p) for p in parameter_names]
rendered_parameters = ", ".join(parameter_names)
if rendered_parameters:
@ -659,15 +671,23 @@ class Client:
human_info = f"\n - predict({rendered_parameters}{final_param}) -> {rendered_return_values}\n"
human_info += " Parameters:\n"
if endpoints_info["parameters"]:
for info in endpoints_info["parameters"]:
if parameter_info:
for info in parameter_info:
desc = (
f" ({info['python_type']['description']})"
if info["python_type"].get("description")
else ""
)
default_value = info.get("parameter_default")
default_info = (
"(required)"
if not info.get("parameter_has_default", False)
else f"(not required, defaults to {default_value})"
)
type_ = info["python_type"]["type"]
human_info += f" - [{info['component']}] {utils.sanitize_parameter_names(info['label'])}: {type_}{desc} \n"
if info.get("parameter_has_default", False) and default_value is None:
type_ += " | None"
human_info += f" - [{info['component']}] {utils.sanitize_parameter_names(info.get('parameter_name') or info['label'])}: {type_} {default_info} {desc} \n"
else:
human_info += " - None\n"
human_info += " Returns:\n"
@ -982,6 +1002,8 @@ class Endpoint:
self.output_component_types = [
self._get_component_type(id_) for id_ in dependency["outputs"]
]
self.parameters_info = self._get_parameters_info()
self.root_url = client.src + "/" if not client.src.endswith("/") else client.src
self.is_continuous = dependency.get("types", {}).get("continuous", False)
@ -1001,6 +1023,13 @@ class Endpoint:
component["type"] == "state",
)
def _get_parameters_info(self) -> list[ParameterInfo] | None:
if not self.client._info:
self._info = self.client._get_api_info()
if self.api_name in self._info["named_endpoints"]:
return self._info["named_endpoints"][self.api_name]["parameters"]
return None
@staticmethod
def value_is_file(component: dict) -> bool:
# This is still hacky as it does not tell us which part of the payload is a file.

13
client/python/gradio_client/data_classes.py
View File

@ -1,6 +1,6 @@
from __future__ import annotations
from typing import TypedDict
from typing import Any, TypedDict
from typing_extensions import NotRequired
@ -15,3 +15,14 @@ class FileData(TypedDict):
orig_name: NotRequired[str] # original filename
mime_type: NotRequired[str]
is_stream: NotRequired[bool]
class ParameterInfo(TypedDict):
label: str
parameter_name: NotRequired[str]
parameter_has_default: NotRequired[bool]
parameter_default: NotRequired[Any]
type: dict
python_type: dict
component: str
example_input: Any

56
client/python/gradio_client/utils.py
View File

@ -17,7 +17,7 @@ from datetime import datetime
from enum import Enum
from pathlib import Path
from threading import Lock
from typing import Any, Callable, Literal, Optional, TypedDict
from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, TypedDict
import fsspec.asyn
import httpx
@ -25,6 +25,9 @@ import huggingface_hub
from huggingface_hub import SpaceStage
from websockets.legacy.protocol import WebSocketCommonProtocol
if TYPE_CHECKING:
from gradio_client.data_classes import ParameterInfo
API_URL = "api/predict/"
SSE_URL_V0 = "queue/join"
SSE_DATA_URL_V0 = "queue/data"
@ -1063,3 +1066,54 @@ def file(filepath_or_url: str | Path):
raise ValueError(
f"File {s} does not exist on local filesystem and is not a valid URL."
)
def construct_args(
parameters_info: list[ParameterInfo] | None, args: tuple, kwargs: dict
) -> list:
class _Keywords(Enum):
NO_VALUE = "NO_VALUE" # Used as a sentinel to determine if nothing is provided as a parameter for an argument
_args = list(args)
if parameters_info is None:
if kwargs:
raise ValueError(
"This endpoint does not support key-word arguments Please click on 'view API' in the footer of the Gradio app to see usage."
)
return _args
num_args = len(args)
_args = _args + [_Keywords.NO_VALUE] * (len(parameters_info) - num_args)
kwarg_arg_mapping = {}
kwarg_names = []
for index, param_info in enumerate(parameters_info):
if "parameter_name" in param_info:
kwarg_arg_mapping[param_info["parameter_name"]] = index
kwarg_names.append(param_info["parameter_name"])
else:
kwarg_names.append("argument {index}")
if (
param_info.get("parameter_has_default", False)
and _args[index] == _Keywords.NO_VALUE
):
_args[index] = param_info.get("parameter_default")
for key, value in kwargs.items():
if key in kwarg_arg_mapping:
if kwarg_arg_mapping[key] < num_args:
raise ValueError(
f"Parameter `{key}` is already set as a positional argument. Please click on 'view API' in the footer of the Gradio app to see usage."
)
else:
_args[kwarg_arg_mapping[key]] = value
else:
raise ValueError(
f"Parameter `{key}` is not a valid key-word argument. Please click on 'view API' in the footer of the Gradio app to see usage."
)
if _Keywords.NO_VALUE in _args:
raise ValueError(
f"No value provided for required argument: {kwarg_names[_args.index(_Keywords.NO_VALUE)]}"
)
return _args

32
client/python/test/conftest.py
View File

@ -41,6 +41,38 @@ def calculator_demo():
return demo
@pytest.fixture
def calculator_demo_with_defaults():
def calculator(num1, operation=None, num2=100):
if operation is None or operation == "add":
return num1 + num2
elif operation == "subtract":
return num1 - num2
elif operation == "multiply":
return num1 * num2
elif operation == "divide":
if num2 == 0:
raise gr.Error("Cannot divide by zero!")
return num1 / num2
demo = gr.Interface(
calculator,
[
gr.Number(value=10),
gr.Radio(["add", "subtract", "multiply", "divide"]),
gr.Number(),
],
"number",
examples=[
[5, "add", 3],
[4, "divide", 2],
[-4, "multiply", 2.5],
[0, "subtract", 1.2],
],
)
return demo
@pytest.fixture
def state_demo():
demo = gr.Interface(

57
client/python/test/test_client.py
View File

@ -601,6 +601,33 @@ class TestClientPredictions:
assert pred[0] == data[0]
class TestClientPredictionsWithKwargs:
def test_no_default_params(self, calculator_demo):
with connect(calculator_demo) as client:
result = client.predict(
num1=3, operation="add", num2=3, api_name="/predict"
)
assert result == 6
result = client.predict(33, operation="add", num2=3, api_name="/predict")
assert result == 36
def test_default_params(self, calculator_demo_with_defaults):
with connect(calculator_demo_with_defaults) as client:
result = client.predict(num2=10, api_name="/predict")
assert result == 20
result = client.predict(num2=33, operation="multiply", api_name="/predict")
assert result == 330
def test_missing_params(self, calculator_demo):
with connect(calculator_demo) as client:
with pytest.raises(
ValueError, match="No value provided for required argument: num2"
):
client.predict(num1=3, operation="add", api_name="/predict")
class TestStatusUpdates:
@patch("gradio_client.client.Endpoint.make_end_to_end_fn")
def test_messages_passed_correctly(self, mock_make_end_to_end_fn, calculator_demo):
@ -952,6 +979,9 @@ class TestAPIInfo:
"parameters": [
{
"label": "num1",
"parameter_name": "num1",
"parameter_has_default": False,
"parameter_default": None,
"type": {"type": "number"},
"python_type": {"type": "float", "description": ""},
"component": "Number",
@ -959,6 +989,9 @@ class TestAPIInfo:
},
{
"label": "operation",
"parameter_name": "operation",
"parameter_has_default": False,
"parameter_default": None,
"type": {
"enum": ["add", "subtract", "multiply", "divide"],
"title": "Radio",
@ -973,6 +1006,9 @@ class TestAPIInfo:
},
{
"label": "num2",
"parameter_name": "num2",
"parameter_has_default": False,
"parameter_default": None,
"type": {"type": "number"},
"python_type": {"type": "float", "description": ""},
"component": "Number",
@ -1046,6 +1082,9 @@ class TestAPIInfo:
"parameters": [
{
"label": "name",
"parameter_name": "name",
"parameter_has_default": True,
"parameter_default": "",
"type": {"type": "string"},
"python_type": {"type": "str", "description": ""},
"component": "Textbox",
@ -1077,6 +1116,9 @@ class TestAPIInfo:
"parameters": [
{
"label": "name",
"parameter_name": "name",
"parameter_has_default": True,
"parameter_default": "",
"type": {"type": "string"},
"python_type": {"type": "str", "description": ""},
"component": "Textbox",
@ -1093,10 +1135,7 @@ class TestAPIInfo:
{
"label": "count",
"type": {"type": "number"},
"python_type": {
"type": "float",
"description": "",
},
"python_type": {"type": "float", "description": ""},
"component": "Number",
},
],
@ -1107,10 +1146,7 @@ class TestAPIInfo:
{
"label": "count",
"type": {"type": "number"},
"python_type": {
"type": "float",
"description": "",
},
"python_type": {"type": "float", "description": ""},
"component": "Number",
}
],
@ -1121,10 +1157,7 @@ class TestAPIInfo:
{
"label": "count",
"type": {"type": "number"},
"python_type": {
"type": "float",
"description": "",
},
"python_type": {"type": "float", "description": ""},
"component": "Number",
}
],

80
client/python/test/test_utils.py
View File

@ -167,3 +167,83 @@ def test_json_schema_to_python_type(schema):
else:
raise ValueError(f"This test has not been modified to check {schema}")
assert utils.json_schema_to_python_type(types[schema]) == answer
class TestConstructArgs:
def test_no_parameters_empty_args(self):
assert utils.construct_args(None, (), {}) == []
def test_no_parameters_with_args(self):
assert utils.construct_args(None, (1, 2), {}) == [1, 2]
def test_no_parameters_with_kwargs(self):
with pytest.raises(
ValueError, match="This endpoint does not support key-word arguments"
):
utils.construct_args(None, (), {"a": 1})
def test_parameters_no_args_kwargs(self):
parameters_info = [
{
"label": "param1",
"parameter_name": "a",
"parameter_has_default": True,
"parameter_default": 10,
}
]
assert utils.construct_args(parameters_info, (), {"a": 1}) == [1]
def test_parameters_with_args_no_kwargs(self):
parameters_info = [{"label": "param1", "parameter_name": "a"}]
assert utils.construct_args(parameters_info, (1,), {}) == [1]
def test_parameter_with_default_no_args_no_kwargs(self):
parameters_info = [
{"label": "param1", "parameter_has_default": True, "parameter_default": 10}
]
assert utils.construct_args(parameters_info, (), {}) == [10]
def test_args_filled_parameters_with_defaults(self):
parameters_info = [
{"label": "param1", "parameter_has_default": True, "parameter_default": 10},
{"label": "param2", "parameter_has_default": True, "parameter_default": 20},
]
assert utils.construct_args(parameters_info, (1,), {}) == [1, 20]
def test_kwargs_filled_parameters_with_defaults(self):
parameters_info = [
{
"label": "param1",
"parameter_name": "a",
"parameter_has_default": True,
"parameter_default": 10,
},
{
"label": "param2",
"parameter_name": "b",
"parameter_has_default": True,
"parameter_default": 20,
},
]
assert utils.construct_args(parameters_info, (), {"a": 1, "b": 2}) == [1, 2]
def test_positional_arg_and_kwarg_for_same_parameter(self):
parameters_info = [{"label": "param1", "parameter_name": "a"}]
with pytest.raises(
ValueError, match="Parameter `a` is already set as a positional argument."
):
utils.construct_args(parameters_info, (1,), {"a": 2})
def test_invalid_kwarg(self):
parameters_info = [{"label": "param1", "parameter_name": "a"}]
with pytest.raises(
ValueError, match="Parameter `b` is not a valid key-word argument."
):
utils.construct_args(parameters_info, (), {"b": 1})
def test_required_arg_missing(self):
parameters_info = [{"label": "param1", "parameter_name": "a"}]
with pytest.raises(
ValueError, match="No value provided for required argument: a"
):
utils.construct_args(parameters_info, (), {})

45
gradio/blocks.py
View File

@ -2473,7 +2473,7 @@ Received outputs:
config = self.config
api_info = {"named_endpoints": {}, "unnamed_endpoints": {}}
for dependency in config["dependencies"]:
for dependency, fn in zip(config["dependencies"], self.fns):
if (
not dependency["backend_fn"]
or not dependency["show_api"]
@ -2482,12 +2482,13 @@ Received outputs:
continue
dependency_info = {"parameters": [], "returns": []}
fn_info = utils.get_function_params(fn.fn) # type: ignore
skip_endpoint = False
inputs = dependency["inputs"]
for i in inputs:
for index, input_id in enumerate(inputs):
for component in config["components"]:
if component["id"] == i:
if component["id"] == input_id:
break
else:
skip_endpoint = True # if component not found, skip endpoint
@ -2495,16 +2496,52 @@ Received outputs:
type = component["props"]["name"]
if self.blocks[component["id"]].skip_api:
continue
label = component["props"].get("label", f"parameter_{i}")
label = component["props"].get("label", f"parameter_{input_id}")
comp = self.get_component(component["id"])
if not isinstance(comp, components.Component):
raise TypeError(f"{comp!r} is not a Component")
info = component["api_info"]
example = comp.example_inputs()
python_type = client_utils.json_schema_to_python_type(info)
# Since the clients use "api_name" and "fn_index" to designate the endpoint and
# "result_callbacks" to specify the callbacks, we need to make sure that no parameters
# have those names. Hence the final checks.
if (
dependency["backend_fn"]
and index < len(fn_info)
and fn_info[index][0]
not in ["api_name", "fn_index", "result_callbacks"]
):
parameter_name = fn_info[index][0]
else:
parameter_name = f"param_{index}"
# How default values are set for the client: if a component has an initial value, then that parameter
# is optional in the client and the initial value from the config is used as default in the client.
# If the component does not have an initial value, but if the corresponding argument in the predict function has
# a default value of None, then that parameter is also optional in the client and the None is used as default in the client.
if component["props"].get("value") is not None:
parameter_has_default = True
parameter_default = component["props"]["value"]
elif (
dependency["backend_fn"]
and index < len(fn_info)
and fn_info[index][1]
and fn_info[index][2] is None
):
parameter_has_default = True
parameter_default = None
else:
parameter_has_default = False
parameter_default = None
dependency_info["parameters"].append(
{
"label": label,
"parameter_name": parameter_name,
"parameter_has_default": parameter_has_default,
"parameter_default": parameter_default,
"type": info,
"python_type": {
"type": python_type,

16
gradio/utils.py
View File

@ -1212,6 +1212,22 @@ def get_upload_folder() -> str:
)
def get_function_params(func: Callable) -> list[tuple[str, bool, Any]]:
params_info = []
signature = inspect.signature(func)
for name, parameter in signature.parameters.items():
if parameter.kind in (
inspect.Parameter.VAR_POSITIONAL,
inspect.Parameter.VAR_KEYWORD,
):
break
if parameter.default is inspect.Parameter.empty:
params_info.append((name, False, None))
else:
params_info.append((name, True, parameter.default))
return params_info
def simplify_file_data_in_str(s):
"""
If a FileData dictionary has been dumped as part of a string, this function will replace the dict with just the str filepath

4
guides/01_getting-started/03_sharing-your-app.md
View File

@ -158,7 +158,9 @@ You can use almost any Gradio app as an API! In the footer of a Gradio app [like
![Use via API](https://github.com/gradio-app/gradio/blob/main/guides/assets/use_via_api.png?raw=true)
This is a page that lists the endpoints that can be used to query the Gradio app, via our supported clients: either [the Python client](https://gradio.app/guides/getting-started-with-the-python-client/), or [the JavaScript client](https://gradio.app/guides/getting-started-with-the-js-client/). For each endpoint, Gradio automatically generates the parameters and their types, as well as example inputs.
This is a page that lists the endpoints that can be used to query the Gradio app, via our supported clients: either [the Python client](https://gradio.app/guides/getting-started-with-the-python-client/), or [the JavaScript client](https://gradio.app/guides/getting-started-with-the-js-client/). For each endpoint, Gradio automatically generates the parameters and their types, as well as example inputs, like this.
![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gradio-guides/view-api.png)
The endpoints are automatically created when you launch a Gradio `Interface`. If you are using Gradio `Blocks`, you can also set up a Gradio API page, though we recommend that you explicitly name each event listener, such as

67
guides/08_gradio-clients-and-lite/01_getting-started-with-the-python-client.md
View File

@ -14,12 +14,15 @@ Here's the entire code to do it:
from gradio_client import Client, file
client = Client("abidlabs/whisper")
client.predict(file("audio_sample.wav"))
client.predict(
audio=file("audio_sample.wav")
)
>> "This is a test of the whisper speech recognition model."
```
The Gradio client works with any hosted Gradio app, whether it be an image generator, a text summarizer, a stateful chatbot, a tax calculator, or anything else! The Gradio Client is mostly used with apps hosted on [Hugging Face Spaces](https://hf.space), but your app can be hosted anywhere, such as your own server.
The Gradio client works with any hosted Gradio app! Although the Client is mostly used with apps hosted on [Hugging Face Spaces](https://hf.space), your app can be hosted anywhere, such as your own server.
**Prerequisites**: To use the Gradio client, you do _not_ need to know the `gradio` library in great detail. However, it is helpful to have general familiarity with Gradio's concepts of input and output components.
@ -27,17 +30,15 @@ The Gradio client works with any hosted Gradio app, whether it be an image gener
If you already have a recent version of `gradio`, then the `gradio_client` is included as a dependency. But note that this documentation reflects the latest version of the `gradio_client`, so upgrade if you're not sure!
The lightweight `gradio_client` package can be installed from pip (or pip3) and is tested to work with Python versions 3.9 or higher:
The lightweight `gradio_client` package can be installed from pip (or pip3) and is tested to work with **Python versions 3.9 or higher**:
```bash
$ pip install --upgrade gradio_client
```
## Connecting to a running Gradio App
## Connecting to a Gradio App on Hugging Face Spaces
Start by connecting instantiating a `Client` object and connecting it to a Gradio app that is running on Hugging Face Spaces or generally anywhere on the web.
## Connecting to a Hugging Face Space
Start by connecting instantiating a `Client` object and connecting it to a Gradio app that is running on Hugging Face Spaces.
```python
from gradio_client import Client
@ -53,6 +54,7 @@ from gradio_client import Client
client = Client("abidlabs/my-private-space", hf_token="...")
```
## Duplicating a Space for private use
While you can use any public Space as an API, you may get rate limited by Hugging Face if you make too many requests. For unlimited usage of a Space, simply duplicate the Space to create a private Space,
@ -95,16 +97,21 @@ Client.predict() Usage Info
---------------------------
Named API endpoints: 1
- predict(input_audio, api_name="/predict") -> value_0
- predict(audio, api_name="/predict") -> output
Parameters:
- [Audio] input_audio: str (filepath or URL)
- [Audio] audio: filepath (required)
Returns:
- [Textbox] value_0: str (value)
- [Textbox] output: str
```
This shows us that we have 1 API endpoint in this space, and shows us how to use the API endpoint to make a prediction: we should call the `.predict()` method (which we will explore below), providing a parameter `input_audio` of type `str`, which is a `filepath or URL`.
We should also provide the `api_name='/predict'` argument to the `predict()` method. Although this isn't necessary if a Gradio app has only 1 named endpoint, it does allow us to call different endpoints in a single app if they are available. If an app has unnamed API endpoints, these can also be displayed by running `.view_api(all_endpoints=True)`.
Alternatively, you can click on the "Use via API" link in the footer of the Gradio app, which shows us the same information, along with example usage.
![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/gradio-guides/view-api.png)
We see that we have 1 API endpoint in this space, and shows us how to use the API endpoint to make a prediction: we should call the `.predict()` method (which we will explore below), providing a parameter `input_audio` of type `str`, which is a `filepath or URL`.
We should also provide the `api_name='/predict'` argument to the `predict()` method. Although this isn't necessary if a Gradio app has only 1 named endpoint, it does allow us to call different endpoints in a single app if they are available.
## Making a prediction
@ -130,13 +137,45 @@ client.predict(4, "add", 5)
>> 9.0
```
For when working with files (e.g. image files), you should pass in the filepath or URL to the file enclosed within `gradio_client.file()`.
It is recommended to provide key-word arguments instead of positional arguments:
```python
from gradio_client import Client
client = Client("gradio/calculator")
client.predict(num1=4, operation="add", num2=5)
>> 9.0
```
This allows you to take advantage of default arguments. For example, this Space includes the default value for the Slider component so you do not need to provide it when accessing it with the client.
```python
from gradio_client import Client
client = Client("abidlabs/image_generator")
client.predict(text="an astronaut riding a camel")
```
The default value is the initial value of the corresponding Gradio component. If the component does not have an initial value, but if the corresponding argument in the predict function has a default value of `None`, then that parameter is also optional in the client. Of course, if you'd like to override it, you can include it as well:
```python
from gradio_client import Client
client = Client("abidlabs/image_generator")
client.predict(text="an astronaut riding a camel", steps=25)
```
For providing files or URLs as inputs, you should pass in the filepath or URL to the file enclosed within `gradio_client.file()`. This takes care of uploading the file to the Gradio server and ensures that the file is preprocessed correctly:
```python
from gradio_client import Client, file
client = Client("abidlabs/whisper")
client.predict(file("https://audio-samples.github.io/samples/mp3/blizzard_unconditional/sample-0.mp3"))
client.predict(
audio=file("https://audio-samples.github.io/samples/mp3/blizzard_unconditional/sample-0.mp3")
)
>> "My thought I have nobody by a beauty and will as you poured. Mr. Rochester is serve in that so don't find simpus, and devoted abode, to at might in a r—"
```

26
js/app/src/api_docs/ApiDocs.svelte
View File

@ -9,12 +9,13 @@
import { represent_value } from "./utils";
import ApiBanner from "./ApiBanner.svelte";
import ResponseObject from "./ResponseObject.svelte";
import ParametersSnippet from "./ParametersSnippet.svelte";
import InstallSnippet from "./InstallSnippet.svelte";
import CodeSnippets from "./CodeSnippets.svelte";
import CodeSnippet from "./CodeSnippet.svelte";
import python from "./img/python.svg";
import javascript from "./img/javascript.svg";
import ResponseSnippet from "./ResponseSnippet.svelte";
export let dependencies: Dependency[];
export let root: string;
@ -223,7 +224,7 @@
{#each dependencies as dependency, dependency_index}
{#if dependency.show_api}
<div class="endpoint-container">
<CodeSnippets
<CodeSnippet
named={true}
endpoint_parameters={info.named_endpoints[
"/" + dependency.api_name
@ -235,16 +236,19 @@
{dependency_index}
{current_language}
root={space_id || root}
{dependency_failures}
/>
<!-- <TryButton
named={true}
{dependency_index}
{run}
/> -->
<ParametersSnippet
endpoint_returns={info.named_endpoints[
"/" + dependency.api_name
].parameters}
js_returns={js_info.named_endpoints["/" + dependency.api_name]
.parameters}
{is_running}
{current_language}
/>
<ResponseObject
<ResponseSnippet
endpoint_returns={info.named_endpoints[
"/" + dependency.api_name
].returns}
@ -360,7 +364,7 @@
.endpoint-container {
margin-top: var(--size-3);
margin-bottom: var(--size-3);
border: 1px solid var(--border-color-primary);
border: 1px solid var(--body-text-color);
border-radius: var(--radius-xl);
padding: var(--size-3);
padding-top: 0;

52
js/app/src/api_docs/CodeSnippets.svelte → js/app/src/api_docs/CodeSnippet.svelte
View File

@ -17,7 +17,6 @@
export let dependency: Dependency;
export let dependency_index: number;
export let root: string;
export let dependency_failures: boolean[][];
export let endpoint_parameters: any;
export let js_parameters: any;
export let named: boolean;
@ -49,35 +48,30 @@
<CopyButton code={python_code?.innerText} />
</div>
<div bind:this={python_code}>
<pre>from gradio_client import Client{#if has_file_path}, file{/if}
<pre><span class="highlight">from</span> gradio_client <span
class="highlight">import</span
> Client{#if has_file_path}, file{/if}
client = Client(<span class="token string">"{root}"</span>)
result = client.predict(<!--
-->{#each endpoint_parameters as { label, type, python_type, component, example_input, serializer }, i}<!--
result = client.<span class="highlight">predict</span
>(<!--
-->{#each endpoint_parameters as { python_type, example_input, parameter_name, parameter_has_default, parameter_default }, i}<!--
-->
<span
class="example-inputs"
>{represent_value(example_input, python_type.type, "py")}</span
>,<!--
-->{#if dependency_failures[dependency_index][i]}<!--
--><span
class="error">ERROR</span
><!--
-->{/if}<!--
--><span class="desc"
><!--
--> # {python_type.type} {#if python_type.description}({python_type.description})
{/if}<!---->in '{label}' <!--
-->{component} component<!--
--></span
><!--
-->{/each}<!--
{parameter_name
? parameter_name + "="
: ""}<span class="example-inputs"
>{represent_value(
parameter_has_default ? parameter_default : example_input,
python_type.type,
"py"
)}</span
>,{/each}<!--
-->
api_name="/{dependency.api_name}"<!--
api_name=<span class="api-name">"/{dependency.api_name}"</span><!--
-->
)
print(result)</pre>
<span class="highlight">print</span>(result)</pre>
</div>
{:else if current_language === "javascript"}
<div class="copy">
@ -170,20 +164,14 @@ console.log(result.data);
margin-bottom: var(--size-3);
}
.error {
color: var(--error-text-color);
}
.desc {
color: var(--body-text-color-subdued);
}
.example-inputs {
border: 1px solid var(--border-color-accent);
border-radius: var(--radius-sm);
background: var(--color-accent-soft);
padding-right: var(--size-1);
padding-left: var(--size-1);
color: var(--color-accent);
}
.api-name {
color: var(--color-accent);
}
</style>

2
js/app/src/api_docs/InstallSnippet.svelte
View File

@ -8,7 +8,7 @@
let js_install = "npm i -D @gradio/client";
</script>
<Block>
<Block border_mode="contrast">
<code>
{#if current_language === "python"}
<div class="copy">

106
js/app/src/api_docs/ParametersSnippet.svelte Normal file
View File

@ -0,0 +1,106 @@
<script lang="ts">
import { Loader } from "@gradio/statustracker";
import { represent_value } from "./utils";
export let is_running: boolean;
export let endpoint_returns: any;
export let js_returns: any;
export let current_language: "python" | "javascript";
</script>
<h4>
<div class="toggle-icon">
<div class="toggle-dot" />
</div>
Accepts {endpoint_returns.length} parameter{#if endpoint_returns.length != 1}s{/if}:
</h4>
<div class:hide={is_running}>
{#each endpoint_returns as { label, python_type, component, parameter_name, parameter_has_default, parameter_default }, i}
<hr class="hr" />
<div style="margin:10px;">
<p style="white-space: nowrap; overflow-x: auto;">
<span class="code" style="margin-right: 10px;"
>{parameter_name && current_language == "python"
? parameter_name
: "[" + i + "]"}</span
>
<span class="code highlight" style="margin-right: 10px;"
>{#if current_language === "python"}{python_type.type}{#if parameter_has_default && parameter_default === null}&nbsp;|
None{/if}{:else}{js_returns[i].type}{/if}</span
>
{#if !parameter_has_default || current_language == "javascript"}<span
style="font-weight:bold">Required</span
>{:else}<span> Default: </span><span
class="code"
style="font-size: var(--text-sm);"
>{represent_value(parameter_default, python_type.type, "py")}</span
>{/if}
</p>
<p class="desc">
The input value that is provided in the "{label}" <!--
-->{component}
component<!--
-->.
</p>
</div>
{/each}
</div>
{#if is_running}
<div class="load-wrap">
<Loader margin={false} />
</div>
{/if}
<style>
.hr {
border: 0;
height: 1px;
background: var(--color-accent-soft);
margin-bottom: 12px;
}
.code {
font-family: var(--font-mono);
display: inline;
}
.highlight {
background: var(--color-accent-soft);
color: var(--color-accent);
padding: var(--size-1);
}
.desc {
color: var(--body-text-color-subdued);
font-size: var(--text-lg);
margin-top: var(--size-1);
}
h4 {
display: flex;
align-items: center;
margin-top: var(--size-6);
margin-bottom: var(--size-3);
color: var(--body-text-color);
font-weight: var(--weight-bold);
}
.toggle-icon {
display: flex;
align-items: center;
margin-right: var(--size-2);
border-radius: var(--radius-full);
background: var(--color-grey-300);
width: 12px;
height: 4px;
}
.toggle-dot {
border-radius: var(--radius-full);
background: var(--color-grey-700);
width: 6px;
height: 6px;
margin-right: auto;
}
</style>

95
js/app/src/api_docs/ResponseObject.svelte
View File

@ -1,95 +0,0 @@
<script lang="ts">
import { Loader } from "@gradio/statustracker";
import { Block } from "@gradio/atoms";
export let is_running: boolean;
export let endpoint_returns: any;
export let js_returns: any;
export let current_language: "python" | "javascript";
</script>
<h4>
<div class="toggle-icon">
<div class="toggle-dot" />
</div>
Return Type(s)
</h4>
<Block>
<div class="response-wrap">
<div class:hide={is_running}>
{#if endpoint_returns.length > 1}({/if}
{#each endpoint_returns as { label, type, python_type, component, serializer }, i}
<div class:second-level={endpoint_returns.length > 1}>
<span class="desc"
><!--
--> # {#if current_language === "python"}{python_type.type}{#if python_type?.description}&nbsp;({python_type.description}){/if}{:else}{js_returns[
i
].type}{#if js_returns[i].description}&nbsp;({js_returns[i]
.description}){/if}{/if}
<!--
-->representing output in '{label}' <!--
-->{component}
component<!--
--></span
>{#if endpoint_returns.length > 1},{/if}
</div>
{/each}
{#if endpoint_returns.length > 1}){/if}
</div>
{#if is_running}
<div class="load-wrap">
<Loader margin={false} />
</div>
{/if}
</div>
</Block>
<style>
.load-wrap {
display: flex;
justify-content: center;
align-items: center;
}
h4 {
display: flex;
align-items: center;
margin-top: var(--size-6);
margin-bottom: var(--size-3);
color: var(--body-text-color);
font-weight: var(--weight-bold);
}
.toggle-icon {
display: flex;
align-items: center;
margin-right: var(--size-2);
border-radius: var(--radius-full);
background: var(--color-grey-300);
width: 12px;
height: 4px;
}
.toggle-dot {
margin-left: auto;
border-radius: var(--radius-full);
background: var(--color-grey-700);
width: 6px;
height: 6px;
}
.response-wrap {
font-family: var(--font-mono);
}
.desc {
color: var(--body-text-color-subdued);
}
.hide {
display: none;
}
.second-level {
margin-left: var(--size-4);
}
</style>

97
js/app/src/api_docs/ResponseSnippet.svelte Normal file
View File

@ -0,0 +1,97 @@
<script lang="ts">
import { Loader } from "@gradio/statustracker";
export let is_running: boolean;
export let endpoint_returns: any;
export let js_returns: any;
export let current_language: "python" | "javascript";
</script>
<h4>
<div class="toggle-icon">
<div class="toggle-dot toggle-right" />
</div>
Returns {#if endpoint_returns.length > 1}
{current_language == "python" ? "tuple" : "list"} of {endpoint_returns.length}
elements{:else}
1 element{/if}
</h4>
<div class:hide={is_running}>
{#each endpoint_returns as { label, type, python_type, component, serializer }, i}
<hr class="hr" />
<div style="margin:10px;">
<p>
{#if endpoint_returns.length > 1}
<span class="code">[{i}]</span>
{/if}
<span class="code highlight"
>{#if current_language === "python"}{python_type.type}{:else}{js_returns[
i
].type}{/if}</span
>
</p>
<p class="desc">
The output value that appears in the "{label}" <!--
-->{component}
component<!--
-->.
</p>
</div>
{/each}
</div>
{#if is_running}
<div class="load-wrap">
<Loader margin={false} />
</div>
{/if}
<style>
.hr {
border: 0;
height: 1px;
background: var(--color-accent-soft);
}
.code {
font-family: var(--font-mono);
margin-right: 10px;
}
.highlight {
background: var(--color-accent-soft);
color: var(--color-accent);
padding: var(--size-1);
}
.desc {
color: var(--body-text-color-subdued);
font-size: var(--text-lg);
}
h4 {
display: flex;
align-items: center;
margin-top: var(--size-6);
margin-bottom: var(--size-3);
color: var(--body-text-color);
font-weight: var(--weight-bold);
}
.toggle-icon {
display: flex;
align-items: center;
margin-right: var(--size-2);
border-radius: var(--radius-full);
background: var(--color-grey-300);
width: 12px;
height: 4px;
}
.toggle-dot {
border-radius: var(--radius-full);
background: var(--color-grey-700);
width: 6px;
height: 6px;
margin-left: auto;
}
</style>

9
js/app/src/api_docs/utils.ts
View File

@ -7,6 +7,9 @@ export function represent_value(
if (type === undefined) {
return lang === "py" ? "None" : null;
}
if (value === null && lang === "py") {
return "None";
}
if (type === "string" || type === "str") {
return lang === null ? value : '"' + value + '"';
} else if (type === "number") {
@ -43,7 +46,7 @@ export function represent_value(
export function is_potentially_nested_file_data(obj: any): boolean {
if (typeof obj === "object" && obj !== null) {
if (obj.hasOwnProperty("path") && obj.hasOwnProperty("meta")) {
if (obj.hasOwnProperty("url") && obj.hasOwnProperty("meta")) {
if (
typeof obj.meta === "object" &&
obj.meta !== null &&
@ -69,11 +72,11 @@ export function is_potentially_nested_file_data(obj: any): boolean {
function replace_file_data_with_file_function(obj: any): any {
if (typeof obj === "object" && obj !== null && !Array.isArray(obj)) {
if (
"path" in obj &&
"url" in obj &&
"meta" in obj &&
obj.meta?._type === "gradio.FileData"
) {
return `file('${obj.path}')`;
return `file('${obj.url}')`;
}
}
if (Array.isArray(obj)) {

7
js/atoms/src/Block.svelte
View File

@ -4,7 +4,7 @@
export let elem_id = "";
export let elem_classes: string[] = [];
export let variant: "solid" | "dashed" | "none" = "solid";
export let border_mode: "base" | "focus" = "base";
export let border_mode: "base" | "focus" | "contrast" = "base";
export let padding = true;
export let type: "normal" | "fieldset" = "normal";
export let test_id: string | undefined = undefined;
@ -39,6 +39,7 @@
class="block {elem_classes.join(' ')}"
class:padded={padding}
class:border_focus={border_mode === "focus"}
class:border_contrast={border_mode === "contrast"}
class:hide-container={!explicit_call && !container}
style:height={get_dimension(height)}
style:width={typeof width === "number"
@ -70,6 +71,10 @@
border-color: var(--color-accent);
}
.block.border_contrast {
border-color: var(--body-text-color);
}
.padded {
padding: var(--block-padding);
}

4
test/test_external.py
View File

@ -289,9 +289,7 @@ class TestLoadInterface:
io = gr.load("models/osanseviero/BigGAN-deep-128")
try:
filename = io("chest")
assert filename.lower().endswith(".jpg") or filename.lower().endswith(
".jpeg"
)
assert filename.lower().endswith((".jpg", ".jpeg", ".png"))
except TooManyRequestsError:
pass

72
test/test_utils.py
View File

@ -23,6 +23,7 @@ from gradio.utils import (
download_if_url,
get_continuous_fn,
get_extension_from_file_path_or_url,
get_function_params,
get_type_hints,
ipython_check,
is_in_or_equal,
@ -453,3 +454,74 @@ def test_get_extension_from_file_path_or_url(path_or_url, extension):
)
def test_diff(old, new, expected_diff):
assert diff(old, new) == expected_diff
class TestFunctionParams:
def test_regular_function(self):
def func(a, b=10, c="default", d=None):
pass
assert get_function_params(func) == [
("a", False, None),
("b", True, 10),
("c", True, "default"),
("d", True, None),
]
def test_function_no_params(self):
def func():
pass
assert get_function_params(func) == []
def test_lambda_function(self):
assert get_function_params(lambda x, y: x + y) == [
("x", False, None),
("y", False, None),
]
def test_function_with_args(self):
def func(a, *args):
pass
assert get_function_params(func) == [("a", False, None)]
def test_function_with_kwargs(self):
def func(a, **kwargs):
pass
assert get_function_params(func) == [("a", False, None)]
def test_class_method_skip_first_param(self):
class MyClass:
def method(self, arg1, arg2=42):
pass
assert get_function_params(MyClass().method) == [
("arg1", False, None),
("arg2", True, 42),
]
def test_static_method_no_skip(self):
class MyClass:
@staticmethod
def method(arg1, arg2=42):
pass
assert get_function_params(MyClass.method) == [
("arg1", False, None),
("arg2", True, 42),
]
def test_class_method_with_args(self):
class MyClass:
def method(self, a, *args, b=42):
pass
assert get_function_params(MyClass().method) == [("a", False, None)]
def test_lambda_with_args(self):
assert get_function_params(lambda x, *args: x) == [("x", False, None)]
def test_lambda_with_kwargs(self):
assert get_function_params(lambda x, **kwargs: x) == [("x", False, None)]