__version__ = "0.68.0"

from starlette import status as status

from .applications import FastAPI as FastAPI
from .background import BackgroundTasks as BackgroundTasks
from .datastructures import UploadFile as UploadFile
from .exceptions import HTTPException as HTTPException

            

Reported by Pylint.

              
from starlette import status as status

from .applications import FastAPI as FastAPI
from .background import BackgroundTasks as BackgroundTasks
from .datastructures import UploadFile as UploadFile
from .exceptions import HTTPException as HTTPException
from .param_functions import Body as Body
from .param_functions import Cookie as Cookie

            

Reported by Pylint.

              from starlette import status as status

from .applications import FastAPI as FastAPI
from .background import BackgroundTasks as BackgroundTasks
from .datastructures import UploadFile as UploadFile
from .exceptions import HTTPException as HTTPException
from .param_functions import Body as Body
from .param_functions import Cookie as Cookie
from .param_functions import Depends as Depends

            

Reported by Pylint.

              
from .applications import FastAPI as FastAPI
from .background import BackgroundTasks as BackgroundTasks
from .datastructures import UploadFile as UploadFile
from .exceptions import HTTPException as HTTPException
from .param_functions import Body as Body
from .param_functions import Cookie as Cookie
from .param_functions import Depends as Depends
from .param_functions import File as File

            

Reported by Pylint.

              from .applications import FastAPI as FastAPI
from .background import BackgroundTasks as BackgroundTasks
from .datastructures import UploadFile as UploadFile
from .exceptions import HTTPException as HTTPException
from .param_functions import Body as Body
from .param_functions import Cookie as Cookie
from .param_functions import Depends as Depends
from .param_functions import File as File
from .param_functions import Form as Form

            

Reported by Pylint.

              from .background import BackgroundTasks as BackgroundTasks
from .datastructures import UploadFile as UploadFile
from .exceptions import HTTPException as HTTPException
from .param_functions import Body as Body
from .param_functions import Cookie as Cookie
from .param_functions import Depends as Depends
from .param_functions import File as File
from .param_functions import Form as Form
from .param_functions import Header as Header

            

Reported by Pylint.

              from .datastructures import UploadFile as UploadFile
from .exceptions import HTTPException as HTTPException
from .param_functions import Body as Body
from .param_functions import Cookie as Cookie
from .param_functions import Depends as Depends
from .param_functions import File as File
from .param_functions import Form as Form
from .param_functions import Header as Header
from .param_functions import Path as Path

            

Reported by Pylint.

              from .exceptions import HTTPException as HTTPException
from .param_functions import Body as Body
from .param_functions import Cookie as Cookie
from .param_functions import Depends as Depends
from .param_functions import File as File
from .param_functions import Form as Form
from .param_functions import Header as Header
from .param_functions import Path as Path
from .param_functions import Query as Query

            

Reported by Pylint.

              from .param_functions import Body as Body
from .param_functions import Cookie as Cookie
from .param_functions import Depends as Depends
from .param_functions import File as File
from .param_functions import Form as Form
from .param_functions import Header as Header
from .param_functions import Path as Path
from .param_functions import Query as Query
from .param_functions import Security as Security

            

Reported by Pylint.

              from .param_functions import Cookie as Cookie
from .param_functions import Depends as Depends
from .param_functions import File as File
from .param_functions import Form as Form
from .param_functions import Header as Header
from .param_functions import Path as Path
from .param_functions import Query as Query
from .param_functions import Security as Security
from .requests import Request as Request

            

Reported by Pylint.

              import http
from typing import Optional

from fastapi import FastAPI, Path, Query

app = FastAPI()


@app.api_route("/api_route")

            

Reported by Pylint.

              

@app.api_route("/api_route")
def non_operation():
    return {"message": "Hello World"}


def non_decorated_route():
    return {"message": "Hello World"}

            

Reported by Pylint.

                  return {"message": "Hello World"}


def non_decorated_route():
    return {"message": "Hello World"}


