{!> ../../../docs_src/query_params_str_validations/tutorial001_py310.py!}
```
-The query parameter `q` is of type `Optional[str]` (or `str | None` in Python 3.10), that means that it's of type `str` but could also be `None`, and indeed, the default value is `None`, so FastAPI will know it's not required.
+The query parameter `q` is of type `Union[str, None]` (or `str | None` in Python 3.10), that means that it's of type `str` but could also be `None`, and indeed, the default value is `None`, so FastAPI will know it's not required.
!!! note
FastAPI will know that the value of `q` is not required because of the default value `= None`.
- The `Optional` in `Optional[str]` is not used by FastAPI, but will allow your editor to give you better support and detect errors.
+ The `Union` in `Union[str, None]` will allow your editor to give you better support and detect errors.
## Additional validation
{!> ../../../docs_src/query_params_str_validations/tutorial002_py310.py!}
```
-As we have to replace the default value `None` with `Query(None)`, the first parameter to `Query` serves the same purpose of defining that default value.
+As we have to replace the default value `None` in the function with `Query()`, we can now set the default value with the parameter `Query(default=None)`, it serves the same purpose of defining that default value.
So:
```Python
-q: Optional[str] = Query(None)
+q: Union[str, None] = Query(default=None)
```
...makes the parameter optional, the same as:
```Python
-q: Optional[str] = None
+q: Union[str, None] = None
```
And in Python 3.10 and above:
```Python
-q: str | None = Query(None)
+q: str | None = Query(default=None)
```
...makes the parameter optional, the same as:
or the:
```Python
- = Query(None)
+ = Query(default=None)
```
as it will use that `None` as the default value, and that way make the parameter **not required**.
- The `Optional` part allows your editor to provide better support, but it is not what tells FastAPI that this parameter is not required.
+ The `Union[str, None]` part allows your editor to provide better support, but it is not what tells FastAPI that this parameter is not required.
Then, we can pass more parameters to `Query`. In this case, the `max_length` parameter that applies to strings:
```Python
-q: str = Query(None, max_length=50)
+q: Union[str, None] = Query(default=None, max_length=50)
```
This will validate the data, show a clear error when the data is not valid, and document the parameter in the OpenAPI schema *path operation*.
=== "Python 3.6 and above"
- ```Python hl_lines="9"
+ ```Python hl_lines="10"
{!> ../../../docs_src/query_params_str_validations/tutorial003.py!}
```
=== "Python 3.6 and above"
- ```Python hl_lines="10"
+ ```Python hl_lines="11"
{!> ../../../docs_src/query_params_str_validations/tutorial004.py!}
```
=== "Python 3.10 and above"
- ```Python hl_lines="8"
+ ```Python hl_lines="9"
{!> ../../../docs_src/query_params_str_validations/tutorial004_py310.py!}
```
## Default values
-The same way that you can pass `None` as the first argument to be used as the default value, you can pass other values.
+The same way that you can pass `None` as the value for the `default` parameter, you can pass other values.
Let's say that you want to declare the `q` query parameter to have a `min_length` of `3`, and to have a default value of `"fixedquery"`:
instead of:
```Python
-q: Optional[str] = None
+q: Union[str, None] = None
```
But we are now declaring it with `Query`, for example like:
```Python
-q: Optional[str] = Query(None, min_length=3)
+q: Union[str, None] = Query(default=None, min_length=3)
```
-So, when you need to declare a value as required while using `Query`, you can use `...` as the first argument:
+So, when you need to declare a value as required while using `Query`, you can simply not declare a default value:
```Python hl_lines="7"
{!../../../docs_src/query_params_str_validations/tutorial006.py!}
```
+### Required with Ellipsis (`...`)
+
+There's an alternative way to explicitly declare that a value is required. You can set the `default` parameter to the literal value `...`:
+
+```Python hl_lines="7"
+{!../../../docs_src/query_params_str_validations/tutorial006b.py!}
+```
+
!!! info
If you hadn't seen that `...` before: it is a special single value, it is <a href="https://docs.python.org/3/library/constants.html#Ellipsis" class="external-link" target="_blank">part of Python and is called "Ellipsis"</a>.
+ It is used by Pydantic and FastAPI to explicitly declare that a value is required.
+
This will let **FastAPI** know that this parameter is required.
+### Required with `None`
+
+You can declare that a parameter can accept `None`, but that it's still required. This would force clients to send a value, even if the value is `None`.
+
+To do that, you can declare that `None` is a valid type but still use `default=...`:
+
+=== "Python 3.6 and above"
+
+ ```Python hl_lines="8"
+ {!> ../../../docs_src/query_params_str_validations/tutorial006c.py!}
+ ```
+
+=== "Python 3.10 and above"
+
+ ```Python hl_lines="7"
+ {!> ../../../docs_src/query_params_str_validations/tutorial006c_py310.py!}
+ ```
+
+!!! tip
+ Pydantic, which is what powers all the data validation and serialization in FastAPI, has a special behavior when you use `Optional` or `Union[Something, None]` without a default value, you can read more about it in the Pydantic docs about <a href="https://pydantic-docs.helpmanual.io/usage/models/#required-optional-fields" class="external-link" target="_blank">Required Optional fields</a>.
+
+### Use Pydantic's `Required` instead of Ellipsis (`...`)
+
+If you feel uncomfortable using `...`, you can also import and use `Required` from Pydantic:
+
+```Python hl_lines="2 8"
+{!../../../docs_src/query_params_str_validations/tutorial006d.py!}
+```
+
+!!! tip
+ Remember that in most of the cases, when something is required, you can simply omit the `default` parameter, so you normally don't have to use `...` nor `Required`.
+
## Query parameter list / multiple values
When you define a query parameter explicitly with `Query` you can also declare it to receive a list of values, or said in other way, to receive multiple values.
=== "Python 3.10 and above"
- ```Python hl_lines="7"
+ ```Python hl_lines="8"
{!> ../../../docs_src/query_params_str_validations/tutorial007_py310.py!}
```
=== "Python 3.10 and above"
- ```Python hl_lines="7"
+ ```Python hl_lines="8"
{!> ../../../docs_src/query_params_str_validations/tutorial014_py310.py!}
```
-from typing import Optional
+from typing import Union
from fastapi import Body, FastAPI, status
from fastapi.responses import JSONResponse
@app.put("/items/{item_id}")
async def upsert_item(
- item_id: str, name: Optional[str] = Body(None), size: Optional[int] = Body(None)
+ item_id: str,
+ name: Union[str, None] = Body(default=None),
+ size: Union[int, None] = Body(default=None),
):
if item_id in items:
item = items[item_id]
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Header, HTTPException
from pydantic import BaseModel
class Item(BaseModel):
id: str
title: str
- description: Optional[str] = None
+ description: Union[str, None] = None
@app.get("/items/{item_id}", response_model=Item)
-async def read_main(item_id: str, x_token: str = Header(...)):
+async def read_main(item_id: str, x_token: str = Header()):
if x_token != fake_secret_token:
raise HTTPException(status_code=400, detail="Invalid X-Token header")
if item_id not in fake_db:
@app.post("/items/", response_model=Item)
-async def create_item(item: Item, x_token: str = Header(...)):
+async def create_item(item: Item, x_token: str = Header()):
if x_token != fake_secret_token:
raise HTTPException(status_code=400, detail="Invalid X-Token header")
if item.id in fake_db:
@app.get("/items/{item_id}", response_model=Item)
-async def read_main(item_id: str, x_token: str = Header(...)):
+async def read_main(item_id: str, x_token: str = Header()):
if x_token != fake_secret_token:
raise HTTPException(status_code=400, detail="Invalid X-Token header")
if item_id not in fake_db:
@app.post("/items/", response_model=Item)
-async def create_item(item: Item, x_token: str = Header(...)):
+async def create_item(item: Item, x_token: str = Header()):
if x_token != fake_secret_token:
raise HTTPException(status_code=400, detail="Invalid X-Token header")
if item.id in fake_db:
from fastapi import Header, HTTPException
-async def get_token_header(x_token: str = Header(...)):
+async def get_token_header(x_token: str = Header()):
if x_token != "fake-super-secret-token":
raise HTTPException(status_code=400, detail="X-Token header invalid")
-from typing import Optional
+from typing import Union
from fastapi import Body, FastAPI
from pydantic import BaseModel, Field
class Item(BaseModel):
name: str
- description: Optional[str] = Field(
- None, title="The description of the item", max_length=300
+ description: Union[str, None] = Field(
+ default=None, title="The description of the item", max_length=300
)
- price: float = Field(..., gt=0, description="The price must be greater than zero")
- tax: Optional[float] = None
+ price: float = Field(gt=0, description="The price must be greater than zero")
+ tax: Union[float, None] = None
@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item = Body(..., embed=True)):
+async def update_item(item_id: int, item: Item = Body(embed=True)):
results = {"item_id": item_id, "item": item}
return results
class Item(BaseModel):
name: str
description: str | None = Field(
- None, title="The description of the item", max_length=300
+ default=None, title="The description of the item", max_length=300
)
- price: float = Field(..., gt=0, description="The price must be greater than zero")
+ price: float = Field(gt=0, description="The price must be greater than zero")
tax: float | None = None
@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item = Body(..., embed=True)):
+async def update_item(item_id: int, item: Item = Body(embed=True)):
results = {"item_id": item_id, "item": item}
return results
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Path
from pydantic import BaseModel
class Item(BaseModel):
name: str
- description: Optional[str] = None
+ description: Union[str, None] = None
price: float
- tax: Optional[float] = None
+ tax: Union[float, None] = None
@app.put("/items/{item_id}")
async def update_item(
*,
- item_id: int = Path(..., title="The ID of the item to get", ge=0, le=1000),
- q: Optional[str] = None,
- item: Optional[Item] = None,
+ item_id: int = Path(title="The ID of the item to get", ge=0, le=1000),
+ q: Union[str, None] = None,
+ item: Union[Item, None] = None,
):
results = {"item_id": item_id}
if q:
@app.put("/items/{item_id}")
async def update_item(
*,
- item_id: int = Path(..., title="The ID of the item to get", ge=0, le=1000),
+ item_id: int = Path(title="The ID of the item to get", ge=0, le=1000),
q: str | None = None,
item: Item | None = None,
):
-from typing import Optional
+from typing import Union
from fastapi import Body, FastAPI
from pydantic import BaseModel
class Item(BaseModel):
name: str
- description: Optional[str] = None
+ description: Union[str, None] = None
price: float
- tax: Optional[float] = None
+ tax: Union[float, None] = None
class User(BaseModel):
username: str
- full_name: Optional[str] = None
+ full_name: Union[str, None] = None
@app.put("/items/{item_id}")
-async def update_item(
- item_id: int, item: Item, user: User, importance: int = Body(...)
-):
+async def update_item(item_id: int, item: Item, user: User, importance: int = Body()):
results = {"item_id": item_id, "item": item, "user": user, "importance": importance}
return results
@app.put("/items/{item_id}")
-async def update_item(
- item_id: int, item: Item, user: User, importance: int = Body(...)
-):
+async def update_item(item_id: int, item: Item, user: User, importance: int = Body()):
results = {"item_id": item_id, "item": item, "user": user, "importance": importance}
return results
-from typing import Optional
+from typing import Union
from fastapi import Body, FastAPI
from pydantic import BaseModel
class Item(BaseModel):
name: str
- description: Optional[str] = None
+ description: Union[str, None] = None
price: float
- tax: Optional[float] = None
+ tax: Union[float, None] = None
class User(BaseModel):
username: str
- full_name: Optional[str] = None
+ full_name: Union[str, None] = None
@app.put("/items/{item_id}")
item_id: int,
item: Item,
user: User,
- importance: int = Body(..., gt=0),
- q: Optional[str] = None
+ importance: int = Body(gt=0),
+ q: Union[str, None] = None
):
results = {"item_id": item_id, "item": item, "user": user, "importance": importance}
if q:
item_id: int,
item: Item,
user: User,
- importance: int = Body(..., gt=0),
+ importance: int = Body(gt=0),
q: str | None = None
):
results = {"item_id": item_id, "item": item, "user": user, "importance": importance}
-from typing import Optional
+from typing import Union
from fastapi import Body, FastAPI
from pydantic import BaseModel
class Item(BaseModel):
name: str
- description: Optional[str] = None
+ description: Union[str, None] = None
price: float
- tax: Optional[float] = None
+ tax: Union[float, None] = None
@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item = Body(..., embed=True)):
+async def update_item(item_id: int, item: Item = Body(embed=True)):
results = {"item_id": item_id, "item": item}
return results
@app.put("/items/{item_id}")
-async def update_item(item_id: int, item: Item = Body(..., embed=True)):
+async def update_item(item_id: int, item: Item = Body(embed=True)):
results = {"item_id": item_id, "item": item}
return results
-from typing import Optional
+from typing import Union
from fastapi import Cookie, FastAPI
@app.get("/items/")
-async def read_items(ads_id: Optional[str] = Cookie(None)):
+async def read_items(ads_id: Union[str, None] = Cookie(default=None)):
return {"ads_id": ads_id}
@app.get("/items/")
-async def read_items(ads_id: str | None = Cookie(None)):
+async def read_items(ads_id: str | None = Cookie(default=None)):
return {"ads_id": ads_id}
@app.post("/sum")
-async def sum_numbers(numbers: List[int] = Body(...)):
+async def sum_numbers(numbers: List[int] = Body()):
return {"sum": sum(numbers)}
@app.post("/")
-async def sum_numbers(numbers: List[int] = Body(...)):
+async def sum_numbers(numbers: List[int] = Body()):
return sum(numbers)
def query_or_cookie_extractor(
- q: str = Depends(query_extractor), last_query: Optional[str] = Cookie(None)
+ q: str = Depends(query_extractor), last_query: Optional[str] = Cookie(default=None)
):
if not q:
return last_query
def query_or_cookie_extractor(
- q: str = Depends(query_extractor), last_query: str | None = Cookie(None)
+ q: str = Depends(query_extractor), last_query: str | None = Cookie(default=None)
):
if not q:
return last_query
app = FastAPI()
-async def verify_token(x_token: str = Header(...)):
+async def verify_token(x_token: str = Header()):
if x_token != "fake-super-secret-token":
raise HTTPException(status_code=400, detail="X-Token header invalid")
-async def verify_key(x_key: str = Header(...)):
+async def verify_key(x_key: str = Header()):
if x_key != "fake-super-secret-key":
raise HTTPException(status_code=400, detail="X-Key header invalid")
return x_key
from fastapi import Depends, FastAPI, Header, HTTPException
-async def verify_token(x_token: str = Header(...)):
+async def verify_token(x_token: str = Header()):
if x_token != "fake-super-secret-token":
raise HTTPException(status_code=400, detail="X-Token header invalid")
-async def verify_key(x_key: str = Header(...)):
+async def verify_key(x_key: str = Header()):
if x_key != "fake-super-secret-key":
raise HTTPException(status_code=400, detail="X-Key header invalid")
return x_key
@app.put("/items/{item_id}")
async def read_items(
item_id: UUID,
- start_datetime: Optional[datetime] = Body(None),
- end_datetime: Optional[datetime] = Body(None),
- repeat_at: Optional[time] = Body(None),
- process_after: Optional[timedelta] = Body(None),
+ start_datetime: Optional[datetime] = Body(default=None),
+ end_datetime: Optional[datetime] = Body(default=None),
+ repeat_at: Optional[time] = Body(default=None),
+ process_after: Optional[timedelta] = Body(default=None),
):
start_process = start_datetime + process_after
duration = end_datetime - start_process
@app.put("/items/{item_id}")
async def read_items(
item_id: UUID,
- start_datetime: datetime | None = Body(None),
- end_datetime: datetime | None = Body(None),
- repeat_at: time | None = Body(None),
- process_after: timedelta | None = Body(None),
+ start_datetime: datetime | None = Body(default=None),
+ end_datetime: datetime | None = Body(default=None),
+ repeat_at: time | None = Body(default=None),
+ process_after: timedelta | None = Body(default=None),
):
start_process = start_datetime + process_after
duration = end_datetime - start_process
@app.get("/items/")
-async def read_items(user_agent: Optional[str] = Header(None)):
+async def read_items(user_agent: Optional[str] = Header(default=None)):
return {"User-Agent": user_agent}
@app.get("/items/")
-async def read_items(user_agent: str | None = Header(None)):
+async def read_items(user_agent: str | None = Header(default=None)):
return {"User-Agent": user_agent}
@app.get("/items/")
async def read_items(
- strange_header: Optional[str] = Header(None, convert_underscores=False)
+ strange_header: Optional[str] = Header(default=None, convert_underscores=False)
):
return {"strange_header": strange_header}
@app.get("/items/")
async def read_items(
- strange_header: str | None = Header(None, convert_underscores=False)
+ strange_header: str | None = Header(default=None, convert_underscores=False)
):
return {"strange_header": strange_header}
@app.get("/items/")
-async def read_items(x_token: Optional[List[str]] = Header(None)):
+async def read_items(x_token: Optional[List[str]] = Header(default=None)):
return {"X-Token values": x_token}
@app.get("/items/")
-async def read_items(x_token: list[str] | None = Header(None)):
+async def read_items(x_token: list[str] | None = Header(default=None)):
return {"X-Token values": x_token}
@app.get("/items/")
-async def read_items(x_token: Optional[list[str]] = Header(None)):
+async def read_items(x_token: Optional[list[str]] = Header(default=None)):
return {"X-Token values": x_token}
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Path, Query
@app.get("/items/{item_id}")
async def read_items(
- item_id: int = Path(..., title="The ID of the item to get"),
- q: Optional[str] = Query(None, alias="item-query"),
+ item_id: int = Path(title="The ID of the item to get"),
+ q: Union[str, None] = Query(default=None, alias="item-query"),
):
results = {"item_id": item_id}
if q:
@app.get("/items/{item_id}")
async def read_items(
- item_id: int = Path(..., title="The ID of the item to get"),
- q: str | None = Query(None, alias="item-query"),
+ item_id: int = Path(title="The ID of the item to get"),
+ q: str | None = Query(default=None, alias="item-query"),
):
results = {"item_id": item_id}
if q:
@app.get("/items/{item_id}")
-async def read_items(
- q: str, item_id: int = Path(..., title="The ID of the item to get")
-):
+async def read_items(q: str, item_id: int = Path(title="The ID of the item to get")):
results = {"item_id": item_id}
if q:
results.update({"q": q})
@app.get("/items/{item_id}")
-async def read_items(
- *, item_id: int = Path(..., title="The ID of the item to get"), q: str
-):
+async def read_items(*, item_id: int = Path(title="The ID of the item to get"), q: str):
results = {"item_id": item_id}
if q:
results.update({"q": q})
@app.get("/items/{item_id}")
async def read_items(
- *, item_id: int = Path(..., title="The ID of the item to get", ge=1), q: str
+ *, item_id: int = Path(title="The ID of the item to get", ge=1), q: str
):
results = {"item_id": item_id}
if q:
@app.get("/items/{item_id}")
async def read_items(
*,
- item_id: int = Path(..., title="The ID of the item to get", gt=0, le=1000),
+ item_id: int = Path(title="The ID of the item to get", gt=0, le=1000),
q: str,
):
results = {"item_id": item_id}
@app.get("/items/{item_id}")
async def read_items(
*,
- item_id: int = Path(..., title="The ID of the item to get", ge=0, le=1000),
+ item_id: int = Path(title="The ID of the item to get", ge=0, le=1000),
q: str,
- size: float = Query(..., gt=0, lt=10.5)
+ size: float = Query(gt=0, lt=10.5)
):
results = {"item_id": item_id}
if q:
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Query
@app.get("/items/")
-async def read_items(q: Optional[str] = Query(None, max_length=50)):
+async def read_items(q: Union[str, None] = Query(default=None, max_length=50)):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
@app.get("/items/")
-async def read_items(q: str | None = Query(None, max_length=50)):
+async def read_items(q: str | None = Query(default=None, max_length=50)):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Query
@app.get("/items/")
-async def read_items(q: Optional[str] = Query(None, min_length=3, max_length=50)):
+async def read_items(
+ q: Union[str, None] = Query(default=None, min_length=3, max_length=50)
+):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
@app.get("/items/")
-async def read_items(q: str | None = Query(None, min_length=3, max_length=50)):
+async def read_items(q: str | None = Query(default=None, min_length=3, max_length=50)):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Query
@app.get("/items/")
async def read_items(
- q: Optional[str] = Query(None, min_length=3, max_length=50, regex="^fixedquery$")
+ q: Union[str, None] = Query(
+ default=None, min_length=3, max_length=50, regex="^fixedquery$"
+ )
):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
@app.get("/items/")
async def read_items(
- q: str | None = Query(None, min_length=3, max_length=50, regex="^fixedquery$")
+ q: str
+ | None = Query(default=None, min_length=3, max_length=50, regex="^fixedquery$")
):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
@app.get("/items/")
-async def read_items(q: str = Query("fixedquery", min_length=3)):
+async def read_items(q: str = Query(default="fixedquery", min_length=3)):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
@app.get("/items/")
-async def read_items(q: str = Query(..., min_length=3)):
+async def read_items(q: str = Query(min_length=3)):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
--- /dev/null
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(q: str = Query(default=..., min_length=3)):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from typing import Union
+
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(q: Union[str, None] = Query(default=..., min_length=3)):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(q: str | None = Query(default=..., min_length=3)):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query
+from pydantic import Required
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(q: str = Query(default=Required, min_length=3)):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Query
@app.get("/items/")
async def read_items(
- q: Optional[str] = Query(None, title="Query string", min_length=3)
+ q: Union[str, None] = Query(default=None, title="Query string", min_length=3)
):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
@app.get("/items/")
-async def read_items(q: str | None = Query(None, title="Query string", min_length=3)):
+async def read_items(
+ q: str | None = Query(default=None, title="Query string", min_length=3)
+):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Query
@app.get("/items/")
async def read_items(
- q: Optional[str] = Query(
- None,
+ q: Union[str, None] = Query(
+ default=None,
title="Query string",
description="Query string for the items to search in the database that have a good match",
min_length=3,
async def read_items(
q: str
| None = Query(
- None,
+ default=None,
title="Query string",
description="Query string for the items to search in the database that have a good match",
min_length=3,
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Query
@app.get("/items/")
-async def read_items(q: Optional[str] = Query(None, alias="item-query")):
+async def read_items(q: Union[str, None] = Query(default=None, alias="item-query")):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
@app.get("/items/")
-async def read_items(q: str | None = Query(None, alias="item-query")):
+async def read_items(q: str | None = Query(default=None, alias="item-query")):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Query
@app.get("/items/")
async def read_items(
- q: Optional[str] = Query(
- None,
+ q: Union[str, None] = Query(
+ default=None,
alias="item-query",
title="Query string",
description="Query string for the items to search in the database that have a good match",
async def read_items(
q: str
| None = Query(
- None,
+ default=None,
alias="item-query",
title="Query string",
description="Query string for the items to search in the database that have a good match",
-from typing import List, Optional
+from typing import List, Union
from fastapi import FastAPI, Query
@app.get("/items/")
-async def read_items(q: Optional[List[str]] = Query(None)):
+async def read_items(q: Union[List[str], None] = Query(default=None)):
query_items = {"q": q}
return query_items
@app.get("/items/")
-async def read_items(q: list[str] | None = Query(None)):
+async def read_items(q: list[str] | None = Query(default=None)):
query_items = {"q": q}
return query_items
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Query
@app.get("/items/")
-async def read_items(q: Optional[list[str]] = Query(None)):
+async def read_items(q: Union[list[str], None] = Query(default=None)):
query_items = {"q": q}
return query_items
@app.get("/items/")
-async def read_items(q: List[str] = Query(["foo", "bar"])):
+async def read_items(q: List[str] = Query(default=["foo", "bar"])):
query_items = {"q": q}
return query_items
@app.get("/items/")
-async def read_items(q: list[str] = Query(["foo", "bar"])):
+async def read_items(q: list[str] = Query(default=["foo", "bar"])):
query_items = {"q": q}
return query_items
@app.get("/items/")
-async def read_items(q: list = Query([])):
+async def read_items(q: list = Query(default=[])):
query_items = {"q": q}
return query_items
-from typing import Optional
+from typing import Union
from fastapi import FastAPI, Query
@app.get("/items/")
async def read_items(
- hidden_query: Optional[str] = Query(None, include_in_schema=False)
+ hidden_query: Union[str, None] = Query(default=None, include_in_schema=False)
):
if hidden_query:
return {"hidden_query": hidden_query}
@app.get("/items/")
-async def read_items(hidden_query: str | None = Query(None, include_in_schema=False)):
+async def read_items(
+ hidden_query: str | None = Query(default=None, include_in_schema=False)
+):
if hidden_query:
return {"hidden_query": hidden_query}
else:
@app.post("/files/")
-async def create_file(file: bytes = File(...)):
+async def create_file(file: bytes = File()):
return {"file_size": len(file)}
@app.post("/files/")
-async def create_file(file: Optional[bytes] = File(None)):
+async def create_file(file: Optional[bytes] = File(default=None)):
if not file:
return {"message": "No file sent"}
else:
@app.post("/files/")
-async def create_file(file: bytes | None = File(None)):
+async def create_file(file: bytes | None = File(default=None)):
if not file:
return {"message": "No file sent"}
else:
@app.post("/files/")
-async def create_file(file: bytes = File(..., description="A file read as bytes")):
+async def create_file(file: bytes = File(description="A file read as bytes")):
return {"file_size": len(file)}
@app.post("/uploadfile/")
async def create_upload_file(
- file: UploadFile = File(..., description="A file read as UploadFile")
+ file: UploadFile = File(description="A file read as UploadFile"),
):
return {"filename": file.filename}
@app.post("/files/")
-async def create_files(files: List[bytes] = File(...)):
+async def create_files(files: List[bytes] = File()):
return {"file_sizes": [len(file) for file in files]}
@app.post("/files/")
-async def create_files(files: list[bytes] = File(...)):
+async def create_files(files: list[bytes] = File()):
return {"file_sizes": [len(file) for file in files]}
@app.post("/files/")
async def create_files(
- files: List[bytes] = File(..., description="Multiple files as bytes")
+ files: List[bytes] = File(description="Multiple files as bytes"),
):
return {"file_sizes": [len(file) for file in files]}
@app.post("/uploadfiles/")
async def create_upload_files(
- files: List[UploadFile] = File(..., description="Multiple files as UploadFile")
+ files: List[UploadFile] = File(description="Multiple files as UploadFile"),
):
return {"filenames": [file.filename for file in files]}
@app.post("/files/")
async def create_files(
- files: list[bytes] = File(..., description="Multiple files as bytes")
+ files: list[bytes] = File(description="Multiple files as bytes"),
):
return {"file_sizes": [len(file) for file in files]}
@app.post("/uploadfiles/")
async def create_upload_files(
- files: list[UploadFile] = File(..., description="Multiple files as UploadFile")
+ files: list[UploadFile] = File(description="Multiple files as UploadFile"),
):
return {"filenames": [file.filename for file in files]}
@app.post("/login/")
-async def login(username: str = Form(...), password: str = Form(...)):
+async def login(username: str = Form(), password: str = Form()):
return {"username": username}
@app.post("/files/")
async def create_file(
- file: bytes = File(...), fileb: UploadFile = File(...), token: str = Form(...)
+ file: bytes = File(), fileb: UploadFile = File(), token: str = Form()
):
return {
"file_size": len(file),
class Item(BaseModel):
- name: str = Field(..., example="Foo")
- description: Optional[str] = Field(None, example="A very nice Item")
- price: float = Field(..., example=35.4)
- tax: Optional[float] = Field(None, example=3.2)
+ name: str = Field(example="Foo")
+ description: Optional[str] = Field(default=None, example="A very nice Item")
+ price: float = Field(example=35.4)
+ tax: Optional[float] = Field(default=None, example=3.2)
@app.put("/items/{item_id}")
class Item(BaseModel):
- name: str = Field(..., example="Foo")
- description: str | None = Field(None, example="A very nice Item")
- price: float = Field(..., example=35.4)
- tax: float | None = Field(None, example=3.2)
+ name: str = Field(example="Foo")
+ description: str | None = Field(default=None, example="A very nice Item")
+ price: float = Field(example=35.4)
+ tax: float | None = Field(default=None, example=3.2)
@app.put("/items/{item_id}")
async def update_item(
item_id: int,
item: Item = Body(
- ...,
example={
"name": "Foo",
"description": "A very nice Item",
async def update_item(
item_id: int,
item: Item = Body(
- ...,
example={
"name": "Foo",
"description": "A very nice Item",
*,
item_id: int,
item: Item = Body(
- ...,
examples={
"normal": {
"summary": "A normal example",
*,
item_id: int,
item: Item = Body(
- ...,
examples={
"normal": {
"summary": "A normal example",
async def get_cookie_or_token(
websocket: WebSocket,
- session: Optional[str] = Cookie(None),
- token: Optional[str] = Query(None),
+ session: Optional[str] = Cookie(default=None),
+ token: Optional[str] = Query(default=None),
):
if session is None and token is None:
await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
FieldInfo,
ModelField,
Required,
+ Undefined,
)
from pydantic.schema import get_annotation_from_field_info
from pydantic.typing import ForwardRef, evaluate_forwardref
field_info = param_field.field_info
assert isinstance(
field_info, params.Body
- ), f"Param: {param_field.name} can only be a request body, using Body(...)"
+ ), f"Param: {param_field.name} can only be a request body, using Body()"
dependant.body_params.append(param_field)
return dependant
force_type: Optional[params.ParamTypes] = None,
ignore_default: bool = False,
) -> ModelField:
- default_value = Required
+ default_value: Any = Undefined
had_schema = False
if not param.default == param.empty and ignore_default is False:
default_value = param.default
if force_type:
field_info.in_ = force_type # type: ignore
else:
- field_info = default_field_info(default_value)
- required = default_value == Required
+ field_info = default_field_info(default=default_value)
+ required = True
+ if default_value is Required or ignore_default:
+ required = True
+ default_value = None
+ elif default_value is not Undefined:
+ required = False
annotation: Any = Any
if not param.annotation == param.empty:
annotation = param.annotation
field = create_response_field(
name=param.name,
type_=annotation,
- default=None if required else default_value,
+ default=default_value,
alias=alias,
required=required,
field_info=field_info,
)
- field.required = required
if not had_schema and not is_scalar_field(field=field):
field.field_info = params.Body(field_info.default)
if not had_schema and lenient_issubclass(field.type_, UploadFile):
class Reference(BaseModel):
- ref: str = Field(..., alias="$ref")
+ ref: str = Field(alias="$ref")
class Discriminator(BaseModel):
class Schema(BaseModel):
- ref: Optional[str] = Field(None, alias="$ref")
+ ref: Optional[str] = Field(default=None, alias="$ref")
title: Optional[str] = None
multipleOf: Optional[float] = None
maximum: Optional[float] = None
exclusiveMaximum: Optional[float] = None
minimum: Optional[float] = None
exclusiveMinimum: Optional[float] = None
- maxLength: Optional[int] = Field(None, gte=0)
- minLength: Optional[int] = Field(None, gte=0)
+ maxLength: Optional[int] = Field(default=None, gte=0)
+ minLength: Optional[int] = Field(default=None, gte=0)
pattern: Optional[str] = None
- maxItems: Optional[int] = Field(None, gte=0)
- minItems: Optional[int] = Field(None, gte=0)
+ maxItems: Optional[int] = Field(default=None, gte=0)
+ minItems: Optional[int] = Field(default=None, gte=0)
uniqueItems: Optional[bool] = None
- maxProperties: Optional[int] = Field(None, gte=0)
- minProperties: Optional[int] = Field(None, gte=0)
+ maxProperties: Optional[int] = Field(default=None, gte=0)
+ minProperties: Optional[int] = Field(default=None, gte=0)
required: Optional[List[str]] = None
enum: Optional[List[Any]] = None
type: Optional[str] = None
allOf: Optional[List["Schema"]] = None
oneOf: Optional[List["Schema"]] = None
anyOf: Optional[List["Schema"]] = None
- not_: Optional["Schema"] = Field(None, alias="not")
+ not_: Optional["Schema"] = Field(default=None, alias="not")
items: Optional[Union["Schema", List["Schema"]]] = None
properties: Optional[Dict[str, "Schema"]] = None
additionalProperties: Optional[Union["Schema", Reference, bool]] = None
class MediaType(BaseModel):
- schema_: Optional[Union[Schema, Reference]] = Field(None, alias="schema")
+ schema_: Optional[Union[Schema, Reference]] = Field(default=None, alias="schema")
example: Optional[Any] = None
examples: Optional[Dict[str, Union[Example, Reference]]] = None
encoding: Optional[Dict[str, Encoding]] = None
style: Optional[str] = None
explode: Optional[bool] = None
allowReserved: Optional[bool] = None
- schema_: Optional[Union[Schema, Reference]] = Field(None, alias="schema")
+ schema_: Optional[Union[Schema, Reference]] = Field(default=None, alias="schema")
example: Optional[Any] = None
examples: Optional[Dict[str, Union[Example, Reference]]] = None
# Serialization rules for more complex scenarios
class Parameter(ParameterBase):
name: str
- in_: ParameterInType = Field(..., alias="in")
+ in_: ParameterInType = Field(alias="in")
class Header(ParameterBase):
class PathItem(BaseModel):
- ref: Optional[str] = Field(None, alias="$ref")
+ ref: Optional[str] = Field(default=None, alias="$ref")
summary: Optional[str] = None
description: Optional[str] = None
get: Optional[Operation] = None
class SecurityBase(BaseModel):
- type_: SecuritySchemeType = Field(..., alias="type")
+ type_: SecuritySchemeType = Field(alias="type")
description: Optional[str] = None
class Config:
class APIKey(SecurityBase):
type_ = Field(SecuritySchemeType.apiKey, alias="type")
- in_: APIKeyIn = Field(..., alias="in")
+ in_: APIKeyIn = Field(alias="in")
name: str
def Path( # noqa: N802
- default: Any,
+ default: Any = Undefined,
*,
alias: Optional[str] = None,
title: Optional[str] = None,
def Query( # noqa: N802
- default: Any,
+ default: Any = Undefined,
*,
alias: Optional[str] = None,
title: Optional[str] = None,
**extra: Any,
) -> Any:
return params.Query(
- default,
+ default=default,
alias=alias,
title=title,
description=description,
def Header( # noqa: N802
- default: Any,
+ default: Any = Undefined,
*,
alias: Optional[str] = None,
convert_underscores: bool = True,
**extra: Any,
) -> Any:
return params.Header(
- default,
+ default=default,
alias=alias,
convert_underscores=convert_underscores,
title=title,
def Cookie( # noqa: N802
- default: Any,
+ default: Any = Undefined,
*,
alias: Optional[str] = None,
title: Optional[str] = None,
**extra: Any,
) -> Any:
return params.Cookie(
- default,
+ default=default,
alias=alias,
title=title,
description=description,
def Body( # noqa: N802
- default: Any,
+ default: Any = Undefined,
*,
embed: bool = False,
media_type: str = "application/json",
**extra: Any,
) -> Any:
return params.Body(
- default,
+ default=default,
embed=embed,
media_type=media_type,
alias=alias,
def Form( # noqa: N802
- default: Any,
+ default: Any = Undefined,
*,
media_type: str = "application/x-www-form-urlencoded",
alias: Optional[str] = None,
**extra: Any,
) -> Any:
return params.Form(
- default,
+ default=default,
media_type=media_type,
alias=alias,
title=title,
def File( # noqa: N802
- default: Any,
+ default: Any = Undefined,
*,
media_type: str = "multipart/form-data",
alias: Optional[str] = None,
**extra: Any,
) -> Any:
return params.File(
- default,
+ default=default,
media_type=media_type,
alias=alias,
title=title,
def __init__(
self,
- default: Any,
+ default: Any = Undefined,
*,
alias: Optional[str] = None,
title: Optional[str] = None,
self.examples = examples
self.include_in_schema = include_in_schema
super().__init__(
- default,
+ default=default,
alias=alias,
title=title,
description=description,
def __init__(
self,
- default: Any,
+ default: Any = Undefined,
*,
alias: Optional[str] = None,
title: Optional[str] = None,
):
self.in_ = self.in_
super().__init__(
- ...,
+ default=...,
alias=alias,
title=title,
description=description,
def __init__(
self,
- default: Any,
+ default: Any = Undefined,
*,
alias: Optional[str] = None,
title: Optional[str] = None,
**extra: Any,
):
super().__init__(
- default,
+ default=default,
alias=alias,
title=title,
description=description,
def __init__(
self,
- default: Any,
+ default: Any = Undefined,
*,
alias: Optional[str] = None,
convert_underscores: bool = True,
):
self.convert_underscores = convert_underscores
super().__init__(
- default,
+ default=default,
alias=alias,
title=title,
description=description,
def __init__(
self,
- default: Any,
+ default: Any = Undefined,
*,
alias: Optional[str] = None,
title: Optional[str] = None,
**extra: Any,
):
super().__init__(
- default,
+ default=default,
alias=alias,
title=title,
description=description,
class Body(FieldInfo):
def __init__(
self,
- default: Any,
+ default: Any = Undefined,
*,
embed: bool = False,
media_type: str = "application/json",
self.example = example
self.examples = examples
super().__init__(
- default,
+ default=default,
alias=alias,
title=title,
description=description,
**extra: Any,
):
super().__init__(
- default,
+ default=default,
embed=True,
media_type=media_type,
alias=alias,
**extra: Any,
):
super().__init__(
- default,
+ default=default,
media_type=media_type,
alias=alias,
title=title,
def __init__(
self,
- grant_type: str = Form(None, regex="password"),
- username: str = Form(...),
- password: str = Form(...),
- scope: str = Form(""),
- client_id: Optional[str] = Form(None),
- client_secret: Optional[str] = Form(None),
+ grant_type: str = Form(default=None, regex="password"),
+ username: str = Form(),
+ password: str = Form(),
+ scope: str = Form(default=""),
+ client_id: Optional[str] = Form(default=None),
+ client_secret: Optional[str] = Form(default=None),
):
self.grant_type = grant_type
self.username = username
def __init__(
self,
- grant_type: str = Form(..., regex="password"),
- username: str = Form(...),
- password: str = Form(...),
- scope: str = Form(""),
- client_id: Optional[str] = Form(None),
- client_secret: Optional[str] = Form(None),
+ grant_type: str = Form(regex="password"),
+ username: str = Form(),
+ password: str = Form(),
+ scope: str = Form(default=""),
+ client_id: Optional[str] = Form(default=None),
+ client_secret: Optional[str] = Form(default=None),
):
super().__init__(
grant_type=grant_type,
Create a new response field. Raises if type_ is invalid.
"""
class_validators = class_validators or {}
- field_info = field_info or FieldInfo(None)
+ field_info = field_info or FieldInfo()
response_field = functools.partial(
ModelField,
@app.get("/path/param/{item_id}")
-def get_path_param_id(item_id: Optional[str] = Path(None)):
+def get_path_param_id(item_id: str = Path()):
return item_id
@app.get("/path/param-required/{item_id}")
-def get_path_param_required_id(item_id: str = Path(...)):
+def get_path_param_required_id(item_id: str = Path()):
return item_id
@app.get("/path/param-minlength/{item_id}")
-def get_path_param_min_length(item_id: str = Path(..., min_length=3)):
+def get_path_param_min_length(item_id: str = Path(min_length=3)):
return item_id
@app.get("/path/param-maxlength/{item_id}")
-def get_path_param_max_length(item_id: str = Path(..., max_length=3)):
+def get_path_param_max_length(item_id: str = Path(max_length=3)):
return item_id
@app.get("/path/param-min_maxlength/{item_id}")
-def get_path_param_min_max_length(item_id: str = Path(..., max_length=3, min_length=2)):
+def get_path_param_min_max_length(item_id: str = Path(max_length=3, min_length=2)):
return item_id
@app.get("/path/param-gt/{item_id}")
-def get_path_param_gt(item_id: float = Path(..., gt=3)):
+def get_path_param_gt(item_id: float = Path(gt=3)):
return item_id
@app.get("/path/param-gt0/{item_id}")
-def get_path_param_gt0(item_id: float = Path(..., gt=0)):
+def get_path_param_gt0(item_id: float = Path(gt=0)):
return item_id
@app.get("/path/param-ge/{item_id}")
-def get_path_param_ge(item_id: float = Path(..., ge=3)):
+def get_path_param_ge(item_id: float = Path(ge=3)):
return item_id
@app.get("/path/param-lt/{item_id}")
-def get_path_param_lt(item_id: float = Path(..., lt=3)):
+def get_path_param_lt(item_id: float = Path(lt=3)):
return item_id
@app.get("/path/param-lt0/{item_id}")
-def get_path_param_lt0(item_id: float = Path(..., lt=0)):
+def get_path_param_lt0(item_id: float = Path(lt=0)):
return item_id
@app.get("/path/param-le/{item_id}")
-def get_path_param_le(item_id: float = Path(..., le=3)):
+def get_path_param_le(item_id: float = Path(le=3)):
return item_id
@app.get("/path/param-lt-gt/{item_id}")
-def get_path_param_lt_gt(item_id: float = Path(..., lt=3, gt=1)):
+def get_path_param_lt_gt(item_id: float = Path(lt=3, gt=1)):
return item_id
@app.get("/path/param-le-ge/{item_id}")
-def get_path_param_le_ge(item_id: float = Path(..., le=3, ge=1)):
+def get_path_param_le_ge(item_id: float = Path(le=3, ge=1)):
return item_id
@app.get("/path/param-lt-int/{item_id}")
-def get_path_param_lt_int(item_id: int = Path(..., lt=3)):
+def get_path_param_lt_int(item_id: int = Path(lt=3)):
return item_id
@app.get("/path/param-gt-int/{item_id}")
-def get_path_param_gt_int(item_id: int = Path(..., gt=3)):
+def get_path_param_gt_int(item_id: int = Path(gt=3)):
return item_id
@app.get("/path/param-le-int/{item_id}")
-def get_path_param_le_int(item_id: int = Path(..., le=3)):
+def get_path_param_le_int(item_id: int = Path(le=3)):
return item_id
@app.get("/path/param-ge-int/{item_id}")
-def get_path_param_ge_int(item_id: int = Path(..., ge=3)):
+def get_path_param_ge_int(item_id: int = Path(ge=3)):
return item_id
@app.get("/path/param-lt-gt-int/{item_id}")
-def get_path_param_lt_gt_int(item_id: int = Path(..., lt=3, gt=1)):
+def get_path_param_lt_gt_int(item_id: int = Path(lt=3, gt=1)):
return item_id
@app.get("/path/param-le-ge-int/{item_id}")
-def get_path_param_le_ge_int(item_id: int = Path(..., le=3, ge=1)):
+def get_path_param_le_ge_int(item_id: int = Path(le=3, ge=1)):
return item_id
@app.get("/query/param")
-def get_query_param(query=Query(None)):
+def get_query_param(query=Query(default=None)):
if query is None:
return "foo bar"
return f"foo bar {query}"
@app.get("/query/param-required")
-def get_query_param_required(query=Query(...)):
+def get_query_param_required(query=Query()):
return f"foo bar {query}"
@app.get("/query/param-required/int")
-def get_query_param_required_type(query: int = Query(...)):
+def get_query_param_required_type(query: int = Query()):
return f"foo bar {query}"
@app.put("/invalid-user/{user_id}")
def put_invalid_user(
- user_id: str, name: str = Body(...), db: dict = Depends(get_database)
+ user_id: str, name: str = Body(), db: dict = Depends(get_database)
):
db[user_id] = name
raise HTTPException(status_code=400, detail="Invalid user")
@app.put("/user/{user_id}")
-def put_user(user_id: str, name: str = Body(...), db: dict = Depends(get_database)):
+def put_user(user_id: str, name: str = Body(), db: dict = Depends(get_database)):
db[user_id] = name
return {"message": "OK"}
@app.post("/form/python-list")
-def post_form_param_list(items: list = Form(...)):
+def post_form_param_list(items: list = Form()):
return items
@app.post("/form/python-set")
-def post_form_param_set(items: set = Form(...)):
+def post_form_param_set(items: set = Form()):
return items
@app.post("/form/python-tuple")
-def post_form_param_tuple(items: tuple = Form(...)):
+def post_form_param_tuple(items: tuple = Form()):
return items
title: str
@app.get("/items/")
- def read_items(q: List[Item] = Query(None)):
+ def read_items(q: List[Item] = Query(default=None)):
pass # pragma: no cover
title: str
@app.get("/items/")
- def read_items(q: Tuple[Item, Item] = Query(None)):
+ def read_items(q: Tuple[Item, Item] = Query(default=None)):
pass # pragma: no cover
title: str
@app.get("/items/")
- def read_items(q: Dict[str, Item] = Query(None)):
+ def read_items(q: Dict[str, Item] = Query(default=None)):
pass # pragma: no cover
title: str
@app.get("/items/")
- def read_items(q: Optional[dict] = Query(None)):
+ def read_items(q: Optional[dict] = Query(default=None)):
pass # pragma: no cover
class ModelWithAlias(BaseModel):
- foo: str = Field(..., alias="Foo")
+ foo: str = Field(alias="Foo")
class ModelWithDefault(BaseModel):
@router.post("/compute")
-def compute(a: int = Body(...), b: str = Body(...)):
+def compute(a: int = Body(), b: str = Body()):
return {"a": a, "b": b}
@router.post("/compute/")
-def compute(a: int = Body(...), b: str = Body(...)):
+def compute(a: int = Body(), b: str = Body()):
return {"a": a, "b": b}
@app.get("/items/")
-def read_items(q: List[int] = Query(None)):
+def read_items(q: List[int] = Query(default=None)):
return {"q": q}
app = FastAPI()
@app.post("/")
- async def root(username: str = Form(...)):
+ async def root(username: str = Form()):
return username # pragma: nocover
app = FastAPI()
@app.post("/")
- async def root(f: UploadFile = File(...)):
+ async def root(f: UploadFile = File()):
return f # pragma: nocover
app = FastAPI()
@app.post("/")
- async def root(f: bytes = File(...)):
+ async def root(f: bytes = File()):
return f # pragma: nocover
app = FastAPI()
@app.post("/")
- async def root(username: str = Form(...), password: str = Form(...)):
+ async def root(username: str = Form(), password: str = Form()):
return username # pragma: nocover
app = FastAPI()
@app.post("/")
- async def root(username: str = Form(...), f: UploadFile = File(...)):
+ async def root(username: str = Form(), f: UploadFile = File()):
return username # pragma: nocover
app = FastAPI()
@app.post("/")
- async def root(username: str = Form(...)):
+ async def root(username: str = Form()):
return username # pragma: nocover
app = FastAPI()
@app.post("/")
- async def root(f: UploadFile = File(...)):
+ async def root(f: UploadFile = File()):
return f # pragma: nocover
app = FastAPI()
@app.post("/")
- async def root(f: bytes = File(...)):
+ async def root(f: bytes = File()):
return f # pragma: nocover
app = FastAPI()
@app.post("/")
- async def root(username: str = Form(...), password: str = Form(...)):
+ async def root(username: str = Form(), password: str = Form()):
return username # pragma: nocover
app = FastAPI()
@app.post("/")
- async def root(username: str = Form(...), f: UploadFile = File(...)):
+ async def root(username: str = Form(), f: UploadFile = File()):
return username # pragma: nocover
@app.get("/items/")
-def read_items(q: Optional[str] = Param(None)): # type: ignore
+def read_items(q: Optional[str] = Param(default=None)): # type: ignore
return {"q": q}
@app.get("/hidden_cookie")
async def hidden_cookie(
- hidden_cookie: Optional[str] = Cookie(None, include_in_schema=False)
+ hidden_cookie: Optional[str] = Cookie(default=None, include_in_schema=False)
):
return {"hidden_cookie": hidden_cookie}
@app.get("/hidden_header")
async def hidden_header(
- hidden_header: Optional[str] = Header(None, include_in_schema=False)
+ hidden_header: Optional[str] = Header(default=None, include_in_schema=False)
):
return {"hidden_header": hidden_header}
@app.get("/hidden_path/{hidden_path}")
-async def hidden_path(hidden_path: str = Path(..., include_in_schema=False)):
+async def hidden_path(hidden_path: str = Path(include_in_schema=False)):
return {"hidden_path": hidden_path}
@app.get("/hidden_query")
async def hidden_query(
- hidden_query: Optional[str] = Query(None, include_in_schema=False)
+ hidden_query: Optional[str] = Query(default=None, include_in_schema=False)
):
return {"hidden_query": hidden_query}
app = FastAPI()
-def get_header(*, someheader: str = Header(...)):
+def get_header(*, someheader: str = Header()):
return someheader
@app.post("/products")
-async def create_product(data: Product = Body(..., media_type=media_type, embed=True)):
+async def create_product(data: Product = Body(media_type=media_type, embed=True)):
pass # pragma: no cover
@app.post("/shops")
async def create_shop(
- data: Shop = Body(..., media_type=media_type),
- included: typing.List[Product] = Body([], media_type=media_type),
+ data: Shop = Body(media_type=media_type),
+ included: typing.List[Product] = Body(default=[], media_type=media_type),
):
pass # pragma: no cover
+from typing import Union
+
from fastapi import Body, Cookie, FastAPI, Header, Path, Query
from fastapi.testclient import TestClient
from pydantic import BaseModel
@app.post("/example/")
-def example(item: Item = Body(..., example={"data": "Data in Body example"})):
+def example(item: Item = Body(example={"data": "Data in Body example"})):
return item
@app.post("/examples/")
def examples(
item: Item = Body(
- ...,
examples={
"example1": {
"summary": "example1 summary",
@app.post("/example_examples/")
def example_examples(
item: Item = Body(
- ...,
example={"data": "Overriden example"},
examples={
"example1": {"value": {"data": "examples example_examples 1"}},
# TODO: enable these tests once/if Form(embed=False) is supported
# TODO: In that case, define if File() should support example/examples too
# @app.post("/form_example")
-# def form_example(firstname: str = Form(..., example="John")):
+# def form_example(firstname: str = Form(example="John")):
# return firstname
@app.get("/path_example/{item_id}")
def path_example(
item_id: str = Path(
- ...,
example="item_1",
),
):
@app.get("/path_examples/{item_id}")
def path_examples(
item_id: str = Path(
- ...,
examples={
"example1": {"summary": "item ID summary", "value": "item_1"},
"example2": {"value": "item_2"},
@app.get("/path_example_examples/{item_id}")
def path_example_examples(
item_id: str = Path(
- ...,
example="item_overriden",
examples={
"example1": {"summary": "item ID summary", "value": "item_1"},
@app.get("/query_example/")
def query_example(
- data: str = Query(
- None,
+ data: Union[str, None] = Query(
+ default=None,
example="query1",
),
):
@app.get("/query_examples/")
def query_examples(
- data: str = Query(
- None,
+ data: Union[str, None] = Query(
+ default=None,
examples={
"example1": {"summary": "Query example 1", "value": "query1"},
"example2": {"value": "query2"},
@app.get("/query_example_examples/")
def query_example_examples(
- data: str = Query(
- None,
+ data: Union[str, None] = Query(
+ default=None,
example="query_overriden",
examples={
"example1": {"summary": "Qeury example 1", "value": "query1"},
@app.get("/header_example/")
def header_example(
- data: str = Header(
- None,
+ data: Union[str, None] = Header(
+ default=None,
example="header1",
),
):
@app.get("/header_examples/")
def header_examples(
- data: str = Header(
- None,
+ data: Union[str, None] = Header(
+ default=None,
examples={
"example1": {"summary": "header example 1", "value": "header1"},
"example2": {"value": "header2"},
@app.get("/header_example_examples/")
def header_example_examples(
- data: str = Header(
- None,
+ data: Union[str, None] = Header(
+ default=None,
example="header_overriden",
examples={
"example1": {"summary": "Qeury example 1", "value": "header1"},
@app.get("/cookie_example/")
def cookie_example(
- data: str = Cookie(
- None,
+ data: Union[str, None] = Cookie(
+ default=None,
example="cookie1",
),
):
@app.get("/cookie_examples/")
def cookie_examples(
- data: str = Cookie(
- None,
+ data: Union[str, None] = Cookie(
+ default=None,
examples={
"example1": {"summary": "cookie example 1", "value": "cookie1"},
"example2": {"value": "cookie2"},
@app.get("/cookie_example_examples/")
def cookie_example_examples(
- data: str = Cookie(
- None,
+ data: Union[str, None] = Cookie(
+ default=None,
example="cookie_overriden",
examples={
"example1": {"summary": "Qeury example 1", "value": "cookie1"},
class Item(BaseModel):
- name: str = Field(..., alias="aliased_name")
+ name: str = Field(alias="aliased_name")
price: Optional[float] = None
owner_ids: Optional[List[int]] = None
@app.get("/int/{param:int}")
-def int_convertor(param: int = Path(...)):
+def int_convertor(param: int = Path()):
return {"int": param}
@app.get("/float/{param:float}")
-def float_convertor(param: float = Path(...)):
+def float_convertor(param: float = Path()):
return {"float": param}
@app.get("/path/{param:path}")
-def path_convertor(param: str = Path(...)):
+def path_convertor(param: str = Path()):
return {"path": param}
@app.post("/tuple-form/")
-def hello(values: Tuple[int, int] = Form(...)):
+def hello(values: Tuple[int, int] = Form()):
return values
projects / thirdparty / fastapi / fastapi.git / commitdiff
