uvicorn[standard]

pydantic[email]

python-jose[cryptography]

passlib[bcrypt]

from datetime import datetime, time, timedelta

from enum import Enum

import time

from typing import Literal, Union

from uuid import UUID

from fastapi import (

Body,

Depends,

FastAPI,

Query,

Path,

Cookie,

Header,

status,

Form,

File,

UploadFile,

HTTPException,

Request,

BackgroundTasks,

)

from fastapi.encoders import jsonable_encoder

from fastapi.exceptions import RequestValidationError

from fastapi.exception_handlers import (

http_exception_handler,

request_validation_exception_handler,

)

from fastapi.middleware.cors import CORSMiddleware

from fastapi.responses import JSONResponse, PlainTextResponse

from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm

from pydantic import BaseModel, Field, HttpUrl, EmailStr

from passlib.context import CryptContext

from jose import jwt, JWTError

from starlette.exceptions import HTTPException as StarletteHTTPException

from starlette.middleware.base import BaseHTTPMiddleware

from starlette.responses import HTMLResponse

app = FastAPI()

async def get():

return {"message": "hello world"}

async def post():

return {"message": 'hello from the post route'}

async def put():

return {"message": 'hello from the put route'}

async def list_items():

return {"message": 'list items route'} # the ./items url should work too

async def get_items(item_id: int):

return {"item_id": item_id} # the ./items/5 should work, prints 'item_id: 5' other data type won't

from enum import Enum

class FoodEnum(str, Enum):

fruits = 'fruits'

vegetables = 'vegetables'

diary = 'dairy'

async def get_food(food_name: FoodEnum):

return {"food_name": food_name, "message": "i like chocolate milk"}

'''Querying Parameters''' # they are not defined in the get, only in the function. Path parameters are defined in both

fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]

@app.get("/items")

async def list_items(skip: int = 0, limit: int = 10): # variables are only passed in here

return fake_items_db[skip : skip + limit] #localhost:8000/items?skip=2, or localhost:8000/items?limit=1 [skip: skip + limit] is indexing

