from pydantic import BaseModel

app = FastAPI()

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")


class User(BaseModel):
    username: str
    email: Union[str, None] = None
    full_name: Union[str, None] = None
    disabled: Union[bool, None] = None


def fake_decode_token(token):
    return User(
        username=token + "fakedecoded", email="******@****.***", full_name="John Doe"
    )

def test_raises_pydantic_v1_model_in_endpoint_param() -> None:
    class ParamModelV1(BaseModel):
        name: str

    app = FastAPI()

    with pytest.raises(PydanticV1NotSupportedError):

        @app.post("/param")
        def endpoint(data: ParamModelV1):  # pragma: no cover
            return data


def test_raises_pydantic_v1_model_in_return_type() -> None:
    class ReturnModelV1(BaseModel):
        name: str

    name: str
    price: Optional[float] = None
    owner_ids: Optional[list[int]] = None


@app.get("/items/invalid", response_model=Item)
def get_invalid():
    return {"name": "invalid", "price": "foo"}


@app.get("/items/invalidnone", response_model=Item)
def get_invalid_none():
    return None


@app.get("/items/validnone", response_model=Union[Item, None])
def get_valid_none(send_none: bool = False):

						<div class="d-sm-none"></div>
						<span class="d-none d-sm-inline-block">&nbsp;</span>
						<la:message key="labels.search_result_size"
							arg0="${fe:formatFileSize(doc.content_length)}" />
					</c:if>
					<c:if test="${searchLogSupport && doc.click_count!=null && doc.click_count>0}">
						<div class="d-sm-none"></div>
						<span class="d-none d-sm-inline-block">&nbsp;</span>

def get_dependant(
    *,
    path: str,
    call: Callable[..., Any],
    name: Optional[str] = None,
    own_oauth_scopes: Optional[list[str]] = None,
    parent_oauth_scopes: Optional[list[str]] = None,
    use_cache: bool = True,
    scope: Union[Literal["function", "request"], None] = None,
) -> Dependant:
    dependant = Dependant(
        call=call,
        name=name,
        path=path,

    def foo(req: Model) -> dict[str, Union[str, None]]:
        return {
            "value": req.value or None,
            "embedded_value": req.embedded_model.value or None,
        }

    client = TestClient(app)

    response = client.post("/", json={})
    assert response.status_code == 200, response.text
    assert response.json() == {
        "value": None,
        "embedded_value": None,
    }

    response2 = client.post(

from inline_snapshot import snapshot


@dataclass
class Item:
    id: uuid.UUID
    name: str
    price: float
    tags: list[str] = field(default_factory=list)
    description: Union[str, None] = None
    tax: Union[float, None] = None


app = FastAPI()


@app.get("/item", response_model=Item)
async def read_item():
    return {
        "id": uuid.uuid4(),
        "name": "Island In The Moon",

async def read_optional_list_bytes(p: Annotated[Optional[list[bytes]], File()] = None):
    return {"file_size": [len(file) for file in p] if p else None}


@app.post("/optional-list-uploadfile")
async def read_optional_list_uploadfile(
    p: Annotated[Optional[list[UploadFile]], File()] = None,
):
    return {"file_size": [file.size for file in p] if p else None}


@pytest.mark.parametrize(
    "path",
    [

from fastapi.params import Body, Cookie, Header, Param, Path, Query

test_data: list[Any] = ["teststr", None, ..., 1, []]


def get_user():
    return {}  # pragma: no cover


def test_param_repr_str():
    assert repr(Param("teststr")) == "Param(teststr)"


def test_param_repr_none():
    assert repr(Param(None)) == "Param(None)"


def test_param_repr_ellipsis():
    assert repr(Param(...)) == "Param(PydanticUndefined)"

from fastapi import FastAPI
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: str | None = None
    price: float
    tax: float | None = None


app = FastAPI()


@app.post("/items/")
async def create_item(item: Item):