gradio

1
from collections import namedtuple
2
from datetime import datetime, timedelta
3
from enum import Enum
4
from pathlib import Path
5
from typing import ClassVar, Dict, List, Literal, Optional, Set, Tuple, Union
6
from uuid import UUID
7

8
import pytest
9
from gradio_client.utils import json_schema_to_python_type
10
from pydantic import Field, confloat, conint, conlist
11
from pydantic.networks import AnyUrl, EmailStr, IPvAnyAddress
12

13
from gradio.data_classes import GradioModel, GradioRootModel
14

15

16
class StringModel(GradioModel):
17
    data: str
18
    answer: ClassVar = "Dict(data: str)"
19

20

21
class IntegerRootModel(GradioRootModel):
22
    root: int
23

24
    answer: ClassVar = "int"
25

26

27
class FloatModel(GradioModel):
28
    data: float
29

30
    answer: ClassVar = "Dict(data: float)"
31

32

33
class ListModel(GradioModel):
34
    items: List[int]
35

36
    answer: ClassVar = "Dict(items: List[int])"
37

38

39
class DictModel(GradioModel):
40
    data_dict: Dict[str, int]
41

42
    answer: ClassVar = "Dict(data_dict: Dict(str, int))"
43

44

45
class DictModel2(GradioModel):
46
    data_dict: Dict[str, List[float]]
47

48
    answer: ClassVar = "Dict(data_dict: Dict(str, List[float]))"
49

50

51
class OptionalModel(GradioModel):
52
    optional_data: Optional[int]
53

54
    answer: ClassVar = "Dict(optional_data: int | None)"
55

56

57
class ColorEnum(Enum):
58
    RED = "red"
59
    GREEN = "green"
60
    BLUE = "blue"
61

62

63
class EnumRootModel(GradioModel):
64
    color: ColorEnum
65

66
    answer: ClassVar = "Dict(color: Literal['red', 'green', 'blue'])"
67

68

69
class EmailModel(GradioModel):
70
    email: EmailStr
71

72
    answer: ClassVar = "Dict(email: str)"
73

74

75
class RootWithNestedModel(GradioModel):
76
    nested_int: IntegerRootModel
77
    nested_enum: EnumRootModel
78
    nested_dict: DictModel2
79

80
    answer: ClassVar = "Dict(nested_int: int, nested_enum: Dict(color: Literal['red', 'green', 'blue']), nested_dict: Dict(data_dict: Dict(str, List[float])))"
81

82

83
class LessNestedModel(GradioModel):
84
    nested_int: int
85
    nested_enum: ColorEnum
86
    nested_dict: Dict[str, List[Union[int, float]]]
87

88
    answer: ClassVar = "Dict(nested_int: int, nested_enum: Literal['red', 'green', 'blue'], nested_dict: Dict(str, List[int | float]))"
89

90

91
class StatusModel(GradioModel):
92
    status: Literal["active", "inactive"]
93

94
    answer: ClassVar = "Dict(status: Literal['active', 'inactive'])"
95

96

97
class PointModel(GradioRootModel):
98
    root: Tuple[float, float]
99

100
    answer: ClassVar = "Tuple[float, float]"
101

102

103
class UuidModel(GradioModel):
104
    uuid: UUID
105

106
    answer: ClassVar = "Dict(uuid: str)"
107

108

109
class UrlModel(GradioModel):
110
    url: AnyUrl
111

112
    answer: ClassVar = "Dict(url: str)"
113

114

115
class CustomFieldModel(GradioModel):
116
    name: str = Field(..., title="Name of the item", max_length=50)
117
    price: float = Field(..., title="Price of the item", gt=0)
118

119
    answer: ClassVar = "Dict(name: str, price: float)"
120

121

122
class DurationModel(GradioModel):
123
    duration: timedelta
124

125
    answer: ClassVar = "Dict(duration: str)"
126

127

128
class IPv4Model(GradioModel):
129
    ipv4_address: IPvAnyAddress
130

131
    answer: ClassVar = "Dict(ipv4_address: str)"
132

133

134
class DateTimeModel(GradioModel):
135
    created_at: datetime
136
    updated_at: datetime
137

