app = FastAPI()
+
@app.get("/")
async def root():
return {"message": "Hello World"}
app = FastAPI()
+
@app.get("/items/{item_id}")
async def read_item(item_id):
return {"item_id": item_id}
app = FastAPI()
+
@app.get("/items/{item_id}")
async def read_item(item_id: int):
return {"item_id": item_id}
-from fastapi import FastAPI
from uuid import UUID
+from fastapi import FastAPI
+
app = FastAPI()
+
@app.get("/items/{item_id}")
async def read_item(item_id: UUID):
return {"item_id": item_id}
app = FastAPI()
-fake_items_db = [
- {"item_name": "Foo"},
- {"item_name": "Bar"},
- {"item_name": "Baz"},
-]
+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):
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:
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"})
+ item.update(
+ {"description": "This is an amazing item that has a long description"}
+ )
return item
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):
+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"})
+ item.update(
+ {"description": "This is an amazing item that has a long description"}
+ )
return item
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):
+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"})
+ item.update(
+ {"description": "This is an amazing item that has a long description"}
+ )
return item
from fastapi import FastAPI
from pydantic import BaseModel
+
class Item(BaseModel):
name: str
description: str = None
app = FastAPI()
+
@app.post("/items/")
async def create_item(item: Item):
return item
from fastapi import FastAPI
from pydantic import BaseModel
+
class Item(BaseModel):
name: str
description: str = None
app = FastAPI()
+
@app.post("/items/")
async def create_item(item: Item):
item_dict = item.dict()
from fastapi import FastAPI
from pydantic import BaseModel
+
class Item(BaseModel):
name: str
description: str = None
app = FastAPI()
+
@app.put("/items/{item_id}")
async def create_item(item_id: int, item: Item):
return {"item_id": item_id, **item.dict()}
from fastapi import FastAPI
from pydantic import BaseModel
+
class Item(BaseModel):
name: str
description: str = 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()}
@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, regex="^fixedquery$")
+):
results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
if q:
results.update({"q": q})
-from fastapi import FastAPI, Query, Path
+from fastapi import FastAPI, Path, Query
app = FastAPI()
-from fastapi import FastAPI, Query, Path
+from fastapi import FastAPI, 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"),
+ q: str, item_id: int = Path(..., title="The ID of the item to get")
):
results = {"item_id": item_id}
if q:
-from fastapi import FastAPI, Query, Path
+from fastapi import FastAPI, 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,
+ *, item_id: int = Path(..., title="The ID of the item to get"), q: str
):
results = {"item_id": item_id}
if q:
-from fastapi import FastAPI, Query, Path
+from fastapi import FastAPI, 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,
+ *, item_id: int = Path(..., title="The ID of the item to get", ge=1), q: str
):
results = {"item_id": item_id}
if q:
-from fastapi import FastAPI, Query, Path
+from fastapi import FastAPI, Path
app = FastAPI()
-from fastapi import FastAPI, Query, Path
+from fastapi import FastAPI, Path, Query
app = FastAPI()
-from fastapi import FastAPI, Query, Path
+from fastapi import FastAPI, Path
from pydantic import BaseModel
app = FastAPI()
-from fastapi import FastAPI, Query, Path
+from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
@app.put("/items/{item_id}")
-async def update_item(
- *,
- item_id: int,
- item: Item,
- user: User,
-):
+async def update_item(*, item_id: int, item: Item, user: User):
results = {"item_id": item_id, "item": item, "user": user}
return results
-from fastapi import FastAPI, Query, Path, Body
+from fastapi import Body, FastAPI
from pydantic import BaseModel
app = FastAPI()
@app.put("/items/{item_id}")
async def update_item(
- *,
- item_id: int,
- item: Item,
- user: User,
- access_token: str = Body(...),
+ *, item_id: int, item: Item, user: User, access_token: str = Body(...)
):
- results = {"item_id": item_id, "item": item, "user": user, "access_token": access_token}
+ results = {
+ "item_id": item_id,
+ "item": item,
+ "user": user,
+ "access_token": access_token,
+ }
return results
-from fastapi import FastAPI, Query, Path, Body
+from fastapi import Body, FastAPI
from pydantic import BaseModel
app = FastAPI()
access_token: str = Body(...),
q: str = None,
):
- results = {"item_id": item_id, "item": item, "user": user, "access_token": access_token}
+ results = {
+ "item_id": item_id,
+ "item": item,
+ "user": user,
+ "access_token": access_token,
+ }
if q:
results.update({"q": q})
return results
-from fastapi import FastAPI, Query, Path, Body
+from fastapi import Body, FastAPI
from pydantic import BaseModel
app = FastAPI()
@app.put("/items/{item_id}")
-async def update_item(
- *,
- item_id: int,
- item: Item = Body(..., embed=True),
-):
+async def update_item(*, item_id: int, item: Item = Body(..., embed=True)):
results = {"item_id": item_id, "item": item}
return results
-from fastapi import FastAPI, Query, Path, Body
+from fastapi import Body, FastAPI
from pydantic import BaseModel, Schema
app = FastAPI()
@app.put("/items/{item_id}")
-async def update_item(
- *,
- item_id: int,
- item: Item = Body(..., embed=True),
-):
+async def update_item(*, item_id: int, item: Item = Body(..., embed=True)):
results = {"item_id": item_id, "item": item}
return results
-from fastapi import FastAPI, Query, Path, Body
+from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
@app.put("/items/{item_id}")
-async def update_item(
- *,
- item_id: int,
- item: Item,
-):
+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 typing import List
+from fastapi import FastAPI
+from pydantic import BaseModel
+
app = FastAPI()
@app.put("/items/{item_id}")
-async def update_item(
- *,
- item_id: int,
- item: Item,
-):
+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 typing import Set
+from fastapi import FastAPI
+from pydantic import BaseModel
+
app = FastAPI()
@app.put("/items/{item_id}")
-async def update_item(
- *,
- item_id: int,
- item: Item,
-):
+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 typing import Set
+from fastapi import FastAPI
+from pydantic import BaseModel
+
app = FastAPI()
@app.put("/items/{item_id}")
-async def update_item(
- *,
- item_id: int,
- item: Item,
-):
+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 typing import Set
+
+from fastapi import FastAPI
from pydantic import BaseModel
from pydantic.types import UrlStr
-from typing import Set
app = FastAPI()
@app.put("/items/{item_id}")
-async def update_item(
- *,
- item_id: int,
- item: Item,
-):
+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 typing import List, Set
+
+from fastapi import FastAPI
from pydantic import BaseModel
from pydantic.types import UrlStr
-from typing import Set, List
app = FastAPI()
@app.put("/items/{item_id}")
-async def update_item(
- *,
- item_id: int,
- item: Item,
-):
+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 typing import List, Set
+
+from fastapi import FastAPI
from pydantic import BaseModel
from pydantic.types import UrlStr
-from typing import Set, List
app = FastAPI()
-from fastapi import Body, FastAPI, Path, Query
+from typing import List
+
+from fastapi import FastAPI
from pydantic import BaseModel
from pydantic.types import UrlStr
-from typing import Set, List
app = FastAPI()
-from fastapi import FastAPI, Cookie
-from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set, List
+from fastapi import Cookie, FastAPI
app = FastAPI()
from fastapi import FastAPI, Header
-from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set, List
app = FastAPI()
from fastapi import FastAPI, Header
-from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set, List
app = FastAPI()
-from fastapi import Body, FastAPI, Path, Query
+from typing import Set
+
+from fastapi import FastAPI
from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set, List
app = FastAPI()
-from fastapi import Body, FastAPI, Path, Query
+from fastapi import FastAPI
from pydantic import BaseModel
from pydantic.types import EmailStr
-from typing import Set, List
app = FastAPI()
password: str
email: EmailStr
full_name: str = None
-
# Don't do this in production!
-from fastapi import Body, FastAPI, Path, Query
+from fastapi import FastAPI
from pydantic import BaseModel
from pydantic.types import EmailStr
-from typing import Set, List
app = FastAPI()
-from fastapi import Body, FastAPI, Path, Query
+from fastapi import FastAPI
from pydantic import BaseModel
from pydantic.types import EmailStr
-from typing import Set, List
-from uuid import UUID, uuid4
app = FastAPI()
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)
-from fastapi import Body, FastAPI, Path, Query
+from fastapi import FastAPI
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
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)
-from fastapi import Body, FastAPI, Path, Query, Form
-from pydantic import BaseModel
-from pydantic.types import EmailStr
-from typing import Set, List
+from fastapi import FastAPI, Form
app = FastAPI()
-from fastapi import Body, FastAPI, Path, Query, File
-from pydantic import BaseModel
-from pydantic.types import EmailStr
-from typing import Set, List
+from fastapi import FastAPI, File
app = FastAPI()
-from fastapi import Body, FastAPI, Path, Query, File, Form
-from pydantic import BaseModel
-from pydantic.types import EmailStr
-from typing import Set, List
+from fastapi import FastAPI, File, Form
app = FastAPI()
-from fastapi import Body, FastAPI, Path, Query
-from starlette.status import HTTP_201_CREATED
+from typing import Set
+
+from fastapi import FastAPI
from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set, List
+from starlette.status import HTTP_201_CREATED
app = FastAPI()
-from fastapi import Body, FastAPI, Path, Query
-from starlette.status import HTTP_201_CREATED
+from typing import Set
+
+from fastapi import FastAPI
from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set, List
app = FastAPI()
-from fastapi import Body, FastAPI, Path, Query
-from starlette.status import HTTP_201_CREATED
+from typing import Set
+
+from fastapi import FastAPI
from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set, List
app = FastAPI()
-from fastapi import Body, FastAPI, Path, Query
-from starlette.status import HTTP_201_CREATED
+from typing import Set
+
+from fastapi import FastAPI
from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set, List
app = FastAPI()
-from fastapi import Body, FastAPI, Path, Query
-from starlette.status import HTTP_201_CREATED
+from typing import Set
+
+from fastapi import FastAPI
from pydantic import BaseModel
-from pydantic.types import UrlStr
-from typing import Set, List
app = FastAPI()
tags: Set[str] = []
-@app.post("/items/", response_model=Item, summary="Create an item", response_description="The created item")
+@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:
-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 fastapi import FastAPI
app = FastAPI()
-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 fastapi import FastAPI
app = FastAPI()
-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 fastapi import FastAPI
app = FastAPI()
-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 fastapi import FastAPI
from starlette.responses import UJSONResponse
app = FastAPI()
-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 fastapi import FastAPI
from starlette.responses import HTMLResponse
app = FastAPI()
-from typing import List, Set
-
-from fastapi import Body, FastAPI, Path, Query, Depends
+from fastapi import Depends, FastAPI
from pydantic import BaseModel
-from pydantic.types import UrlStr
-from starlette.status import HTTP_201_CREATED
-from starlette.responses import HTMLResponse
app = FastAPI()
response = {}
if commons.q:
response.update({"q": commons.q})
- items = fake_items_db[commons.skip:commons.limit]
+ items = fake_items_db[commons.skip : commons.limit]
response.update({"items": items})
return response
-from typing import List, Set
+from typing import List
-from fastapi import Body, FastAPI, Path, Query, Depends, Cookie
+from fastapi import Cookie, Depends, FastAPI
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("/interests/")
-async def read_interests(tracked_interests: InterestsTracker = Depends(get_tracked_interests)):
+async def read_interests(
+ tracked_interests: InterestsTracker = Depends(get_tracked_interests)
+):
response = {"interests": tracked_interests.interests}
return response
-from typing import List, Set
+from random import choice
+from typing import List
-from fastapi import Body, FastAPI, Path, Query, Depends, Cookie
+from fastapi import Cookie, Depends, FastAPI
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()
"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]
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 self.tracker.interests:
return choice(self.tracker.interests)
- return choice(["sports", "movies", "food", "shows", "gaming", "virtual reality"])
+ return choice(
+ ["sports", "movies", "food", "shows", "gaming", "virtual reality"]
+ )
@app.get("/suggested-category")
-from typing import List, Set
+from fastapi import FastAPI
-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 import Boolean, Column, Integer, String, create_engine
from sqlalchemy.ext.declarative import declarative_base, declared_attr
-
+from sqlalchemy.orm import scoped_session, sessionmaker
# SQLAlchemy specific code, as with any other app
# 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 get_user(username, db_session):
return db_session.query(User).filter(User.id == username).first()
+
# FastAPI specific code
app = FastAPI()
-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 typing import Optional
+from fastapi import FastAPI
from pydantic import BaseModel
from app.models.config import USERPROFILE_DOC_TYPE
-from app.models.role import RoleEnum
+from couchbase import LOCKMODE_WAIT
from couchbase.bucket import Bucket
from couchbase.cluster import Cluster, PasswordAuthenticator
-from couchbase import LOCKMODE_WAIT
def get_bucket():
projects / thirdparty / fastapi / fastapi.git / commitdiff
