from fastapi import APIRouter, FastAPI
from fastapi.responses import HTMLResponse, JSONResponse, PlainTextResponse
from fastapi.testclient import TestClient


class OverrideResponse(JSONResponse):
    media_type = "application/x-override"



            

Reported by Pylint.

              from fastapi.testclient import TestClient


class OverrideResponse(JSONResponse):
    media_type = "application/x-override"


app = FastAPI()
router_a = APIRouter()

            

Reported by Pylint.

              from fastapi.testclient import TestClient


class OverrideResponse(JSONResponse):
    media_type = "application/x-override"


app = FastAPI()
router_a = APIRouter()

            

Reported by Pylint.

              

@app.get("/")
def get_root():
    return {"msg": "Hello World"}


@app.get("/override", response_class=PlainTextResponse)
def get_path_override():

            

Reported by Pylint.

              

@app.get("/override", response_class=PlainTextResponse)
def get_path_override():
    return "Hello World"


@router_a.get("/")
def get_a():

            

Reported by Pylint.

              

@router_a.get("/")
def get_a():
    return {"msg": "Hello A"}


@router_a.get("/override", response_class=PlainTextResponse)
def get_a_path_override():

            

Reported by Pylint.

              

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


@router_a_a.get("/")
def get_a_a():

            

Reported by Pylint.

              

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

            

Reported by Pylint.

              

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

            

Reported by Pylint.

              

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

            

Reported by Pylint.

              from pathlib import Path
from unittest.mock import MagicMock

import pytest
from fastapi.testclient import TestClient

from ...utils import needs_py37

