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, )