app.add_api_route("/non_decorated_route", non_decorated_route)


            

Reported by Pylint.

              

@app.get("/text")
def get_text():
    return "Hello World"


@app.get("/path/{item_id}")
def get_id(item_id):

            

Reported by Pylint.

              

@app.get("/path/{item_id}")
def get_id(item_id):
    return item_id


@app.get("/path/str/{item_id}")
def get_str_id(item_id: str):

            

Reported by Pylint.

              

@app.get("/path/str/{item_id}")
def get_str_id(item_id: str):
    return item_id


@app.get("/path/int/{item_id}")
def get_int_id(item_id: int):

            

Reported by Pylint.

              

@app.get("/path/int/{item_id}")
def get_int_id(item_id: int):
    return item_id


@app.get("/path/float/{item_id}")
def get_float_id(item_id: float):

            

Reported by Pylint.

              

@app.get("/path/float/{item_id}")
def get_float_id(item_id: float):
    return item_id


@app.get("/path/bool/{item_id}")
def get_bool_id(item_id: bool):

            

Reported by Pylint.

              

@app.get("/path/bool/{item_id}")
def get_bool_id(item_id: bool):
    return item_id


@app.get("/path/param/{item_id}")
def get_path_param_id(item_id: Optional[str] = Path(None)):

            

Reported by Pylint.

              

@app.get("/path/param/{item_id}")
def get_path_param_id(item_id: Optional[str] = Path(None)):
    return item_id


@app.get("/path/param-required/{item_id}")
def get_path_param_required_id(item_id: str = Path(...)):

            

Reported by Pylint.

              from fastapi import (
    Body,
    Cookie,
    Depends,
    FastAPI,
    File,
    Form,
    Header,
    Path,

            

Reported by Pylint.

                  Query,
    Security,
)
from fastapi.security import (
    HTTPBasic,
    OAuth2,
    OAuth2PasswordBearer,
    OAuth2PasswordRequestForm,
)

            

Reported by Pylint.

                  OAuth2PasswordBearer,
    OAuth2PasswordRequestForm,
)
from pydantic import BaseModel
from starlette.responses import HTMLResponse, JSONResponse, PlainTextResponse
from starlette.status import HTTP_202_ACCEPTED

app = FastAPI()


            

Reported by Pylint.

                  OAuth2PasswordRequestForm,
)
from pydantic import BaseModel
from starlette.responses import HTMLResponse, JSONResponse, PlainTextResponse
from starlette.status import HTTP_202_ACCEPTED

app = FastAPI()



            

Reported by Pylint.

              )
from pydantic import BaseModel
from starlette.responses import HTMLResponse, JSONResponse, PlainTextResponse
from starlette.status import HTTP_202_ACCEPTED

app = FastAPI()


@app.get("/security")

            