async def get_item(

# NB: short=no, short=True, short=false will work

async def get_user_item(

return item

class Item(BaseModel): # BaseModel was imported from pydantic. 'from pydantic import BaseModel'

tax: float | None = None

# url stays same 'localhost:8000/items' items are within the class object.

async def create_item(item: Item):

return item_dict

#it can also update request updates to the request body. (i.e): 'localhost:8000/items/food' food is a path parameter, q is a query parameter, Items is a class object.

# if we don't set our query parameters to none 'q:str | None = None' they'll be required.

async def create_item_with_put(item_id: int, item: Item, q: str | None = None):

return result

'''query Parameters string''' # to go to a method definition (the class definition) in vscode, right click the method or press F12, press ALT + F12 for documentation

async def read_items(

return results

async def hidden_query_route(

return {"hidden_query": "Not found"}

async def read_items_validation(

return results

class Item(BaseModel):

tax: float | None = None

async def update_item(item_id: int, item: Item = Body(..., embed=True)): #Body is imported from FastAPI. normally, we'll have to use class __(BaseModel) to set a request body parameter.

results = {"item_id": item_id, "item": item} #Alternatively, we could use 'Body' to set it.

return results

class Image(BaseModel):

url: HttpUrl # HttpUrl is imported from pydantic. the value entered must be a url otherwise it will raise an error

name: str

class Item(BaseModel):

image: list[Image] | None = None

class Offer(BaseModel):

items: list[Item]

async def update_item(item_id: int, item: Item):

results = {"item_id": item_id, "item": item}

return results

async def create_offer(offer: Offer = Body(..., embed=True)):

return offer

async def create_multiple_images(images: list[Image]):

return images

async def create_some_blahs(blahs: dict[int, float]): # 'dict[int, float]' says key and value should be int and float respectively

return blahs

class Item(BaseModel):

# }

async def update_item(

return results

async def read_items(

}

from uuid import uuid4

uuid4()

async def read_items(

}

class Item(BaseModel):

tags: list[str] = []

items = {

}

async def read_item(item_id: Literal["foo", "bar", "baz"]):

return items[item_id]

async def create_item(item: Item):

return item

class UserBase(BaseModel):

username: str

email: EmailStr

full_name: str | None = None

class UserIn(UserBase): # this is typically how to hide passwords.

password: str

class UserOut(UserBase):

pass

async def create_user(user: UserIn):

return user

async def read_item_name(item_id: Literal["foo", "bar", "baz"]): #'from typing import Literal' helps to valate that only our permitted value is used (foo, bar, baz)

return items[item_id]

async def read_items_public_data(item_id: Literal["foo", "bar", "baz"]):

return items[item_id]

class UserBase(BaseModel):

username: str

email: EmailStr

full_name: str | None = None

class UserIn(UserBase):

password: str

class UserOut(UserBase):

pass

class UserInDB(UserBase):

hashed_password: str

def fake_password_hasher(raw_password: str):

return f"supersecret{raw_password}"

def fake_save_user(user_in: UserIn):

return user_in_db

async def create_user(user_in: UserIn):

user_saved = fake_save_user(user_in)

return user_saved

class BaseItem(BaseModel):

description: str

type: str

class CarItem(BaseItem):

type = "car"

class PlaneItem(BaseItem):

type = "plane"

size: int

items = {

}

async def read_item(item_id: Literal["item1", "item2"]):

return items[item_id]

class ListItem(BaseModel):

name: str

description: str

list_items = [

{"name": "Foo", "description": "There comes my hero"},

{"name": "Red", "description": "It's my aeroplane"},

]

async def read_items():

return items

async def get_arbitrary():

return {"foo": 1, "bar": "2"}

async def create_item(name: str):

return {"name": name}

async def delete_item(pk: str):

print("pk", pk)

return pk

async def read_items_redirect():

return {"hello": "world"}

async def login(username: str = Form(...), password: str = Body(...)): #Forms is imported from FastAPI, fields make our respons body like json, while forms make it like an excel cell.

print("password", password)

return {"username": username}

async def login_json(username: str = Body(...), password: str = Body(...)):

print("password", password)

return {"username": username}

async def create_file(

files: list[bytes] = File(..., description="A file read as bytes") # bytes objects make it such that we can upload a file, 'File' and 'UploadFile' are imported from FastAPI

):

return {"file_sizes": [len(file) for file in files]}

async def create_upload_file(

files: list[UploadFile] = File(..., description="A file read as UploadFile") # 'UploadFile' also makes it possible to upload a file this is better because it can work with multiple file types

): # 'await file.read()' reads the content of the file.

return {"filename": [file.filename for file in files]}

async def main():

return HTMLResponse(content=content)

async def create_file(

}

items = {"foo": "The Foo Wrestlers"}

async def read_item(item_id: str):

return {"item": items[item_id]}

class UnicornException(Exception):

def __init__(self, name: str):

self.name = name

async def unicorn_exception_handler(request: Request, exc: UnicornException): # Request is installed from FastAPI,

)

async def read_unicorns(name: str):

if name == "yolo":

raise UnicornException(name=name)

return {"unicorn_name": name}

async def custom_http_exception_handler(request, exc):

print(f"OMG! An HTTP error!: {repr(exc)}")

return await http_exception_handler(request, exc) # from FastAPI.exception_handler import 'http_exception_handler'

async def validation_exception_handler(request, exc):

print(f"OMG! The client sent invalid data!: {exc}")

return await request_validation_exception_handler(request, exc) # from FastAPI.exception_handler import 'request_validation_exception_handler'

async def read_items(item_id: int):

if item_id == 3:

raise HTTPException(status_code=418, detail="Nope! I don't like 3.")

return {"item_id": item_id}

class Item(BaseModel):

tags: set[str] = set()

class Tags(Enum):

items = "items"

users = "users"

async def create_item(item: Item):

return item

async def read_items():

return [{"name": "Foo", "price": 42}]

async def read_users():

return [{"username": "PhoebeBuffay"}]

async def read_elements():

return [{"item_id": "Foo"}]

class Item(BaseModel):

tags: list[str] = []

items = {

}

async def read_item(item_id: str):

return items.get(item_id)

def update_item(item_id: str, item: Item):

update_item_encoded = jsonable_encoder(item)

items[item_id] = update_item_encoded

return update_item_encoded

def patch_item(item_id: str, item: Item):

return updated_item

async def hello():

return "world"

async def common_parameters(

q: str | None = None, skip: int = 0, limit: int = 100, blah: str = Depends(hello)

):

return {"q": q, "skip": skip, "limit": limit, "hello": blah}

async def read_items(commons: dict = Depends(common_parameters)): # 'Depend' is imported from FastAPI. this is used to link variables to multiple request statements.

return commons

async def read_users(commons: dict = Depends(common_parameters)):

return commons

fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]

class CommonQueryParams:

self.limit = limit

async def read_items(commons: CommonQueryParams = Depends()):

return response

def query_extractor(q: str | None = None):

return q

def query_or_body_extractor(

return last_query

async def try_query(query_or_body: str = Depends(query_or_body_extractor)):

return {"q_or_body": query_or_body}

async def verify_token(x_token: str = Header(...)):

if x_token != "fake-super-secret-token":

raise HTTPException(status_code=400, detail="X-Token header invalid")

async def verify_key(x_key: str = Header(...)):

if x_key != "fake-super-secret-key":

raise HTTPException(status_code=400, detail="X-Key header invalid")

return x_key

async def read_items():

return [{"item": "Foo"}, {"item": "Bar"}]

async def read_users():

return [{"username": "Rick"}, {"username": "Morty"}]

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") # 'from FastAPI.security import OAuth2PasswordBearer' creates a login that is required before status_code == 200 (as a form)

fake_users_db = {

}

def fake_hash_password(password: str):

return f"fakehashed{password}"

class User(BaseModel):

disabled: bool | None = None

class UserInDB(User):

hashed_password: str

def get_user(db, username: str):

if username in db:

user_dict = db[username]

return UserInDB(**user_dict)

def fake_decode_token(token):

return get_user(fake_users_db, token)

async def get_current_user(token: str = Depends(oauth2_scheme)):

return user

async def get_current_active_user(current_user: User = Depends(get_current_user)):

if current_user.disabled:

raise HTTPException(status_code=400, detail="Inactive user")

return current_user

async def login(form_data: OAuth2PasswordRequestForm = Depends()): # 'from FastAPI.security import OAuth2PasswordRequestForm' this retrieves the data entered into form

return {"access_token": user.username, "token_type": "bearer"}

async def get_me(current_user: User = Depends(get_current_active_user)):

return current_user

async def read_items(token: str = Depends(oauth2_scheme)):

return {"token": token}

'''Security, OAuth2 Beearer and JWT''' #jwt is json web token, it is a hash identifier.

from passlib.context import CryptContext # Importation.

from jose import jwt, JWTError