+++ /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}
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, short: bool = False):
- item = {"item_id": item_id}
+async def read_item(item_id: str, q: str = None):
if q:
- item.update({"q": q})
- if not short:
- item.update({"description": "This is an amazing item that has a long description"})
- return item
+ return {"item_id": item_id, "q": q}
+ return {"item_id": item_id}
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}
+@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:
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}
+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:
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):
+@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
@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
+ return item
app = FastAPI()
-@app.put("/items/{item_id}")
-async def create_item(item_id: int, item: Item):
- return {"item_id": item_id, **item.dict()}
+@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
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
+async def create_item(item_id: int, item: Item):
+ return {"item_id": item_id, **item.dict()}
-from fastapi import FastAPI, Query
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+class Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
-app = FastAPI()
+app = FastAPI()
-@app.get("/items/")
-async def read_items(q: str = Query(None, max_length=50)):
- results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+@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:
- results.update({"q": q})
- return results
+ result.update({"q": q})
+ return result
@app.get("/items/")
-async def read_items(q: str = Query(None, min_length=3, max_length=50)):
+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})
@app.get("/items/")
-async def read_items(q: str = Query(None, min_length=3, max_length=50, regex="^fixedquery$")):
+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})
@app.get("/items/")
-async def read_items(
- q: str = Query(
- None, title="Query string", min_length=3, max_length=50, regex="^fixedquery$"
- )
-):
+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})
@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$",
+ None, title="Query string", min_length=3, max_length=50, regex="^fixedquery$"
)
):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
+++ /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(
- ...,
- 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
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,
@app.get("/items/")
async def read_items(
q: str = Query(
- None,
+ "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$",
- deprecated=True,
)
):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
-from fastapi import FastAPI, Query, Path
+from fastapi import FastAPI, Query
app = FastAPI()
-@app.get("/items/{item_id}")
+@app.get("/items/")
async def read_items(
- item_id: int = Path(..., title="The ID of the item to get"),
- q: str = Query(None, alias="item-query"),
+ 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 = {"item_id": item_id}
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
return results
-from fastapi import FastAPI, Query, Path
+from fastapi import FastAPI, Query
app = FastAPI()
-@app.get("/items/{item_id}")
+@app.get("/items/")
async def read_items(
- q: str,
- item_id: int = Path(..., title="The ID of the item to get"),
+ 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 = {"item_id": item_id}
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
return results
-from fastapi import FastAPI, Query, Path
+from fastapi import FastAPI, Query
app = FastAPI()
-@app.get("/items/{item_id}")
+@app.get("/items/")
async def read_items(
- *,
- item_id: int = Path(..., title="The ID of the item to get"),
- q: str,
+ 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 = {"item_id": item_id}
+ results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
return results
@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,
+ 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:
@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,
+ item_id: int = Path(..., title="The ID of the item to get"),
):
results = {"item_id": item_id}
if q:
@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),
+ item_id: int = Path(..., title="The ID of the item to get"),
q: str,
- size: float = Query(..., gt=0, lt=10.5)
):
results = {"item_id": item_id}
if q:
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(
+@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),
+ item_id: int = Path(..., title="The ID of the item to get", ge=1),
q: str,
- item: Item = None,
):
results = {"item_id": item_id}
if q:
results.update({"q": q})
- if item:
- results.update({"item": item})
return results
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(
+@app.get("/items/{item_id}")
+async def read_items(
*,
- item_id: int,
- item: Item,
- user: User,
+ item_id: int = Path(..., title="The ID of the item to get", gt=0, le=1000),
+ q: str,
):
- results = {"item_id": item_id, "item": item, "user": user}
+ results = {"item_id": item_id}
+ if q:
+ results.update({"q": q})
return results
-from fastapi import FastAPI, Query, Path, Body
-from pydantic import BaseModel
+from fastapi import FastAPI, Query, Path
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(
+@app.get("/items/{item_id}")
+async def read_items(
*,
- item_id: int,
- item: Item,
- user: User,
- access_token: str = Body(...),
+ 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, "item": item, "user": user, "access_token": access_token}
+ results = {"item_id": item_id}
+ if q:
+ results.update({"q": q})
return results
-from fastapi import FastAPI, Query, Path, Body
+from fastapi import FastAPI, Query, Path
from pydantic import BaseModel
app = FastAPI()
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,
+ 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, "item": item, "user": user, "access_token": access_token}
+ results = {"item_id": item_id}
if q:
results.update({"q": q})
+ if item:
+ results.update({"item": item})
return results
-from fastapi import FastAPI, Query, Path, Body
+from fastapi import FastAPI, Query, Path
from pydantic import BaseModel
app = FastAPI()
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 = Body(..., embed=True),
+ item: Item,
+ user: User,
):
- results = {"item_id": item_id, "item": item}
+ results = {"item_id": item_id, "item": item, "user": user}
return results
from fastapi import FastAPI, Query, Path, Body
-from pydantic import BaseModel, Schema
+from pydantic import BaseModel
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")
+ 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 = Body(..., embed=True),
+ item: Item,
+ user: User,
+ access_token: str = Body(...),
):
- results = {"item_id": item_id, "item": item}
+ results = {"item_id": item_id, "item": item, "user": user, "access_token": access_token}
return results
description: str = None
price: float
tax: float = None
- tags: list = []
+
+
+class User(BaseModel):
+ username: str
+ full_name: str = None
@app.put("/items/{item_id}")
*,
item_id: int,
item: Item,
+ user: User,
+ access_token: str = Body(...),
+ q: str = None,
):
- results = {"item_id": item_id, "item": item}
+ results = {"item_id": item_id, "item": item, "user": user, "access_token": access_token}
+ if q:
+ results.update({"q": q})
return results
-from fastapi import Body, FastAPI, Path, Query
+from fastapi import FastAPI, Query, Path, Body
from pydantic import BaseModel
-from typing import List
app = FastAPI()
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,
+ item: Item = Body(..., embed=True),
):
results = {"item_id": item_id, "item": item}
return results
-from fastapi import Body, FastAPI, Path, Query
-from pydantic import BaseModel
-from typing import Set
+from fastapi import FastAPI, Query, Path, Body
+from pydantic import BaseModel, Schema
app = FastAPI()
class Item(BaseModel):
name: str
- description: str = None
- price: float
+ 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
- tags: Set[str] = []
@app.put("/items/{item_id}")
async def update_item(
*,
item_id: int,
- item: Item,
+ item: Item = Body(..., embed=True),
):
results = {"item_id": item_id, "item": item}
return results
-from fastapi import Body, FastAPI, Path, Query
+from fastapi import FastAPI, Query, Path, Body
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
+ tags: list = []
@app.put("/items/{item_id}")
from fastapi import Body, FastAPI, Path, Query
from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set
+from typing import 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: Image = None
+ tags: List[str] = []
@app.put("/items/{item_id}")
from fastapi import Body, FastAPI, Path, Query
from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set, List
+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: List[Image] = None
@app.put("/items/{item_id}")
from fastapi import Body, FastAPI, Path, Query
from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set, List
+from typing import Set
app = FastAPI()
class Image(BaseModel):
- url: UrlStr
+ url: str
name: str
price: float
tax: float = None
tags: Set[str] = []
- image: List[Image] = None
+ image: 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
+@app.put("/items/{item_id}")
+async def update_item(
+ *,
+ item_id: int,
+ item: Item,
+):
+ results = {"item_id": item_id, "item": item}
+ return results
from fastapi import Body, FastAPI, Path, Query
from pydantic import BaseModel
from pydantic.types import UrlStr
-from typing import Set, List
+from typing import Set
app = FastAPI()
name: str
-@app.post("/images/multiple/")
-async def create_multiple_images(*, images: List[Image]):
- return images
+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
-from fastapi import FastAPI, Cookie
+from fastapi import Body, FastAPI, Path, Query
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}
+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
-from fastapi import FastAPI, Header
+from fastapi import Body, FastAPI, Path, Query
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}
+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
-from fastapi import FastAPI, Header
+from fastapi import Body, FastAPI, Path, Query
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}
+class Image(BaseModel):
+ url: UrlStr
+ name: str
+
+
+@app.post("/images/multiple/")
+async def create_multiple_images(*, images: List[Image]):
+ return images
-from fastapi import Body, FastAPI, Path, Query
+from fastapi import FastAPI, Cookie
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
+@app.get("/items/")
+async def read_items(*, ads_id: str = Cookie(None)):
+ return {"ads_id": ads_id}
-from fastapi import Body, FastAPI, Path, Query
+from fastapi import FastAPI, Header
from pydantic import BaseModel
-from pydantic.types import EmailStr
+from pydantic.types import UrlStr
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
+@app.get("/items/")
+async def read_items(*, accept_encoding: str = Header(None)):
+ return {"Accept-Encoding": accept_encoding}
-from fastapi import Body, FastAPI, Path, Query
+from fastapi import FastAPI, Header
from pydantic import BaseModel
-from pydantic.types import EmailStr
+from pydantic.types import UrlStr
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
+@app.get("/items/")
+async def read_items(*, strange_header: str = Header(None, convert_underscores=False)):
+ return {"strange_header": strange_header}
from fastapi import Body, FastAPI, Path, Query
from pydantic import BaseModel
-from pydantic.types import EmailStr
+from pydantic.types import UrlStr
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 Item(BaseModel):
+ name: str
+ description: str = None
+ price: float
+ tax: float = None
+ tags: Set[str] = []
-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
+@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 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 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
from fastapi import Body, FastAPI, Path, Query
-from starlette.status import HTTP_201_CREATED
from pydantic import BaseModel
-from pydantic.types import UrlStr
+from pydantic.types import EmailStr
from typing import Set, List
app = FastAPI()
-class Item(BaseModel):
- name: str
- description: str = None
- price: float
- tax: float = None
- tags: Set[str] = []
+class UserIn(BaseModel):
+ username: str
+ password: str
+ email: EmailStr
+ full_name: str = None
-@app.post("/items/", response_model=Item, status_code=HTTP_201_CREATED)
-async def create_item(*, item: Item):
- return item
+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
from fastapi import Body, FastAPI, Path, Query
-from starlette.status import HTTP_201_CREATED
from pydantic import BaseModel
-from pydantic.types import UrlStr
+from pydantic.types import EmailStr
from typing import Set, List
+from uuid import UUID, uuid4
app = FastAPI()
-class Item(BaseModel):
- name: str
- description: str = None
- price: float
- tax: float = None
- tags: Set[str] = []
+class UserIn(BaseModel):
+ username: str
+ password: str
+ email: EmailStr
+ full_name: str = None
-@app.post("/items/", response_model=Item, tags=["items"])
-async def create_item(*, item: Item):
- return item
+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
from fastapi import Body, FastAPI, Path, Query
-from starlette.status import HTTP_201_CREATED
from pydantic import BaseModel
-from pydantic.types import UrlStr
+from pydantic.types import EmailStr
from typing import Set, List
app = FastAPI()
+class UserBase(BaseModel):
+ username: str
+ email: EmailStr
+ full_name: str = None
-class Item(BaseModel):
- name: str
- description: str = None
- price: float
- tax: float = None
- tags: Set[str] = []
+class UserIn(UserBase):
+ password: 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
+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
-from fastapi import Body, FastAPI, Path, Query
-from starlette.status import HTTP_201_CREATED
+from fastapi import Body, FastAPI, Path, Query, Form
from pydantic import BaseModel
-from pydantic.types import UrlStr
+from pydantic.types import EmailStr
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
+@app.post("/login/")
+async def login(*, username: str = Form(...), password: str = Form(...)):
+ return {"username": username}
-from fastapi import Body, FastAPI, Path, Query
-from starlette.status import HTTP_201_CREATED
+from fastapi import Body, FastAPI, Path, Query, File
from pydantic import BaseModel
-from pydantic.types import UrlStr
+from pydantic.types import EmailStr
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
+@app.post("/files/")
+async def create_file(*, file: bytes = File(...)):
+ return {"file_size": len(file)}
-from typing import List, Set
-
-from fastapi import Body, FastAPI, Path, Query
+from fastapi import Body, FastAPI, Path, Query, File, Form
from pydantic import BaseModel
-from pydantic.types import UrlStr
-from starlette.status import HTTP_201_CREATED
+from pydantic.types import EmailStr
+from typing import Set, List
app = FastAPI()
-@app.get("/items/", deprecated=True)
-async def read_items():
- return [{"item_id": "Foo"}]
+@app.post("/files/")
+async def create_file(*, file: bytes = File(...), token: str = Form(...)):
+ return {"file_size": len(file), "token": token}
-from typing import List, Set
-
from fastapi import Body, FastAPI, Path, Query
+from starlette.status import HTTP_201_CREATED
from pydantic import BaseModel
from pydantic.types import UrlStr
-from starlette.status import HTTP_201_CREATED
+from typing import Set, List
app = FastAPI()
-@app.get("/items/", operation_id="some_specific_id_you_define")
-async def read_items():
- return [{"item_id": "Foo"}]
+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
-from typing import List, Set
-
from fastapi import Body, FastAPI, Path, Query
+from starlette.status import HTTP_201_CREATED
from pydantic import BaseModel
from pydantic.types import UrlStr
-from starlette.status import HTTP_201_CREATED
+from typing import Set, List
app = FastAPI()
-@app.get("/items/", include_in_schema=False)
-async def read_items():
- return [{"item_id": "Foo"}]
+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
-from typing import List, Set
-
from fastapi import Body, FastAPI, Path, Query
+from starlette.status import HTTP_201_CREATED
from pydantic import BaseModel
from pydantic.types import UrlStr
-from starlette.status import HTTP_201_CREATED
-from starlette.responses import UJSONResponse
+from typing import Set, List
app = FastAPI()
-@app.get("/items/", content_type=UJSONResponse)
-async def read_items():
- return [{"item_id": "Foo"}]
+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
-from typing import List, Set
-
from fastapi import Body, FastAPI, Path, Query
+from starlette.status import HTTP_201_CREATED
from pydantic import BaseModel
from pydantic.types import UrlStr
-from starlette.status import HTTP_201_CREATED
-from starlette.responses import HTMLResponse
+from typing import Set, List
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>
+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
from typing import List, Set
-from fastapi import Body, FastAPI, Path, Query, Depends, Cookie
+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
-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
+@app.get("/items/", deprecated=True)
+async def read_items():
+ return [{"item_id": "Foo"}]
from typing import List, Set
-from fastapi import Body, FastAPI, Path, Query, Depends, Cookie
+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
-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
+@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, 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
