# Without aliases


@app.get("/required-list-str")
async def read_required_list_str(p: Annotated[list[str], Query()]):
    return {"p": p}


class QueryModelRequiredListStr(BaseModel):
    p: list[str]


@app.get("/model-required-list-str")
def read_model_required_list_str(p: Annotated[QueryModelRequiredListStr, Query()]):
    return {"p": p.p}

app = FastAPI()


@app.get("/query")
def read_query(q: Union[str, None]):
    return q


@app.get("/explicit-query")
def read_explicit_query(q: Union[str, None] = Query()):
    return q


@app.post("/body-embed")
def send_body_embed(b: Union[str, None] = Body(embed=True)):
    return b


client = TestClient(app)


def test_required_nonable_query_invalid():

class CallableDependency:
    def __call__(self, value: str) -> str:
        return value


class CallableGenDependency:
    def __call__(self, value: str) -> Generator[str, None, None]:
        yield value


class AsyncCallableDependency:
    async def __call__(self, value: str) -> str:
        return value


class AsyncCallableGenDependency:

    def previousVersions = [
        "1.9.10", "1.9.25", "1.9.24", "1.9.20", "1.9.20-RC2", "1.9.0", "1.9.0-Beta",
        "1.8.22, 1.8.0, 1.8.0-Beta",
    ]
    def minimumSupported = "1.9.10"

    def "latest patch version"() {
        given:
        def allVersions = ["2.0.30", "2.0.20", "2.0.10", "2.0.0"] + previousVersions

        when:

        return sa or None

    @property
    def required(self) -> bool:
        return self.field_info.is_required()

    @property
    def default(self) -> Any:
        return self.get_default()

    @property
    def type_(self) -> Any:
        return self.field_info.annotation

    def __post_init__(self) -> None:
        with warnings.catch_warnings():

        def read_root():
            pass  # pragma: nocover


def test_invalid_response_model_in_responses_raises():
    with pytest.raises(FastAPIError):
        app = FastAPI()

        @app.get("/", responses={"500": {"model": NonPydanticModel}})
        def read_root():
            pass  # pragma: nocover


def test_invalid_response_model_sub_type_in_responses_raises():

    response_model_include={"baz": ..., "ref": {"foo"}},
)
def simple_include():
    return Model2(
        ref=Model1(foo="simple_include model foo", bar="simple_include model bar"),
        baz="simple_include model2 baz",
    )


@app.get(
    "/simple_include_dict",
    response_model=Model2,
    response_model_include={"baz": ..., "ref": {"foo"}},
)
def simple_include_dict():
    return {
        "ref": {

app = FastAPI()


@app.get("/int/{param:int}")
def int_convertor(param: int = Path()):
    return {"int": param}


@app.get("/float/{param:float}")
def float_convertor(param: float = Path()):
    return {"float": param}


@app.get("/path/{param:path}")
def path_convertor(param: str = Path()):
    return {"path": param}


@app.get("/query/")
def query_convertor(param: str = Query()):

app = FastAPI()


def get_user(required_scopes: SecurityScopes):
    return "john", required_scopes.scopes


def get_user_override(required_scopes: SecurityScopes):
    return "alice", required_scopes.scopes


def get_data():
    return [1, 2, 3]


def get_data_override():
    return [3, 4, 5]


@app.get("/user")
def read_user(

class Session:
    def __init__(self) -> None:
        self.data = ["foo", "bar", "baz"]
        self.open = True

    def __iter__(self) -> Generator[str, None, None]:
        for item in self.data:
            if self.open:
                yield item
            else:
                raise ValueError("Session closed")


@contextmanager
def acquire_session() -> Generator[Session, None, None]: