--- /dev/null
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/")
+async def root():
+ return {"message": "Hello World"}
--- /dev/null
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/items/{item_id}")
+async def read_item(item_id):
+ return {"item_id": item_id}
--- /dev/null
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/items/{item_id}")
+async def read_item(item_id: int):
+ return {"item_id": item_id}
--- /dev/null
+from fastapi import FastAPI
+from uuid import UUID
+
+app = FastAPI()
+
+@app.get("/items/{item_id}")
+async def read_item(item_id: UUID):
+ return {"item_id": item_id}
--- /dev/null
+from fastapi import FastAPI
+
+app = FastAPI()
+
+fake_items_db = [
+ {"item_name": "Foo"},
+ {"item_name": "Bar"},
+ {"item_name": "Baz"},
+]
+
+@app.get("/items/")
+async def read_item(skip: int = 0, limit: int = 100):
+ return fake_items_db[skip:limit]
--- /dev/null
+from fastapi import FastAPI
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/items/{item_id}")
+async def read_item(item_id: str, q: str = None):
+ if q:
+ return {"item_id": item_id, "q": q}
+ return {"item_id": item_id}
--- /dev/null
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/items/{item_id}")
+async def read_item(item_id: str, q: str = None, short: bool = False):
+ item = {"item_id": item_id}
+ if q:
+ item.update({"q": q})
+ if not short:
+ item.update({"description": "This is an amazing item that has a long description"})
+ return item
--- /dev/null
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/users/{user_id}/items/{item_id}")
+async def read_user_item(user_id: int, item_id: str, q: str = None, short: bool = False):
+ item = {"item_id": item_id, "owner_id": user_id}
+ if q:
+ item.update({"q": q})
+ if not short:
+ item.update({"description": "This is an amazing item that has a long description"})
+ return item
--- /dev/null
+from fastapi import FastAPI
+
+app = FastAPI()
+
+@app.get("/users/{user_id}/items/{item_id}")
+async def read_user_item(user_id: int, item_id: str, needy: str, q: str = None, short: bool = False):
+ item = {"item_id": item_id, "owner_id": user_id, "needy": needy}
+ if q:
+ item.update({"q": q})
+ if not short:
+ item.update({"description": "This is an amazing item that has a long description"})
+ return item
--- /dev/null
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+
+
+app = FastAPI()
+
+@app.post("/items/")
+async def create_item(item: Item):
+ return item
--- /dev/null
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+
+
+app = FastAPI()
+
+@app.post("/items/")
+async def create_item(item: Item):
+ item_dict = item.dict()
+ if item.tax:
+ price_with_tax = item.price + item.tax
+ item_dict.update({"price_with_tax": price_with_tax})
+ return item_dict
--- /dev/null
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+
+
+app = FastAPI()
+
+@app.put("/items/{item_id}")
+async def create_item(item_id: int, item: Item):
+ return {"item_id": item_id, **item.dict()}
--- /dev/null
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+
+
+app = FastAPI()
+
+@app.put("/items/{item_id}")
+async def create_item(item_id: int, item: Item, q: str = None):
+ result = {"item_id": item_id, **item.dict()}
+ if q:
+ result.update({"q": q})
+ return result
--- /dev/null
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(q: str = Query(None, max_length=50)):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(q: str = Query(None, min_length=3, max_length=50)):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(q: str = Query(None, min_length=3, max_length=50, regex="^fixedquery$")):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(
+ q: str = Query(
+ None, title="Query string", min_length=3, max_length=50, regex="^fixedquery$"
+ )
+):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(
+ q: str = Query(
+ None,
+ title="Query string",
+ description="Query string for the items to search in the database that have a good match",
+ min_length=3,
+ max_length=50,
+ regex="^fixedquery$",
+ )
+):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(
+ q: str = Query(
+ "fixedquery",
+ alias="item-query",
+ title="Query string",
+ description="Query string for the items to search in the database that have a good match",
+ min_length=3,
+ max_length=50,
+ regex="^fixedquery$",
+ )
+):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(
+ q: str = Query(
+ None,
+ alias="item-query",
+ title="Query string",
+ description="Query string for the items to search in the database that have a good match",
+ min_length=3,
+ max_length=50,
+ regex="^fixedquery$",
+ )
+):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(
+ q: str = Query(
+ ...,
+ alias="item-query",
+ title="Query string",
+ description="Query string for the items to search in the database that have a good match",
+ min_length=3,
+ max_length=50,
+ regex="^fixedquery$",
+ )
+):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(
+ q: str = Query(
+ None,
+ alias="item-query",
+ title="Query string",
+ description="Query string for the items to search in the database that have a good match",
+ min_length=3,
+ max_length=50,
+ regex="^fixedquery$",
+ deprecated=True,
+ )
+):
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path
+
+app = FastAPI()
+
+
+@app.get("/items/{item_id}")
+async def read_items(
+ item_id: int = Path(..., title="The ID of the item to get"),
+ q: str = Query(None, alias="item-query"),
+):
+ results = {"item_id": item_id}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path
+
+app = FastAPI()
+
+
+@app.get("/items/{item_id}")
+async def read_items(
+ q: str,
+ item_id: int = Path(..., title="The ID of the item to get"),
+):
+ results = {"item_id": item_id}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path
+
+app = FastAPI()
+
+
+@app.get("/items/{item_id}")
+async def read_items(
+ *,
+ item_id: int = Path(..., title="The ID of the item to get"),
+ q: str,
+):
+ results = {"item_id": item_id}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path
+
+app = FastAPI()
+
+
+@app.get("/items/{item_id}")
+async def read_items(
+ *,
+ item_id: int = Path(..., title="The ID of the item to get", ge=1),
+ q: str,
+):
+ results = {"item_id": item_id}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path
+
+app = FastAPI()
+
+
+@app.get("/items/{item_id}")
+async def read_items(
+ *,
+ item_id: int = Path(..., title="The ID of the item to get", gt=0, le=1000),
+ q: str,
+):
+ results = {"item_id": item_id}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path
+
+app = FastAPI()
+
+
+@app.get("/items/{item_id}")
+async def read_items(
+ *,
+ item_id: int = Path(..., title="The ID of the item to get", ge=0, le=1000),
+ q: str,
+ size: float = Query(..., gt=0, lt=10.5)
+):
+ results = {"item_id": item_id}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int = Path(..., title="The ID of the item to get", ge=0, le=1000),
+ q: str,
+ item: Item = None,
+):
+ results = {"item_id": item_id}
+ if q:
+ results.update({"q": q})
+ if item:
+ results.update({"item": item})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+
+
+class User(BaseModel):
+ username: str
+ full_name: str = None
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item,
+ user: User,
+):
+ results = {"item_id": item_id, "item": item, "user": user}
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path, Body
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+
+
+class User(BaseModel):
+ username: str
+ full_name: str = None
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item,
+ user: User,
+ access_token: str = Body(...),
+):
+ results = {"item_id": item_id, "item": item, "user": user, "access_token": access_token}
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path, Body
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+
+
+class User(BaseModel):
+ username: str
+ full_name: str = None
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item,
+ user: User,
+ access_token: str = Body(...),
+ q: str = None,
+):
+ results = {"item_id": item_id, "item": item, "user": user, "access_token": access_token}
+ if q:
+ results.update({"q": q})
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path, Body
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item = Body(..., embed=True),
+):
+ results = {"item_id": item_id, "item": item}
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path, Body
+from pydantic import BaseModel, Schema
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = Schema(None, title="The description of the item", max_length=300)
+ price: float = Schema(..., gt=0, description="The price must be greater than zero")
+ tax: float = None
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item = Body(..., embed=True),
+):
+ results = {"item_id": item_id, "item": item}
+ return results
--- /dev/null
+from fastapi import FastAPI, Query, Path, Body
+from pydantic import BaseModel
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: list = []
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item,
+):
+ results = {"item_id": item_id, "item": item}
+ return results
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from typing import List
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: List[str] = []
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item,
+):
+ results = {"item_id": item_id, "item": item}
+ return results
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from typing import Set
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item,
+):
+ results = {"item_id": item_id, "item": item}
+ return results
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from typing import Set
+
+app = FastAPI()
+
+
+class Image(BaseModel):
+ url: str
+ name: str
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
+ image: Image = None
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item,
+):
+ results = {"item_id": item_id, "item": item}
+ return results
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set
+
+app = FastAPI()
+
+
+class Image(BaseModel):
+ url: UrlStr
+ name: str
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
+ image: Image = None
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item,
+):
+ results = {"item_id": item_id, "item": item}
+ return results
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+class Image(BaseModel):
+ url: UrlStr
+ name: str
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
+ image: List[Image] = None
+
+
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item,
+):
+ results = {"item_id": item_id, "item": item}
+ return results
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+class Image(BaseModel):
+ url: UrlStr
+ name: str
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
+ image: List[Image] = None
+
+
+class Offer(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ items: List[Item]
+
+
+@app.post("/offers/")
+async def create_offer(*, offer: Offer):
+ return offer
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+class Image(BaseModel):
+ url: UrlStr
+ name: str
+
+
+@app.post("/images/multiple/")
+async def create_multiple_images(*, images: List[Image]):
+ return images
--- /dev/null
+from fastapi import FastAPI, Cookie
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(*, ads_id: str = Cookie(None)):
+ return {"ads_id": ads_id}
--- /dev/null
+from fastapi import FastAPI, Header
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(*, accept_encoding: str = Header(None)):
+ return {"Accept-Encoding": accept_encoding}
--- /dev/null
+from fastapi import FastAPI, Header
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+@app.get("/items/")
+async def read_items(*, strange_header: str = Header(None, convert_underscores=False)):
+ return {"strange_header": strange_header}
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
+
+
+@app.post("/items/", response_model=Item)
+async def create_item(*, item: Item):
+ return item
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import EmailStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+class UserIn(BaseModel):
+ username: str
+ password: str
+ email: EmailStr
+ full_name: str = None
+
+
+
+# Don't do this in production!
+@app.post("/user/", response_model=UserIn)
+async def create_user(*, user: UserIn):
+ return user
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import EmailStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+class UserIn(BaseModel):
+ username: str
+ password: str
+ email: EmailStr
+ full_name: str = None
+
+
+class UserOut(BaseModel):
+ username: str
+ email: EmailStr
+ full_name: str = None
+
+
+@app.post("/user/", response_model=UserOut)
+async def create_user(*, user: UserIn):
+ return user
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import EmailStr
+from typing import Set, List
+from uuid import UUID, uuid4
+
+app = FastAPI()
+
+
+class UserIn(BaseModel):
+ username: str
+ password: str
+ email: EmailStr
+ full_name: str = None
+
+
+class UserOut(BaseModel):
+ username: str
+ email: EmailStr
+ full_name: str = None
+
+
+class UserInDB(BaseModel):
+ username: str
+ hashed_password: str
+ email: EmailStr
+ full_name: str = None
+
+
+def fake_password_hasher(raw_password: str):
+ return "supersecret" + raw_password
+
+
+def fake_save_user(user_in: UserIn):
+ hashed_password = fake_password_hasher(user_in.password)
+ user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)
+ print("User saved! ..not really")
+ return user_in_db
+
+@app.post("/user/", response_model=UserOut)
+async def create_user(*, user_in: UserIn):
+ user_saved = fake_save_user(user_in)
+ return user_saved
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import EmailStr
+from typing import Set, List
+
+app = FastAPI()
+
+class UserBase(BaseModel):
+ username: str
+ email: EmailStr
+ full_name: str = None
+
+class UserIn(UserBase):
+ password: str
+
+
+class UserOut(UserBase):
+ pass
+
+class UserInDB(UserBase):
+ hashed_password: str
+
+
+def fake_password_hasher(raw_password: str):
+ return "supersecret" + raw_password
+
+
+def fake_save_user(user_in: UserIn):
+ hashed_password = fake_password_hasher(user_in.password)
+ user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)
+ print("User saved! ..not really")
+ return user_in_db
+
+@app.post("/user/", response_model=UserOut)
+async def create_user(*, user_in: UserIn):
+ user_saved = fake_save_user(user_in)
+ return user_saved
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query, Form
+from pydantic import BaseModel
+from pydantic.types import EmailStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+@app.post("/login/")
+async def login(*, username: str = Form(...), password: str = Form(...)):
+ return {"username": username}
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query, File
+from pydantic import BaseModel
+from pydantic.types import EmailStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+@app.post("/files/")
+async def create_file(*, file: bytes = File(...)):
+ return {"file_size": len(file)}
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query, File, Form
+from pydantic import BaseModel
+from pydantic.types import EmailStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+@app.post("/files/")
+async def create_file(*, file: bytes = File(...), token: str = Form(...)):
+ return {"file_size": len(file), "token": token}
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from starlette.status import HTTP_201_CREATED
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
+
+
+@app.post("/items/", response_model=Item, status_code=HTTP_201_CREATED)
+async def create_item(*, item: Item):
+ return item
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from starlette.status import HTTP_201_CREATED
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
+
+
+@app.post("/items/", response_model=Item, tags=["items"])
+async def create_item(*, item: Item):
+ return item
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from starlette.status import HTTP_201_CREATED
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
+
+
+@app.post(
+ "/items/",
+ response_model=Item,
+ summary="Create an item",
+ description="Create an item with all the information, name, description, price, tax and a set of unique tags",
+)
+async def create_item(*, item: Item):
+ return item
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from starlette.status import HTTP_201_CREATED
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
+
+
+@app.post("/items/", response_model=Item, summary="Create an item")
+async def create_item(*, item: Item):
+ """
+ Create an item with all the information:
+
+ * name: each item must have a name
+ * description: a long description
+ * price: required
+ * tax: if the item doesn't have tax, you can omit this
+ * tags: a set of unique tag strings for this item
+ """
+ return item
--- /dev/null
+from fastapi import Body, FastAPI, Path, Query
+from starlette.status import HTTP_201_CREATED
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from typing import Set, List
+
+app = FastAPI()
+
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
+
+
+@app.post("/items/", response_model=Item, summary="Create an item", response_description="The created item")
+async def create_item(*, item: Item):
+ """
+ Create an item with all the information:
+
+ * name: each item must have a name
+ * description: a long description
+ * price: required
+ * tax: if the item doesn't have tax, you can omit this
+ * tags: a set of unique tag strings for this item
+ """
+ return item
--- /dev/null
+from typing import List, Set
+
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from starlette.status import HTTP_201_CREATED
+
+app = FastAPI()
+
+
+@app.get("/items/", deprecated=True)
+async def read_items():
+ return [{"item_id": "Foo"}]
--- /dev/null
+from typing import List, Set
+
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from starlette.status import HTTP_201_CREATED
+
+app = FastAPI()
+
+
+@app.get("/items/", operation_id="some_specific_id_you_define")
+async def read_items():
+ return [{"item_id": "Foo"}]
--- /dev/null
+from typing import List, Set
+
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from starlette.status import HTTP_201_CREATED
+
+app = FastAPI()
+
+
+@app.get("/items/", include_in_schema=False)
+async def read_items():
+ return [{"item_id": "Foo"}]
--- /dev/null
+from typing import List, Set
+
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from starlette.status import HTTP_201_CREATED
+from starlette.responses import UJSONResponse
+
+app = FastAPI()
+
+
+@app.get("/items/", content_type=UJSONResponse)
+async def read_items():
+ return [{"item_id": "Foo"}]
--- /dev/null
+from typing import List, Set
+
+from fastapi import Body, FastAPI, Path, Query
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from starlette.status import HTTP_201_CREATED
+from starlette.responses import HTMLResponse
+
+app = FastAPI()
+
+
+@app.get("/items/", content_type=HTMLResponse)
+async def read_items():
+ return """
+ <html>
+ <head>
+ <title>Some HTML in here</title>
+ </head>
+ <body>
+ <h1>Look ma! HTML!</h1>
+ </body>
+ </html>
+ """
--- /dev/null
+from typing import List, Set
+
+from fastapi import Body, FastAPI, Path, Query, Depends
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from starlette.status import HTTP_201_CREATED
+from starlette.responses import HTMLResponse
+
+app = FastAPI()
+
+
+fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]
+
+
+class CommonQueryParams(BaseModel):
+ q: str = None
+ skip: int = None
+ limit: int = None
+
+
+async def common_parameters(q: str = None, skip: int = 0, limit: int = 100):
+ return CommonQueryParams(q=q, skip=skip, limit=limit)
+
+
+@app.get("/items/")
+async def read_items(commons: CommonQueryParams = Depends(common_parameters)):
+ response = {}
+ if commons.q:
+ response.update({"q": commons.q})
+ items = fake_items_db[commons.skip:commons.limit]
+ response.update({"items": items})
+ return response
--- /dev/null
+from typing import List, Set
+
+from fastapi import Body, FastAPI, Path, Query, Depends, Cookie
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from starlette.status import HTTP_201_CREATED
+from starlette.responses import HTMLResponse
+
+app = FastAPI()
+
+
+class InterestsTracker(BaseModel):
+ track_code: str
+ interests: List[str]
+
+
+fake_tracked_users_db = {
+ "Foo": {"track_code": "Foo", "interests": ["sports", "movies"]},
+ "Bar": {"track_code": "Bar", "interests": ["food", "shows"]},
+ "Baz": {"track_code": "Baz", "interests": ["gaming", "virtual reality"]},
+}
+
+
+async def get_tracked_interests(track_code: str = Cookie(None)):
+ if track_code in fake_tracked_users_db:
+ track_dict = fake_tracked_users_db[track_code]
+ track = InterestsTracker(**track_dict)
+ return track
+ return None
+
+
+@app.get("/interests/")
+async def read_interests(tracked_interests: InterestsTracker = Depends(get_tracked_interests)):
+ response = {"interests": tracked_interests.interests}
+ return response
--- /dev/null
+from typing import List, Set
+
+from fastapi import Body, FastAPI, Path, Query, Depends, Cookie
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from starlette.status import HTTP_201_CREATED
+from starlette.responses import HTMLResponse
+from random import choice
+
+app = FastAPI()
+
+
+class InterestsTracker(BaseModel):
+ track_code: str
+ interests: List[str]
+
+
+fake_tracked_users_db = {
+ "Foo": {"track_code": "Foo", "interests": ["sports", "movies"]},
+ "Bar": {"track_code": "Bar", "interests": ["food", "shows"]},
+ "Baz": {"track_code": "Baz", "interests": ["gaming", "virtual reality"]},
+}
+
+async def get_tracked_interests(track_code: str = Cookie(None)):
+ if track_code in fake_tracked_users_db:
+ track_dict = fake_tracked_users_db[track_code]
+ track = InterestsTracker(**track_dict)
+ return track
+ return None
+
+class ComplexTracker:
+ def __init__(self, tracker: InterestsTracker = Depends(get_tracked_interests)):
+ self.tracker = tracker
+
+ def random_interest(self):
+ """
+ Get a random interest from the tracked ones for the current user.
+ If the user doesn't have tracked interests, return a random one from the ones available.
+ """
+ if self.tracker.interests:
+ return choice(self.tracker.interests)
+ return choice(["sports", "movies", "food", "shows", "gaming", "virtual reality"])
+
+
+@app.get("/suggested-category")
+async def read_suggested_category(tracker: ComplexTracker = Depends(None)):
+ response = {"category": tracker.random_interest()}
+ return response
--- /dev/null
+from typing import List, Set
+
+from fastapi import Body, FastAPI, Path, Query, Depends, Cookie
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from starlette.status import HTTP_201_CREATED
+from starlette.responses import HTMLResponse
+from random import choice
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import scoped_session, sessionmaker
+from sqlalchemy import Column, Integer, DateTime, String, Boolean, ForeignKey
+from sqlalchemy.ext.declarative import declarative_base, declared_attr
+
+
+# SQLAlchemy specific code, as with any other app
+
+
+SQLALCHEMY_DATABASE_URI = "postgresql://user:password@postgresserver/db"
+
+# By creating this a CustomBase class and inheriting from it, your models will have
+# automatic __tablename__ attributes. So you don't have to declare them.
+# So, your models will behave very similarly to, for example, Flask-SQLAlchemy
+
+class CustomBase:
+ # Generate __tablename__ automatically
+ @declared_attr
+ def __tablename__(cls):
+ return cls.__name__.lower()
+
+
+Base = declarative_base(cls=CustomBase)
+
+
+class User(Base):
+ # Own properties
+ id = Column(Integer, primary_key=True, index=True)
+ email = Column(String, unique=True, index=True)
+ hashed_password = Column(String)
+ is_active = Column(Boolean(), default=True)
+
+
+engine = create_engine(SQLALCHEMY_DATABASE_URI, convert_unicode=True)
+db_session = scoped_session(
+ sessionmaker(autocommit=False, autoflush=False, bind=engine)
+)
+
+
+def get_user(username, db_session):
+ return db_session.query(User).filter(User.id == username).first()
+
+# FastAPI specific code
+app = FastAPI()
+
+
+@app.get("/users/{username}")
+def read_user(username: str):
+ user = get_user(username, db_session)
+ return user
--- /dev/null
+from typing import List, Set
+
+from fastapi import Body, FastAPI, Path, Query, Depends, Cookie
+from pydantic import BaseModel
+from pydantic.types import UrlStr
+from starlette.status import HTTP_201_CREATED
+from starlette.responses import HTMLResponse
+from random import choice
+
+from typing import List, Optional, Union
+
+from pydantic import BaseModel
+
+from app.models.config import USERPROFILE_DOC_TYPE
+from app.models.role import RoleEnum
+from couchbase.bucket import Bucket
+from couchbase.cluster import Cluster, PasswordAuthenticator
+from couchbase import LOCKMODE_WAIT
+
+
+def get_bucket():
+ cluster = Cluster("couchbase://couchbasehost:8091")
+ authenticator = PasswordAuthenticator("username", "password")
+ cluster.authenticate(authenticator)
+ bucket: Bucket = cluster.open_bucket("bucket_name", lockmode=LOCKMODE_WAIT)
+ return bucket
+
+
+class User(BaseModel):
+ username: str
+ email: Optional[str] = None
+ full_name: Optional[str] = None
+ disabled: Optional[bool] = None
+
+
+class UserInDB(User):
+ type: str = USERPROFILE_DOC_TYPE
+ hashed_password: str
+
+ class Meta:
+ key: Optional[str] = None
+
+
+def get_user_doc_id(username):
+ return f"userprofile::{username}"
+
+
+def get_user(bucket: Bucket, username: str):
+ doc_id = get_user_doc_id(username)
+ result = bucket.get(doc_id, quiet=True)
+ if not result.value:
+ return None
+ user = UserInDB(**result.value)
+ user.Meta.key = result.key
+ return user
+
+
+# FastAPI specific code
+app = FastAPI()
+
+
+@app.get("/users/{username}")
+def read_user(username: str):
+ bucket = get_bucket()
+ user = get_user(bucket=bucket, username=username)
+ return user
projects / thirdparty / fastapi / fastapi.git / commitdiff