138
    answer: ClassVar = "Dict(created_at: str, updated_at: str)"
139

140

141
class SetModel(GradioModel):
142
    unique_numbers: Set[int]
143

144
    answer: ClassVar = "Dict(unique_numbers: List[int])"
145

146

147
class ItemModel(GradioModel):
148
    name: str
149
    price: float
150

151

152
class OrderModel(GradioModel):
153
    items: List[ItemModel]
154

155
    answer: ClassVar = "Dict(items: List[Dict(name: str, price: float)])"
156

157

158
class TemperatureUnitEnum(Enum):
159
    CELSIUS = "Celsius"
160
    FAHRENHEIT = "Fahrenheit"
161
    KELVIN = "Kelvin"
162

163

164
class TemperatureConversionModel(GradioModel):
165
    temperature: confloat(ge=-273.15, le=1.416808)
166
    from_unit: TemperatureUnitEnum
167
    to_unit: TemperatureUnitEnum = Field(..., title="Target temperature unit")
168

169
    answer: ClassVar = "Dict(temperature: float, from_unit: Literal['Celsius', 'Fahrenheit', 'Kelvin'], to_unit: All[Literal['Celsius', 'Fahrenheit', 'Kelvin']])"
170

171

172
class CartItemModel(GradioModel):
173
    product_name: str = Field(..., title="Name of the product", max_length=50)
174
    quantity: int = Field(..., title="Quantity of the product", ge=1)
175
    price_per_unit: float = Field(..., title="Price per unit", gt=0)
176

177

178
class ShoppingCartModel(GradioModel):
179
    items: List[CartItemModel]
180

181
    answer: ClassVar = "Dict(items: List[Dict(product_name: str, quantity: int, price_per_unit: float)])"
182

183

184
class CoordinateModel(GradioModel):
185
    latitude: float
186
    longitude: float
187

188

189
class PathModel(GradioModel):
190
    coordinates: conlist(CoordinateModel, min_length=2, max_length=2)
191

192
    answer: ClassVar = (
193
        "Dict(coordinates: List[Dict(latitude: float, longitude: float)])"
194
    )
195

196

197
class CreditCardModel(GradioModel):
198
    card_number: conint(ge=1, le=9999999999999999)
199

200
    answer: ClassVar = "Dict(card_number: int)"
201

202

203
class TupleListModel(GradioModel):
204
    data: List[Tuple[int, str]]
205

206
    answer: ClassVar = "Dict(data: List[Tuple[int, str]]"
207

208

209
class PathListModel(GradioModel):
210
    file_paths: List[Path]
211

212
    answer: ClassVar = "Dict(file_paths: List[str])"
213

214

215
class PostModel(GradioModel):
216
    author: str
217
    content: str
218
    tags: List[str]
219
    likes: int = 0
220

221
    answer: ClassVar = "Dict(author: str, content: str, tags: List[str], likes: int)"
222

223

224
Person = namedtuple("Person", ["name", "age"])
225

226

227
class NamedTupleDictionaryModel(GradioModel):
228
    people: Dict[str, Person]
229

230
    answer: ClassVar = "Dict(people: Dict(str, Tuple[Any, Any]))"
231

232

233
MODELS = [
234
    StringModel,
235
    IntegerRootModel,
236
    FloatModel,
237
    ListModel,
238
    DictModel,
239
    DictModel2,
240
    OptionalModel,
241
    EnumRootModel,
242
    EmailModel,
243
    RootWithNestedModel,
244
    LessNestedModel,
245
    StatusModel,
246
    PointModel,
247
    UuidModel,
248
    UrlModel,
249
    CustomFieldModel,
250
    DurationModel,
251
    IPv4Model,
252
    DateTimeModel,
253
    SetModel,
254
    OrderModel,
255
    TemperatureConversionModel,
256
    ShoppingCartModel,
257
    PathModel,
258
    CreditCardModel,
259
    PathListModel,
260
    NamedTupleDictionaryModel,
261
]
262

263

264
@pytest.mark.parametrize("model", MODELS)
265
def test_api_info_for_model(model):
266
    assert json_schema_to_python_type(model.model_json_schema()) == model.answer
267