def init_db(app: FastAPI):
"""
Init database models.
:param app:
:return:
"""
register_tortoise(
app,
db_url=tortoise_config.db_url,
generate_schemas=tortoise_config.generate_schemas,
modules=tortoise_config.modules,
)
def init_web_app(*args, **kwargs) -> Starlette:
logger.info('init starlette')
app = Starlette(
debug=True,
routes=routes,
middleware=middlewares
)
register_tortoise(
app,
config=TORTOISE_CONFIG,
generate_schemas=True
)
logger.info('starlette application inited')
return app
def create_app():
register_tortoise(
app,
db_url='postgres://*****:*****@localhost:5432/accounts',
modules={"models": ["accounts.models"]},
generate_schemas=True,
)
# register exception handlers
register_jsonapi_exception_handlers(app)
# register routes
from accounts.resources import users, organizations
users.UsersResource.register_routes(app, '/api')
organizations.OrganizationsResource.register_routes(app, '/api')
return app
async def app_for_httpx():
app = Starlette(
debug=settings.DEBUG,
routes=routes,
middleware=middleware,
exception_handlers=exception_handlers,
)
register_tortoise(
app,
db_url=settings.DB_URL,
modules={"models": ["models"]},
generate_schemas=settings.GENERATE_SCHEMAS,
)
async with LifespanManager(app):
yield app
def create_app():
register_tortoise(
app,
db_url='sqlite://:memory:',
modules={"models": ["accounts.models"]},
generate_schemas=True,
)
# register exception handlers
register_jsonapi_exception_handlers(app)
# register routes
from accounts.resources import users, organizations, teams
users.UsersResource.register_routes(app, '/api')
organizations.OrganizationsResource.register_routes(app, '/api')
teams.TeamsResource.register_routes(app, '/api')
teams.TeamUsersResource.register_routes(app)
return app
def create_app():
fast_app = FastAPI(debug=settings.DEBUG)
fast_app.mount("/static", StaticFiles(directory="static"), name="static")
fast_app.mount('/api', api_app)
fast_app.mount('/admin', admin_app)
fast_app.mount('/web', web_app)
fast_app.add_middleware(
CORSMiddleware,
allow_origins=['*'],
allow_credentials=True,
allow_methods=['*'],
allow_headers=['*'],
)
fast_app.add_middleware(SentryAsgiMiddleware)
register_tortoise(fast_app, config=settings.TORTOISE_ORM)
init_apps(fast_app, api_app, admin_app, web_app)
return fast_app
async def set_secure_headers(request, call_next):
response = await call_next(request)
secure_headers.starlette(response)
return response
@app.exception_handler(404)
async def not_found(request, exc):
"""
Return an HTTP 404 page.
"""
template = "404.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=404)
@app.exception_handler(500)
async def server_error(request, exc):
"""
Return an HTTP 500 page.
"""
template = "500.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=500)
register_tortoise(app,
db_url=DB_URI,
modules={"models": ["accounts.models", "questions.models"]},
generate_schemas=True)
class UserUpdate(User, models.BaseUserUpdate):
pass
class UserDB(User, models.BaseUserDB):
pass
class UserModel(TortoiseBaseUserModel):
pass
user_db = TortoiseUserDatabase(UserDB, UserModel)
app = FastAPI()
register_tortoise(app, db_url=DATABASE_URL, modules={"models": ["test"]})
def on_after_register(user: UserDB, request: Request):
print(f"User {user.id} has registered.")
def on_after_forgot_password(user: UserDB, token: str, request: Request):
print(f"User {user.id} has forgot their password. Reset token: {token}")
jwt_authentication = JWTAuthentication(secret=SECRET,
lifetime_seconds=3600,
tokenUrl="/auth/jwt/login")
fastapi_users = FastAPIUsers(
@app.route("/", methods=["GET"])
async def list_all(_: Request) -> JSONResponse:
users = await Users.all()
return JSONResponse({"users": [str(user) for user in users]})
@app.route("/user", methods=["POST"])
async def add_user(request: Request) -> JSONResponse:
try:
payload = await request.json()
username = payload["username"]
except JSONDecodeError:
raise HTTPException(status_code=HTTP_400_BAD_REQUEST,
detail="cannot parse request body")
except KeyError:
raise HTTPException(status_code=HTTP_400_BAD_REQUEST,
detail="username is required")
user = await Users.create(username=username)
return JSONResponse({"user": str(user)}, status_code=HTTP_201_CREATED)
register_tortoise(app,
db_url="sqlite://:memory:",
modules={"models": ["models"]},
generate_schemas=True)
if __name__ == "__main__":
run(app)
# print(exc.detail)
print(traceback.print_exc())
return GeneralJSONResponse(code=3000, data={}, detail=str(exc))
exception_handlers = {
Exception: handle_general_exception,
ValidationError: handler_params_exception
}
# define application
app_instance = FastAPI(exception_handlers=exception_handlers)
# init postgres connection
register_tortoise(app=app_instance,
db_url=config.PG_DATABASE_URL,
modules={"models": ["handlers.users.models"]})
register_health(app=app_instance)
register_postgres(app=app_instance,
user=config.PG_USER,
host=config.PG_HOST,
port=config.PG_PORT,
db=config.PG_DATABASE,
password=config.PG_PASSWD)
register_redis(app=app_instance,
host=config.REDIS_HOST,
port=config.REDIS_PORT,
db=config.REDIS_DB,
password=config.REDIS_PASSWD)
# add middleware
logging.basicConfig(level=logging.DEBUG)
app = Starlette()
@app.route("/", methods=["GET"])
async def hello(_: Request) -> Response:
return Response({"meta on ubuntu": ["binary pkgs", "source pkgs"]})
@app.route("/source/package/names", methods=["GET"])
async def sources_list_names(request: Request) -> Response:
sources = await Sources.all()
return Response({"names": [str(source) for source in sources]})
@app.route("/binary/package/names", methods=["GET"])
async def sources_list_names(request: Request) -> Response:
binaries = await Binaries.all()
return Response({"names": [str(b) for b in binaries]})
register_tortoise(
app,
db_url="sqlite://data/db/packages.db",
modules={"models": ["models"]},
)
if __name__ == "__main__":
run(app)
from starlette.applications import Starlette
from tortoise.contrib.starlette import register_tortoise
from core import settings, urls
app = Starlette(
debug=settings.DEBUG,
routes=urls.routes,
middleware=settings.middleware,
)
# Config ORM Tortoise
# Thiết lập ORM Tortoise
register_tortoise(
app,
db_url=str(settings.DATABASE_URL),
modules={"models": settings.models},
generate_schemas=True # for dev
)
from starlette.applications import Starlette from tortoise.contrib.starlette import register_tortoise import settings from urls import routes from utils import register_pipeline app = Starlette(routes=routes, **settings.APP_CONFIG) register_tortoise(app, config=settings.DATABASE_CONFIG, generate_schemas=True) queue = register_pipeline(app, services=settings.MAIN_PIPELINE) app.state.queue = queue
from tortoise.contrib.starlette import register_tortoise
class User(models.BaseUser):
pass
class UserCreate(User, models.BaseUserCreate):
pass
class UserUpdate(User, models.BaseUserUpdate):
pass
class UserDB(User, models.BaseUserDB):
pass
DATABASE_URL = "sqlite://./test.db"
class UserModel(TortoiseBaseUserModel):
pass
user_db = TortoiseUserDatabase(UserDB, UserModel)
app = FastAPI()
register_tortoise(app, modules={"models": ["path_to_your_package"]})
from fastapi import FastAPI from src.routers import router from src.conf.conf import fastapi_users from src.conf.database import DB_CONFIG from tortoise.contrib.starlette import register_tortoise app = FastAPI() app.include_router(fastapi_users.router, prefix="/api/users", tags=["users"]) app.include_router(router) register_tortoise(app, config=DB_CONFIG, generate_schemas=True)
"http://*****:*****@app.get("/")
async def root(request: Request):
return templates.TemplateResponse('index.html', {"request": request, "name": "Bob"})
@app.get("/item/{item_id}")
async def get_item(request: Request, item_id: int):
return {"item": {
"item_id": item_id
}}
res = await request.form()
email = res['email']
password = res['password']
await Users.create(email=email)
return templates.TemplateResponse(template, context)
async def noti(request):
tasks = BackgroundTasks()
tasks.add_task(send_noti_email)
message = {'status': True}
return JSONResponse(message, background=tasks)
routes = [
Route('/', endpoint=homepage),
Route('/registration', endpoint=reg, methods=['POST']),
Route('/noti', endpoint=noti, methods=['POST']),
Mount('/static', StaticFiles(directory='statics'), name='static')
]
app = Starlette(debug=True, routes=routes)
register_tortoise(
app, db_url="mysql://*****:*****@localhost:3306/reg",
modules={"models": ["models"]},
generate_schemas=True
)
if __name__ == "__main__":
uvicorn.run(app, host='0.0.0.0', port=8000)
from starlette.applications import Starlette
from starlette.routing import Mount
from tortoise.contrib.starlette import register_tortoise
from api import settings
from api.endpoints import questions, users
from api.exception_handlers import exception_handlers
from api.middleware import middleware
routes = [
Mount("/questions", routes=questions.routes),
Mount("/users", routes=users.routes),
]
app = Starlette(
debug=settings.DEBUG,
routes=routes,
middleware=middleware,
exception_handlers=exception_handlers,
)
register_tortoise(
app,
db_url=settings.DB_URL,
modules={"models": ["api.models"]},
generate_schemas=settings.GENERATE_SCHEMAS,
)
if __name__ == "__main__":
uvicorn.run(app)
async def set_secure_headers(request, call_next):
response = await call_next(request)
secure_headers.starlette(response)
return response
@app.exception_handler(404)
async def not_found(request, exc):
"""
Return an HTTP 404 page.
"""
template = "404.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=404)
@app.exception_handler(500)
async def server_error(request, exc):
"""
Return an HTTP 500 page.
"""
template = "500.html"
context = {"request": request}
return templates.TemplateResponse(template, context, status_code=500)
register_tortoise(app,
db_url=DB_URI,
modules={"models": ["models"]},
generate_schemas=True)
def _setup_databases(fastapi_server: FastAPI) -> None:
"""
Setups databases used by the server.
"""
register_tortoise(fastapi_server, config=TORTOISE_ORM)
import uvicorn
from starlette.applications import Starlette
from starlette.endpoints import HTTPEndpoint
from starlette.responses import JSONResponse
from tortoise.contrib.starlette import register_tortoise
from db_settings import DB_CONF
from models import Tour, Team
from tour_api.urls import router
app = Starlette(debug=True)
with open('config.json') as config_file:
register_tortoise(app, config=DB_CONF, modules={"models": ["models"]}, generate_schemas=True)
# resta_api initializatibn
router.register_app(app)
@app.route('/')
async def homepage(request):
#tour = Tour()
#tour.name = ""
#await tour.save()
tours = await Tour.all()
#teams = await Team.all()
return JSONResponse({"tours": [ {"name": x.name, "id": x.id} for x in tours] })
]
# Sentry
if SENTRY_URL:
import sentry_sdk
from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
sentry_sdk.init(SENTRY_URL)
middlewares.append(Middleware(SentryAsgiMiddleware))
# Application setup
app: Starlette = Starlette(debug=DEBUG, routes=routes, middleware=middlewares)
# Database setup
logger.info("Setting up database.")
tortoise_config = {
"connections": {"default": DB_URL},
"apps": {
"models": {
"models": ["bnstats.models", "aerich.models"],
"default_connection": "default",
},
},
}
register_tortoise(
app,
tortoise_config,
generate_schemas=True,
)
id = request.path_params["id"]
await Book.get(id=id).delete()
response = RedirectResponse(url="/", status_code=302)
return response
routes = [
Route("/", endpoint=list_all, methods=["GET"], name="list_all"),
Route("/create", endpoint=create, methods=["GET", "POST"], name="create"),
Route("/{id:int}/edit",
endpoint=edit,
methods=["GET", "POST"],
name="edit"),
Route("/{id:int}/delete", endpoint=delete, methods=["GET"], name="delete"),
]
app = Starlette(debug=True, routes=routes)
@app.middleware("http")
async def set_secure_headers(request, call_next):
response = await call_next(request)
secure_headers.starlette(response)
return response
register_tortoise(app,
db_url="sqlite://example_db.sqlite3",
modules={"models": ["models"]},
generate_schemas=True)
from tortoise.contrib.starlette import register_tortoise
from historedge_backend import settings
from historedge_backend.api.event_handlers import on_startup, on_shutdown
from historedge_backend.api.exception_handlers import exception_handlers
from historedge_backend.api.logger import init_logging
from historedge_backend.api.middleware import middleware
from historedge_backend.api.routes import routes
from historedge_backend.settings import DB_URL
app = Starlette(
debug=settings.DEBUG,
routes=routes,
middleware=middleware,
exception_handlers=exception_handlers,
on_startup=on_startup,
on_shutdown=on_shutdown,
)
init_logging()
sleep(30)
register_tortoise(
app,
db_url=DB_URL,
modules={"models": ["historedge_backend.models"]},
generate_schemas=settings.GENERATE_SCHEMAS,
)
if __name__ == "__main__":
uvicorn.run(app)
Middleware(CORSMiddleware,
allow_origins=["*"],
allow_methods=["*"],
allow_headers=["*"]),
Middleware(AuthenticationMiddleware,
backend=JWTAuthenticationBackend(
secret_key=str(SECRET_KEY),
algorithm=JWT_ALGORITHM,
prefix=JWT_PREFIX)), # str(SECRET_KEY) is important
Middleware(SessionMiddleware, secret_key=SECRET_KEY),
Middleware(GZipMiddleware, minimum_size=1000),
Middleware(CustomHeaderMiddleware),
]
routes = [
Mount("/chat", routes=chat_routes),
Mount("/user", routes=user_routes),
Mount("/", routes=main_routes),
]
entry_point = Starlette(debug=DEBUG, routes=routes, middleware=middleware)
tortoise_models = [
"apps.user.models",
]
register_tortoise(entry_point,
db_url=DATABASE_URL,
modules={"models": tortoise_models},
generate_schemas=True)
version = f"{sys.version_info.major}.{sys.version_info.minor}"
app = FastAPI()
if not config.DEBUG:
import sentry_sdk
from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
sentry_sdk.init(config.SENTRY_DSN, environment=config.ENVIRONMENT)
app.add_middleware(
CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"]
)
app.add_middleware(SentryAsgiMiddleware)
app.add_middleware(
TrustedHostMiddleware, allowed_hosts=config.ALLOW_HOST.split(",")
)
app.add_middleware(GZipMiddleware, minimum_size=1000)
for router in routes.routers:
app.include_router(router)
register_tortoise(
app, db_url=config.TORTOISE_DATABASE_URI, modules={"models": ["party_maker_bot.models"]}, generate_schemas=True
)
middleware = [
Middleware(SessionMiddleware, secret_key=SECRET_KEY),
Middleware(AuthenticationMiddleware, backend=SessionAuthBackend()),
Middleware(CSRFProtectMiddleware, csrf_secret=SECRET_KEY),
]
routes = [
Route("/", home, methods=["GET"], name="home"),
Mount("/static", StaticFiles(directory=BASEDIR / "static"), name="static"),
Mount("/auth", routes=auth.routes, name="auth"),
Mount("/connect", routes=connect.routes, name="connect"),
]
app = Starlette(middleware=middleware, routes=routes)
register_tortoise(
app,
db_url=DATABASE_URL,
modules={
"models": [
"example.models.clients",
"example.models.sessions",
"example.models.tokens",
"example.models.users",
],
},
generate_schemas=True,
)