Reported by Pylint.

              from fastapi import (
    Body,
    Cookie,
    Depends,
    FastAPI,
    File,
    Form,
    Header,
    Path,

            

Reported by Pylint.

              from fastapi import (
    Body,
    Cookie,
    Depends,
    FastAPI,
    File,
    Form,
    Header,
    Path,

            

Reported by Pylint.

              from fastapi import (
    Body,
    Cookie,
    Depends,
    FastAPI,
    File,
    Form,
    Header,
    Path,

            

Reported by Pylint.

              from fastapi import (
    Body,
    Cookie,
    Depends,
    FastAPI,
    File,
    Form,
    Header,
    Path,

            

Reported by Pylint.

              from fastapi import (
    Body,
    Cookie,
    Depends,
    FastAPI,
    File,
    Form,
    Header,
    Path,

            

Reported by Pylint.

              from fastapi import FastAPI
from fastapi.responses import JSONResponse
from fastapi.testclient import TestClient
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):

            

Reported by Pylint.

              

@app.trace("/items/{item_id}")
def trace_item(item_id: str):
    return JSONResponse(media_type="message/http")


client = TestClient(app)


            

Reported by Pylint.

              from typing import Optional

from fastapi import FastAPI
from fastapi.responses import JSONResponse
from fastapi.testclient import TestClient
from pydantic import BaseModel

app = FastAPI()


            

Reported by Pylint.

              app = FastAPI()


class Item(BaseModel):
    name: str
    price: Optional[float] = None


@app.api_route("/items/{item_id}", methods=["GET"])

            

Reported by Pylint.

              app = FastAPI()


class Item(BaseModel):
    name: str
    price: Optional[float] = None


@app.api_route("/items/{item_id}", methods=["GET"])

            

Reported by Pylint.

              

@app.api_route("/items/{item_id}", methods=["GET"])
def get_items(item_id: str):
    return {"item_id": item_id}


def get_not_decorated(item_id: str):
    return {"item_id": item_id}

            

Reported by Pylint.

                  return {"item_id": item_id}


def get_not_decorated(item_id: str):
    return {"item_id": item_id}


app.add_api_route("/items-not-decorated/{item_id}", get_not_decorated)


            

Reported by Pylint.

              

@app.delete("/items/{item_id}")
def delete_item(item_id: str, item: Item):
    return {"item_id": item_id, "item": item}


@app.head("/items/{item_id}")
def head_item(item_id: str):

            

Reported by Pylint.

              

@app.head("/items/{item_id}")
def head_item(item_id: str):
    return JSONResponse(headers={"x-fastapi-item-id": item_id})


@app.options("/items/{item_id}")
def options_item(item_id: str):

            

Reported by Pylint.

              

@app.options("/items/{item_id}")
def options_item(item_id: str):
    return JSONResponse(headers={"x-fastapi-item-id": item_id})


@app.patch("/items/{item_id}")
def patch_item(item_id: str, item: Item):

            

Reported by Pylint.

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


class Model1(BaseModel):
    foo: str
    bar: str


            

Reported by Pylint.

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


class Model1(BaseModel):
    foo: str
    bar: str


            

Reported by Pylint.

              from pydantic import BaseModel


class Model1(BaseModel):
    foo: str
    bar: str


class Model2(BaseModel):

            

Reported by Pylint.

              from pydantic import BaseModel


class Model1(BaseModel):
    foo: str
    bar: str


class Model2(BaseModel):

            

Reported by Pylint.

              

class Model1(BaseModel):
    foo: str
    bar: str


class Model2(BaseModel):
    ref: Model1

            

Reported by Pylint.

              
class Model1(BaseModel):
    foo: str
    bar: str


class Model2(BaseModel):
    ref: Model1
    baz: str

            

Reported by Pylint.

                  bar: str


class Model2(BaseModel):
    ref: Model1
    baz: str


class Model3(BaseModel):

            

Reported by Pylint.

                  bar: str


class Model2(BaseModel):
    ref: Model1
    baz: str


class Model3(BaseModel):

            

Reported by Pylint.

              
class Model2(BaseModel):
    ref: Model1
    baz: str


class Model3(BaseModel):
    name: str
    age: int

            

Reported by Pylint.

                  baz: str


class Model3(BaseModel):
    name: str
    age: int
    ref2: Model2



            

Reported by Pylint.

              from typing import Optional

from fastapi import APIRouter, FastAPI
from fastapi.testclient import TestClient

app = FastAPI()


user_router = APIRouter()

            

Reported by Pylint.

              

@user_router.get("/")
def get_users():
    return [{"user_id": "u1"}, {"user_id": "u2"}]


@user_router.get("/{user_id}")
def get_user(user_id: str):

            

Reported by Pylint.

              

@user_router.get("/{user_id}")
def get_user(user_id: str):
    return {"user_id": user_id}


@item_router.get("/")
def get_items(user_id: Optional[str] = None):

            

Reported by Pylint.

              

@item_router.get("/")
def get_items(user_id: Optional[str] = None):
    if user_id is None:
        return [{"item_id": "i1", "user_id": "u1"}, {"item_id": "i2", "user_id": "u2"}]
    else:
        return [{"item_id": "i2", "user_id": user_id}]


            

Reported by Pylint.

              
@item_router.get("/")
def get_items(user_id: Optional[str] = None):
    if user_id is None:
        return [{"item_id": "i1", "user_id": "u1"}, {"item_id": "i2", "user_id": "u2"}]
    else:
        return [{"item_id": "i2", "user_id": user_id}]



            

Reported by Pylint.

              

@item_router.get("/{item_id}")
def get_item(item_id: str, user_id: Optional[str] = None):
    if user_id is None:
        return {"item_id": item_id}
    else:
        return {"item_id": item_id, "user_id": user_id}


            

Reported by Pylint.

              
@item_router.get("/{item_id}")
def get_item(item_id: str, user_id: Optional[str] = None):
    if user_id is None:
        return {"item_id": item_id}
    else:
        return {"item_id": item_id, "user_id": user_id}



            

Reported by Pylint.

              def test_get_users():
    """Check that /users returns expected data"""
    response = client.get("/users")
    assert response.status_code == 200, response.text
    assert response.json() == [{"user_id": "u1"}, {"user_id": "u2"}]


def test_get_user():
    """Check that /users/{user_id} returns expected data"""

            

Reported by Bandit.

                  """Check that /users returns expected data"""
    response = client.get("/users")
    assert response.status_code == 200, response.text
    assert response.json() == [{"user_id": "u1"}, {"user_id": "u2"}]


def test_get_user():
    """Check that /users/{user_id} returns expected data"""
    response = client.get("/users/abc123")

            

Reported by Bandit.

              def test_get_user():
    """Check that /users/{user_id} returns expected data"""
    response = client.get("/users/abc123")
    assert response.status_code == 200, response.text
    assert response.json() == {"user_id": "abc123"}


def test_get_items_1():
    """Check that /items returns expected data"""

            

Reported by Bandit.

              import pytest
from fastapi import FastAPI, File, Form, UploadFile
from fastapi.dependencies.utils import (
    multipart_incorrect_install_error,
    multipart_not_installed_error,
)


def test_incorrect_multipart_installed_form(monkeypatch):

            

Reported by Pylint.

                      app = FastAPI()

        @app.post("/")
        async def root(username: str = Form(...)):
            return username  # pragma: nocover


def test_incorrect_multipart_installed_file_upload(monkeypatch):
    monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)

            

Reported by Pylint.

                      app = FastAPI()

        @app.post("/")
        async def root(f: UploadFile = File(...)):
            return f  # pragma: nocover


def test_incorrect_multipart_installed_file_bytes(monkeypatch):
    monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)

            

Reported by Pylint.

                      app = FastAPI()

        @app.post("/")
        async def root(f: bytes = File(...)):
            return f  # pragma: nocover


def test_incorrect_multipart_installed_multi_form(monkeypatch):
    monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)

            

Reported by Pylint.

                      app = FastAPI()

        @app.post("/")
        async def root(username: str = Form(...), password: str = Form(...)):
            return username  # pragma: nocover


def test_incorrect_multipart_installed_form_file(monkeypatch):
    monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)

            

