from fastapi.testclient import TestClient

app = FastAPI()


def function_dependency(value: str) -> str:
    return value


async def async_function_dependency(value: str) -> str:
    return value


def gen_dependency(value: str) -> Generator[str, None, None]:
    yield value


async def async_gen_dependency(value: str) -> AsyncGenerator[str, None]:
    yield value

# Without aliases


@app.get("/optional-str")
async def read_optional_str(p: Annotated[Optional[str], Cookie()] = None):
    return {"p": p}


class CookieModelOptionalStr(BaseModel):
    p: Optional[str] = None


@app.get("/model-optional-str")
async def read_model_optional_str(p: Annotated[CookieModelOptionalStr, Cookie()]):
    return {"p": p.p}

# Without aliases


@app.get("/optional-list-str")
async def read_optional_list_str(
    p: Annotated[Optional[list[str]], Header()] = None,
):
    return {"p": p}


class HeaderModelOptionalListStr(BaseModel):
    p: Optional[list[str]] = None


@app.get("/model-optional-list-str")
async def read_model_optional_list_str(
    p: Annotated[HeaderModelOptionalListStr, Header()],
):

    def format = new SimpleDateFormat('yyyyMMddHHmmssZ')

    def setup() {
        format.timeZone = TimeZone.getTimeZone("UTC")
    }

    def "final release is added to list"() {
        def snapshot = snapshot('4.3')
        def rc = releasedVersion('4.3-rc-1')
        def versions = releasedVersions(snapshot, rc, [])
        def version = new ReleasedVersion('4.2', '20170913122310+0000')

# 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():

        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():

@app.post("/sync/validated", response_model=ItemOut)
def sync_validated(item: ItemIn, dep: Annotated[int, Depends(dep_b)]):
    return ItemOut(name=item.name, value=item.value, dep=dep)


@app.get("/sync/dict-no-response-model")
def sync_dict_no_response_model():
    return {"name": "foo", "value": 123}


@app.get("/sync/dict-with-response-model", response_model=ItemOut)
def sync_dict_with_response_model(

    BinaryCompatibilityRepository repository

    def jApiClassifier = Stub(JApiClass) // represents interfaces, enums and annotations
    def jApiMethod = Stub(JApiMethod)
    def jApiField = Stub(JApiField) // represents fields and enum literals
    def jApiConstructor = Stub(JApiConstructor)
    def incubatingAnnotation = Stub(JApiAnnotation)
    def deprecatedAnnotation = Stub(JApiAnnotation)
    def overrideAnnotation = Stub(JApiAnnotation)

@router_a_a.get("/")
def get_a_a():
    return {"msg": "Hello A A"}


@router_a_a.get("/override", response_class=PlainTextResponse)
def get_a_a_path_override():
    return "Hello A A"


@router_a_b_override.get("/")
def get_a_b():
    return "Hello A B"


@router_a_b_override.get("/override", response_class=HTMLResponse)
def get_a_b_path_override():
    return "Hello A B"


@router_b_override.get("/")
def get_b():