openapi_schema = {

            

Reported by Pylint.

              import pytest
from fastapi.testclient import TestClient

from ...utils import needs_py37

openapi_schema = {
    "openapi": "3.0.2",
    "info": {"title": "FastAPI", "version": "0.1.0"},
    "paths": {

            

Reported by Pylint.

              

@needs_py37
def test_openapi_schema(client):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == openapi_schema



            

Reported by Pylint.

              

@needs_py37
def test_create_user(client):
    test_user = {"email": "johndoe@example.com", "password": "secret"}
    response = client.post("/users/", json=test_user)
    assert response.status_code == 200, response.text
    data = response.json()
    assert test_user["email"] == data["email"]

            

Reported by Pylint.

              

@needs_py37
def test_get_user(client):
    response = client.get("/users/1")
    assert response.status_code == 200, response.text
    data = response.json()
    assert "email" in data
    assert "id" in data

            

Reported by Pylint.

              

@needs_py37
def test_inexistent_user(client):
    response = client.get("/users/999")
    assert response.status_code == 404, response.text


@needs_py37

            

Reported by Pylint.

              

@needs_py37
def test_get_users(client):
    response = client.get("/users/")
    assert response.status_code == 200, response.text
    data = response.json()
    assert "email" in data[0]
    assert "id" in data[0]

            

Reported by Pylint.

              

@needs_py37
def test_get_slowusers(client):
    response = client.get("/slowusers/")
    assert response.status_code == 200, response.text
    data = response.json()
    assert "email" in data[0]
    assert "id" in data[0]

            

Reported by Pylint.

              

@needs_py37
def test_create_item(client):
    item = {"title": "Foo", "description": "Something that fights"}
    response = client.post("/users/1/items/", json=item)
    assert response.status_code == 200, response.text
    item_data = response.json()
    assert item["title"] == item_data["title"]

            

Reported by Pylint.

              

@needs_py37
def test_read_items(client):
    response = client.get("/items/")
    assert response.status_code == 200, response.text
    data = response.json()
    assert data
    first_item = data[0]

            

Reported by Pylint.

              from typing import Any, Callable, Dict, Optional, Sequence

from fastapi import params
from pydantic.fields import Undefined


def Path(  # noqa: N802
    default: Any,
    *,

            

Reported by Pylint.

              from typing import Any, Callable, Dict, Optional, Sequence

from fastapi import params
from pydantic.fields import Undefined


def Path(  # noqa: N802
    default: Any,
    *,

            

Reported by Pylint.

              from typing import Any, Callable, Dict, Optional, Sequence

from fastapi import params
from pydantic.fields import Undefined


def Path(  # noqa: N802
    default: Any,
    *,

            

Reported by Pylint.

              from pydantic.fields import Undefined


def Path(  # noqa: N802
    default: Any,
    *,
    alias: Optional[str] = None,
    title: Optional[str] = None,
    description: Optional[str] = None,

            

Reported by Pylint.

              from pydantic.fields import Undefined


def Path(  # noqa: N802
    default: Any,
    *,
    alias: Optional[str] = None,
    title: Optional[str] = None,
    description: Optional[str] = None,

            

Reported by Pylint.

                  alias: Optional[str] = None,
    title: Optional[str] = None,
    description: Optional[str] = None,
    gt: Optional[float] = None,
    ge: Optional[float] = None,
    lt: Optional[float] = None,
    le: Optional[float] = None,
    min_length: Optional[int] = None,
    max_length: Optional[int] = None,

            

Reported by Pylint.

                  title: Optional[str] = None,
    description: Optional[str] = None,
    gt: Optional[float] = None,
    ge: Optional[float] = None,
    lt: Optional[float] = None,
    le: Optional[float] = None,
    min_length: Optional[int] = None,
    max_length: Optional[int] = None,
    regex: Optional[str] = None,

            

Reported by Pylint.

                  description: Optional[str] = None,
    gt: Optional[float] = None,
    ge: Optional[float] = None,
    lt: Optional[float] = None,
    le: Optional[float] = None,
    min_length: Optional[int] = None,
    max_length: Optional[int] = None,
    regex: Optional[str] = None,
    example: Any = Undefined,

            

Reported by Pylint.

                  gt: Optional[float] = None,
    ge: Optional[float] = None,
    lt: Optional[float] = None,
    le: Optional[float] = None,
    min_length: Optional[int] = None,
    max_length: Optional[int] = None,
    regex: Optional[str] = None,
    example: Any = Undefined,
    examples: Optional[Dict[str, Any]] = None,

            

Reported by Pylint.

                  )


def Query(  # noqa: N802
    default: Any,
    *,
    alias: Optional[str] = None,
    title: Optional[str] = None,
    description: Optional[str] = None,

            

Reported by Pylint.

              from fastapi.openapi.utils import get_openapi
from fastapi.params import Depends
from fastapi.types import DecoratedCallable
from starlette.applications import Starlette
from starlette.datastructures import State
from starlette.exceptions import HTTPException
from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import HTMLResponse, JSONResponse, Response

            

Reported by Pylint.

              from fastapi.params import Depends
from fastapi.types import DecoratedCallable
from starlette.applications import Starlette
from starlette.datastructures import State
from starlette.exceptions import HTTPException
from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import HTMLResponse, JSONResponse, Response
from starlette.routing import BaseRoute

            

Reported by Pylint.

              from fastapi.types import DecoratedCallable
from starlette.applications import Starlette
from starlette.datastructures import State
from starlette.exceptions import HTTPException
from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import HTMLResponse, JSONResponse, Response
from starlette.routing import BaseRoute
from starlette.types import ASGIApp, Receive, Scope, Send

            

Reported by Pylint.

              from starlette.applications import Starlette
from starlette.datastructures import State
from starlette.exceptions import HTTPException
from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import HTMLResponse, JSONResponse, Response
from starlette.routing import BaseRoute
from starlette.types import ASGIApp, Receive, Scope, Send


            

Reported by Pylint.

              from starlette.datastructures import State
from starlette.exceptions import HTTPException
from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import HTMLResponse, JSONResponse, Response
from starlette.routing import BaseRoute
from starlette.types import ASGIApp, Receive, Scope, Send



            

Reported by Pylint.

              from starlette.exceptions import HTTPException
from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import HTMLResponse, JSONResponse, Response
from starlette.routing import BaseRoute
from starlette.types import ASGIApp, Receive, Scope, Send


class FastAPI(Starlette):

            

Reported by Pylint.

              from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import HTMLResponse, JSONResponse, Response
from starlette.routing import BaseRoute
from starlette.types import ASGIApp, Receive, Scope, Send


class FastAPI(Starlette):
    def __init__(

            

Reported by Pylint.

              from starlette.requests import Request
from starlette.responses import HTMLResponse, JSONResponse, Response
from starlette.routing import BaseRoute
from starlette.types import ASGIApp, Receive, Scope, Send


class FastAPI(Starlette):
    def __init__(
        self,

            

Reported by Pylint.

                      self.servers = servers or []
        self.openapi_url = openapi_url
        self.openapi_tags = openapi_tags
        # TODO: remove when discarding the openapi_prefix parameter
        if openapi_prefix:
            logger.warning(
                '"openapi_prefix" has been deprecated in favor of "root_path", which '
                "follows more closely the ASGI standard, is simpler, and more "
                "automatic. Check the docs at "

            

Reported by Pylint.

              
            if self.swagger_ui_oauth2_redirect_url:

                async def swagger_ui_redirect(req: Request) -> HTMLResponse:
                    return get_swagger_ui_oauth2_redirect_html()

                self.add_route(
                    self.swagger_ui_oauth2_redirect_url,
                    swagger_ui_redirect,

            

Reported by Pylint.

              
from fastapi import FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field

app = FastAPI()


class Model(BaseModel):

            

Reported by Pylint.

              from typing import List

from fastapi import FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel, Field

app = FastAPI()



            

Reported by Pylint.

              app = FastAPI()


class Model(BaseModel):
    name: str = Field(alias="alias")


class ModelNoAlias(BaseModel):
    name: str

            

Reported by Pylint.

              app = FastAPI()


class Model(BaseModel):
    name: str = Field(alias="alias")


class ModelNoAlias(BaseModel):
    name: str

            

Reported by Pylint.

                  name: str = Field(alias="alias")


class ModelNoAlias(BaseModel):
    name: str

    class Config:
        schema_extra = {
            "description": (

            

Reported by Pylint.

                  name: str = Field(alias="alias")


class ModelNoAlias(BaseModel):
    name: str

    class Config:
        schema_extra = {
            "description": (

            

Reported by Pylint.

              class ModelNoAlias(BaseModel):
    name: str

    class Config:
        schema_extra = {
            "description": (
                "response_model_by_alias=False is basically a quick hack, to support "
                "proper OpenAPI use another model with the correct field names"
            )

            

Reported by Pylint.

              class ModelNoAlias(BaseModel):
    name: str

    class Config:
        schema_extra = {
            "description": (
                "response_model_by_alias=False is basically a quick hack, to support "
                "proper OpenAPI use another model with the correct field names"
            )

            

Reported by Pylint.

              

@app.get("/dict", response_model=Model, response_model_by_alias=False)
def read_dict():
    return {"alias": "Foo"}


@app.get("/model", response_model=Model, response_model_by_alias=False)
def read_model():

            

Reported by Pylint.

              

@app.get("/model", response_model=Model, response_model_by_alias=False)
def read_model():
    return Model(alias="Foo")


@app.get("/list", response_model=List[Model], response_model_by_alias=False)
def read_list():

            

Reported by Pylint.

              import importlib
from pathlib import Path

import pytest
from fastapi.testclient import TestClient

openapi_schema = {
    "openapi": "3.0.2",
    "info": {"title": "FastAPI", "version": "0.1.0"},

            

Reported by Pylint.

                      test_db.unlink()


def test_openapi_schema(client):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == openapi_schema



            

Reported by Pylint.

                  assert response.json() == openapi_schema


def test_create_user(client):
    test_user = {"email": "johndoe@example.com", "password": "secret"}
    response = client.post("/users/", json=test_user)
    assert response.status_code == 200, response.text
    data = response.json()
    assert test_user["email"] == data["email"]

            

Reported by Pylint.

                  assert response.status_code == 400, response.text


def test_get_user(client):
    response = client.get("/users/1")
    assert response.status_code == 200, response.text
    data = response.json()
    assert "email" in data
    assert "id" in data

            

Reported by Pylint.

                  assert "id" in data


def test_inexistent_user(client):
    response = client.get("/users/999")
    assert response.status_code == 404, response.text


def test_get_users(client):

            

Reported by Pylint.

                  assert response.status_code == 404, response.text


def test_get_users(client):
    response = client.get("/users/")
    assert response.status_code == 200, response.text
    data = response.json()
    assert "email" in data[0]
    assert "id" in data[0]

            

Reported by Pylint.

                  assert "id" in data[0]


def test_create_item(client):
    item = {"title": "Foo", "description": "Something that fights"}
    response = client.post("/users/1/items/", json=item)
    assert response.status_code == 200, response.text
    item_data = response.json()
    assert item["title"] == item_data["title"]

            

Reported by Pylint.

                  assert item_to_check["description"] == item["description"]


def test_read_items(client):
    response = client.get("/items/")
    assert response.status_code == 200, response.text
    data = response.json()
    assert data
    first_item = data[0]

            

Reported by Pylint.

              import importlib
from pathlib import Path

import pytest
from fastapi.testclient import TestClient

openapi_schema = {
    "openapi": "3.0.2",
    "info": {"title": "FastAPI", "version": "0.1.0"},

            

Reported by Pylint.

              

@pytest.fixture(scope="module")
def client():
    test_db = Path("./sql_app.db")
    if test_db.is_file():  # pragma: nocover
        test_db.unlink()
    # Import while creating the client to create the DB after starting the test session
    from docs_src.sql_databases.sql_app import main

            

Reported by Pylint.

              import importlib
from pathlib import Path

import pytest
from fastapi.testclient import TestClient

openapi_schema = {
    "openapi": "3.0.2",
    "info": {"title": "FastAPI", "version": "0.1.0"},

            

Reported by Pylint.

                      test_db.unlink()


def test_openapi_schema(client):
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == openapi_schema



            

Reported by Pylint.

                  assert response.json() == openapi_schema


def test_create_user(client):
    test_user = {"email": "johndoe@example.com", "password": "secret"}
    response = client.post("/users/", json=test_user)
    assert response.status_code == 200, response.text
    data = response.json()
    assert test_user["email"] == data["email"]

            

Reported by Pylint.

                  assert response.status_code == 400, response.text


def test_get_user(client):
    response = client.get("/users/1")
    assert response.status_code == 200, response.text
    data = response.json()
    assert "email" in data
    assert "id" in data

            

Reported by Pylint.

                  assert "id" in data


def test_inexistent_user(client):
    response = client.get("/users/999")
    assert response.status_code == 404, response.text


def test_get_users(client):

            

Reported by Pylint.

                  assert response.status_code == 404, response.text


def test_get_users(client):
    response = client.get("/users/")
    assert response.status_code == 200, response.text
    data = response.json()
    assert "email" in data[0]
    assert "id" in data[0]

            

Reported by Pylint.

                  assert "id" in data[0]


def test_create_item(client):
    item = {"title": "Foo", "description": "Something that fights"}
    response = client.post("/users/1/items/", json=item)
    assert response.status_code == 200, response.text
    item_data = response.json()
    assert item["title"] == item_data["title"]

            

Reported by Pylint.

                  assert item_to_check["description"] == item["description"]


def test_read_items(client):
    response = client.get("/items/")
    assert response.status_code == 200, response.text
    data = response.json()
    assert data
    first_item = data[0]

            

Reported by Pylint.

              import importlib
from pathlib import Path

import pytest
from fastapi.testclient import TestClient

openapi_schema = {
    "openapi": "3.0.2",
    "info": {"title": "FastAPI", "version": "0.1.0"},

            

Reported by Pylint.

              

@pytest.fixture(scope="module")
def client():
    test_db = Path("./sql_app.db")
    if test_db.is_file():  # pragma: nocover
        test_db.unlink()
    # Import while creating the client to create the DB after starting the test session
    from docs_src.sql_databases.sql_app import alt_main

            

Reported by Pylint.

              from typing import Dict, List, Tuple

import pytest
from fastapi import FastAPI
from pydantic import BaseModel


def test_invalid_sequence():
    with pytest.raises(AssertionError):

            

Reported by Pylint.

              
import pytest
from fastapi import FastAPI
from pydantic import BaseModel


def test_invalid_sequence():
    with pytest.raises(AssertionError):
        app = FastAPI()

            

Reported by Pylint.

                          title: str

        @app.get("/items/{id}")
        def read_items(id: List[Item]):
            pass  # pragma: no cover


def test_invalid_tuple():
    with pytest.raises(AssertionError):

            

Reported by Pylint.

                          title: str

        @app.get("/items/{id}")
        def read_items(id: List[Item]):
            pass  # pragma: no cover


def test_invalid_tuple():
    with pytest.raises(AssertionError):

            

Reported by Pylint.

                          title: str

        @app.get("/items/{id}")
        def read_items(id: List[Item]):
            pass  # pragma: no cover


def test_invalid_tuple():
    with pytest.raises(AssertionError):

            

Reported by Pylint.

                          title: str

        @app.get("/items/{id}")
        def read_items(id: Tuple[Item, Item]):
            pass  # pragma: no cover


def test_invalid_dict():
    with pytest.raises(AssertionError):

            

Reported by Pylint.

                          title: str

        @app.get("/items/{id}")
        def read_items(id: Tuple[Item, Item]):
            pass  # pragma: no cover


def test_invalid_dict():
    with pytest.raises(AssertionError):

            

Reported by Pylint.

                          title: str

        @app.get("/items/{id}")
        def read_items(id: Tuple[Item, Item]):
            pass  # pragma: no cover


def test_invalid_dict():
    with pytest.raises(AssertionError):

            

Reported by Pylint.

                          title: str

        @app.get("/items/{id}")
        def read_items(id: Dict[str, Item]):
            pass  # pragma: no cover


def test_invalid_simple_list():
    with pytest.raises(AssertionError):

            

Reported by Pylint.

                          title: str

        @app.get("/items/{id}")
        def read_items(id: Dict[str, Item]):
            pass  # pragma: no cover


def test_invalid_simple_list():
    with pytest.raises(AssertionError):

            

Reported by Pylint.

              from fastapi import Body, Cookie, FastAPI, Header, Path, Query
from fastapi.testclient import TestClient
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    data: str

            

Reported by Pylint.

                  return item


# 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")):
#     return firstname


            

Reported by Pylint.

              

# 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")):
#     return firstname



            

Reported by Pylint.

              from fastapi import Body, Cookie, FastAPI, Header, Path, Query
from fastapi.testclient import TestClient
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    data: str

            

Reported by Pylint.

              app = FastAPI()


class Item(BaseModel):
    data: str

    class Config:
        schema_extra = {"example": {"data": "Data in schema_extra"}}


            

Reported by Pylint.

              app = FastAPI()


class Item(BaseModel):
    data: str

    class Config:
        schema_extra = {"example": {"data": "Data in schema_extra"}}


            

Reported by Pylint.

              class Item(BaseModel):
    data: str

    class Config:
        schema_extra = {"example": {"data": "Data in schema_extra"}}


@app.post("/schema_extra/")
def schema_extra(item: Item):

            

Reported by Pylint.

              class Item(BaseModel):
    data: str

    class Config:
        schema_extra = {"example": {"data": "Data in schema_extra"}}


@app.post("/schema_extra/")
def schema_extra(item: Item):

            

Reported by Pylint.

              

@app.post("/schema_extra/")
def schema_extra(item: Item):
    return item


@app.post("/example/")
def example(item: Item = Body(..., example={"data": "Data in Body example"})):

            

Reported by Pylint.

              

@app.post("/example/")
def example(item: Item = Body(..., example={"data": "Data in Body example"})):
    return item


@app.post("/examples/")
def examples(

            

Reported by Pylint.

              from pathlib import Path
from typing import Dict, List, Optional, Tuple

import mkdocs.commands.build
import mkdocs.commands.serve
import mkdocs.config
import mkdocs.utils
import typer
import yaml

            

Reported by Pylint.

              from typing import Dict, List, Optional, Tuple

import mkdocs.commands.build
import mkdocs.commands.serve
import mkdocs.config
import mkdocs.utils
import typer
import yaml
from jinja2 import Template

            

Reported by Pylint.

              
import mkdocs.commands.build
import mkdocs.commands.serve
import mkdocs.config
import mkdocs.utils
import typer
import yaml
from jinja2 import Template


            

Reported by Pylint.

              import mkdocs.commands.build
import mkdocs.commands.serve
import mkdocs.config
import mkdocs.utils
import typer
import yaml
from jinja2 import Template

app = typer.Typer()

            

Reported by Pylint.

              import mkdocs.commands.serve
import mkdocs.config
import mkdocs.utils
import typer
import yaml
from jinja2 import Template

app = typer.Typer()


            

Reported by Pylint.

                      dest_path = overrides_dest / path.name
        if not dest_path.exists():
            shutil.copy(path, dest_path)
    en_config_path: Path = en_lang_path / mkdocs_name
    en_config: dict = mkdocs.utils.yaml_load(en_config_path.read_text(encoding="utf-8"))
    nav = en_config["nav"]
    lang_config_path: Path = lang_path / mkdocs_name
    lang_config: dict = mkdocs.utils.yaml_load(
        lang_config_path.read_text(encoding="utf-8")

            

Reported by Pylint.

                  os.chdir("site")
    server_address = ("", 8008)
    server = HTTPServer(server_address, SimpleHTTPRequestHandler)
    typer.echo(f"Serving at: http://127.0.0.1:8008")
    server.serve_forever()


@app.command()
def live(

            

Reported by Pylint.

              import os
import re
import shutil
from http.server import HTTPServer, SimpleHTTPRequestHandler
from multiprocessing import Pool
from pathlib import Path
from typing import Dict, List, Optional, Tuple

import mkdocs.commands.build

            

Reported by Pylint.

              
app = typer.Typer()

mkdocs_name = "mkdocs.yml"

missing_translation_snippet = """
{!../../../docs/missing-translation.md!}
"""


            

Reported by Pylint.

              
mkdocs_name = "mkdocs.yml"

missing_translation_snippet = """
{!../../../docs/missing-translation.md!}
"""

docs_path = Path("docs")
en_docs_path = Path("docs/en")

            

Reported by Pylint.