Reported by Pylint.

                      app = FastAPI()

        @app.post("/")
        async def root(username: str = Form(...), password: str = Form(...)):
            return username  # pragma: nocover


def test_incorrect_multipart_installed_form_file(monkeypatch):
    monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)

            

Reported by Pylint.

                      app = FastAPI()

        @app.post("/")
        async def root(username: str = Form(...), f: UploadFile = File(...)):
            return username  # pragma: nocover


def test_no_multipart_installed(monkeypatch):
    monkeypatch.delattr("multipart.__version__", raising=False)

            

Reported by Pylint.

                      app = FastAPI()

        @app.post("/")
        async def root(username: str = Form(...), f: UploadFile = File(...)):
            return username  # pragma: nocover


def test_no_multipart_installed(monkeypatch):
    monkeypatch.delattr("multipart.__version__", raising=False)

            

Reported by Pylint.

                      app = FastAPI()

        @app.post("/")
        async def root(username: str = Form(...)):
            return username  # pragma: nocover


def test_no_multipart_installed_file(monkeypatch):
    monkeypatch.delattr("multipart.__version__", raising=False)

            

Reported by Pylint.

                      app = FastAPI()

        @app.post("/")
        async def root(f: UploadFile = File(...)):
            return f  # pragma: nocover


def test_no_multipart_installed_file_bytes(monkeypatch):
    monkeypatch.delattr("multipart.__version__", raising=False)

            

Reported by Pylint.

              from datetime import datetime, timedelta
from typing import List, Optional

from fastapi import Depends, FastAPI, HTTPException, Security, status
from fastapi.security import (
    OAuth2PasswordBearer,
    OAuth2PasswordRequestForm,
    SecurityScopes,
)

            

Reported by Pylint.

              from typing import List, Optional

from fastapi import Depends, FastAPI, HTTPException, Security, status
from fastapi.security import (
    OAuth2PasswordBearer,
    OAuth2PasswordRequestForm,
    SecurityScopes,
)
from jose import JWTError, jwt

            

Reported by Pylint.

                  OAuth2PasswordRequestForm,
    SecurityScopes,
)
from jose import JWTError, jwt
from passlib.context import CryptContext
from pydantic import BaseModel, ValidationError

# to get a string like this run:
# openssl rand -hex 32

            

Reported by Pylint.

                  SecurityScopes,
)
from jose import JWTError, jwt
from passlib.context import CryptContext
from pydantic import BaseModel, ValidationError

# to get a string like this run:
# openssl rand -hex 32
SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"

            

Reported by Pylint.

              )
from jose import JWTError, jwt
from passlib.context import CryptContext
from pydantic import BaseModel, ValidationError

# to get a string like this run:
# openssl rand -hex 32
SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
ALGORITHM = "HS256"

            

Reported by Pylint.

                      raise HTTPException(status_code=400, detail="Incorrect username or password")
    access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    access_token = create_access_token(
        data={"sub": user.username, "scopes": form_data.scopes},
        expires_delta=access_token_expires,
    )
    return {"access_token": access_token, "token_type": "bearer"}



            

Reported by Pylint.

                  if security_scopes.scopes:
        authenticate_value = f'Bearer scope="{security_scopes.scope_str}"'
    else:
        authenticate_value = f"Bearer"
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": authenticate_value},
    )

            

Reported by Pylint.

                      token_scopes = payload.get("scopes", [])
        token_data = TokenData(scopes=token_scopes, username=username)
    except (JWTError, ValidationError):
        raise credentials_exception
    user = get_user(fake_users_db, username=token_data.username)
    if user is None:
        raise credentials_exception
    for scope in security_scopes.scopes:
        if scope not in token_data.scopes:

            

Reported by Pylint.

              

@app.get("/status/")
async def read_system_status(current_user: User = Depends(get_current_user)):
    return {"status": "ok"}

            

Reported by Pylint.

              from datetime import datetime, timedelta
from typing import List, Optional

from fastapi import Depends, FastAPI, HTTPException, Security, status
from fastapi.security import (
    OAuth2PasswordBearer,
    OAuth2PasswordRequestForm,
    SecurityScopes,
)

            

Reported by Pylint.

                  generate_operation_id_for_path,
    get_model_definitions,
)
from pydantic import BaseModel
from pydantic.fields import ModelField, Undefined
from pydantic.schema import (
    field_schema,
    get_flat_models_from_fields,
    get_model_name_map,

            

Reported by Pylint.

                  get_model_definitions,
)
from pydantic import BaseModel
from pydantic.fields import ModelField, Undefined
from pydantic.schema import (
    field_schema,
    get_flat_models_from_fields,
    get_model_name_map,
)

            

Reported by Pylint.

              )
from pydantic import BaseModel
from pydantic.fields import ModelField, Undefined
from pydantic.schema import (
    field_schema,
    get_flat_models_from_fields,
    get_model_name_map,
)
from pydantic.utils import lenient_issubclass

            

Reported by Pylint.

                  get_flat_models_from_fields,
    get_model_name_map,
)
from pydantic.utils import lenient_issubclass
from starlette.responses import JSONResponse
from starlette.routing import BaseRoute
from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY

validation_error_definition = {

            

Reported by Pylint.

                  get_model_name_map,
)
from pydantic.utils import lenient_issubclass
from starlette.responses import JSONResponse
from starlette.routing import BaseRoute
from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY

validation_error_definition = {
    "title": "ValidationError",

            

Reported by Pylint.

              )
from pydantic.utils import lenient_issubclass
from starlette.responses import JSONResponse
from starlette.routing import BaseRoute
from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY

validation_error_definition = {
    "title": "ValidationError",
    "type": "object",

            

Reported by Pylint.

              from pydantic.utils import lenient_issubclass
from starlette.responses import JSONResponse
from starlette.routing import BaseRoute
from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY

validation_error_definition = {
    "title": "ValidationError",
    "type": "object",
    "properties": {

            

Reported by Pylint.

                  return generate_operation_id_for_path(name=route.name, path=path, method=method)


def generate_operation_summary(*, route: routing.APIRoute, method: str) -> str:
    if route.summary:
        return route.summary
    return route.name.replace("_", " ").title()



            

Reported by Pylint.

                                  if isinstance(callback, routing.APIRoute):
                        (
                            cb_path,
                            cb_security_schemes,
                            cb_definitions,
                        ) = get_openapi_path(
                            route=callback, model_name_map=model_name_map
                        )
                        callbacks[callback.name] = {callback.path: cb_path}

            

Reported by Pylint.

                                      (
                            cb_path,
                            cb_security_schemes,
                            cb_definitions,
                        ) = get_openapi_path(
                            route=callback, model_name_map=model_name_map
                        )
                        callbacks[callback.name] = {callback.path: cb_path}
                operation["callbacks"] = callbacks

            

Reported by Pylint.

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


class State(BaseModel):
    app_startup: bool = False
    app_shutdown: bool = False
    router_startup: bool = False

            

Reported by Pylint.

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


class State(BaseModel):
    app_startup: bool = False
    app_shutdown: bool = False
    router_startup: bool = False

            

Reported by Pylint.

              from pydantic import BaseModel


class State(BaseModel):
    app_startup: bool = False
    app_shutdown: bool = False
    router_startup: bool = False
    router_shutdown: bool = False
    sub_router_startup: bool = False

            

Reported by Pylint.

              from pydantic import BaseModel


class State(BaseModel):
    app_startup: bool = False
    app_shutdown: bool = False
    router_startup: bool = False
    router_shutdown: bool = False
    sub_router_startup: bool = False

            

Reported by Pylint.

              

@app.on_event("startup")
def app_startup():
    state.app_startup = True


@app.on_event("shutdown")
def app_shutdown():

            

Reported by Pylint.

              

@app.on_event("shutdown")
def app_shutdown():
    state.app_shutdown = True


router = APIRouter()


            

Reported by Pylint.

              

@router.on_event("startup")
def router_startup():
    state.router_startup = True


@router.on_event("shutdown")
def router_shutdown():

            

Reported by Pylint.

              

@router.on_event("shutdown")
def router_shutdown():
    state.router_shutdown = True


sub_router = APIRouter()


            

Reported by Pylint.

              

@sub_router.on_event("startup")
def sub_router_startup():
    state.sub_router_startup = True


@sub_router.on_event("shutdown")
def sub_router_shutdown():

            

Reported by Pylint.

              

@sub_router.on_event("shutdown")
def sub_router_shutdown():
    state.sub_router_shutdown = True


@sub_router.get("/")
def main():

            

Reported by Pylint.