from fastapi import FastAPI from fastapi.staticfiles import StaticFiles from src.routers import common, api app = FastAPI() app.mount('/static', StaticFiles(directory='static'), name='static') app.include_router(common.router) app.include_router(api.router) if __name__ == "__main__": import uvicorn uvicorn.run('main:app', reload=True, host='127.0.0.1', port=7340)
import pydantic import uvicorn from fastapi import FastAPI, Request, Response from fastapi.responses import HTMLResponse from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates from aptus import __version__ from aptus.compute import AptusCompute from aptus.palettes import Palette, all_palettes app = FastAPI() HERE = pathlib.Path(__file__).parent app.mount("/static", StaticFiles(directory=HERE / "static"), name="static") templates = Jinja2Templates(directory=HERE / "templates") @app.get("/", response_class=HTMLResponse) async def home(request: Request): context = { "request": request, "palettes": [p.spec() for p in all_palettes], "version": __version__, } return templates.TemplateResponse("mainpage.html", context) def run_in_executor(f): # from https://stackoverflow.com/a/53719009/14343
S3_BUCKET = os.environ['S3_BUCKET'] boto3_session = boto3.Session( aws_access_key_id=os.environ['AWS_ACCESS_KEY_ID'], aws_secret_access_key=os.environ['AWS_SECRET_ACCESS_KEY'], region_name=os.environ['AWS_REGION']) s3 = boto3_session.client('s3') @app.get("/s3/sign") def sign_s3_upload(objectName: str): mime_type, _ = mimetypes.guess_type(objectName) presigned_url = s3.generate_presigned_url( 'put_object', Params={ 'Bucket': S3_BUCKET, 'Key': objectName, 'ContentType': mime_type, 'ACL': 'public-read', }, ExpiresIn=3600, ) return {'signedUrl': presigned_url} app.mount("/", StaticFiles(directory="upload-frontend/build", html=True), name="static")
mgr.init_node_mgr() # create a task simply so we don't hold up the startup asyncio.create_task(gstate.start()) pass @app.on_event("shutdown") # type: ignore async def on_shutdown(): await gstate.shutdown() api.include_router(local.router) api.include_router(bootstrap.router) api.include_router(orch.router) api.include_router(status.router) api.include_router(services.router) api.include_router(nodes.router) # # mounts # these should be the last things to be done, so fastapi is aware of # everything that comes before. # # api calls go here. app.mount("/api", api, name="api") # mounting root "/" must be the last thing, so it does not override "/api". app.mount("/", StaticFiles(directory="./glass/dist/", html=True), name="static")
import toml import subprocess from fastapi import FastAPI, Request, Response, Depends, status from fastapi.openapi.utils import get_openapi from fastapi.responses import HTMLResponse from fastapi.staticfiles import StaticFiles from jinja2 import ( Environment, FileSystemLoader, select_autoescape, ) # PackageLoader global app app = FastAPI() app.mount("/static", StaticFiles(directory="foolfuuka/static"), name="static") def custom_openapi(openapi_prefix: str): if app.openapi_schema: return app.openapi_schema revision = "0.1.0" try: revision = (subprocess.run( ["git", "rev-parse", "--short", "HEAD"], stdout=subprocess.PIPE, ).stdout.decode("utf-8").rstrip()) except Exception: pass openapi_schema = get_openapi( title="Ayase",
from fastapi import FastAPI, Request from fastapi.responses import HTMLResponse from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates app = FastAPI() app.mount("/static", StaticFiles(directory="/app/web/static"), name="static") templates = Jinja2Templates(directory="/app/web/templates") @app.get("/", response_class=HTMLResponse) async def index(request: Request): return templates.TemplateResponse("index.html", {"request": request}) @app.get("/tradingview_widget") async def tradingview_widget(request: Request): return templates.TemplateResponse("tradingview_widget.html", {"request": request})
title="DISBUN Non HASURA API", version="0.14.0", description="API for Disbun", openapi_url="/api/openapi.json", docs_url="/api/docs", redoc_url=None, ) app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"], ) app.include_router(api.router, prefix="/api") app.mount("/", StaticFiles(directory="client/build", html=True), name="build") @app.on_event("startup") async def startup(): await db.open_pool() @app.on_event("shutdown") async def shutdown(): await db.close_pool() if __name__ == "__main__": uvicorn.run(app, host="0.0.0.0", port=8000)
console.log( "Required environment variable IRRGUI_NETWORK_NAME is not defined") exit(1) if not environ.get("IRRGUI_IRR_SERVER"): console.log( "Required environment variable IRRGUI_IRR_SERVER is not defined") exit(1) # Constants WHOIS_ENCODING = "utf-8" app = FastAPI(title="IRR GUI", description="Web UI for IRR object management", version="vDEV") app.mount("/static", StaticFiles(directory="frontend/public/"), name="static") class Query(BaseModel): inverse: Optional[str] types: Optional[str] value: str def whois(server: str, query: str) -> List[dict]: s: socket.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) console.log(f"Connecting to {server}") s.connect((server, 43)) console.log(f"Connected to {server}") try:
else: result.body["details"].append( f"{board_name} had no active sessions to stop.") result.body["result"]["board"]["is_recording"] = False else: result.body["details"].append( f"{board_name} had no active sessions to stop.") result.body["result"]["board"]["is_recording"] = False return result.body # Configuration of auto-docs with static assets, # so that they work without Internet connection: app.mount( "/static", StaticFiles( directory=pathlib.Path(__file__).parent.absolute().joinpath("static")), name="static", ) @app.get("/docs", include_in_schema=False) async def custom_swagger_ui_html(): return get_swagger_ui_html( openapi_url=app.openapi_url, title=app.title + " - REST UI", oauth2_redirect_url=app.swagger_ui_oauth2_redirect_url, swagger_js_url="/static/swagger-ui-bundle.js", swagger_css_url="/static/swagger-ui.css", swagger_favicon_url="/static/favicon.ico", )
from fastapi import FastAPI, Request from fastapi.responses import FileResponse, HTMLResponse from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates from .models import SUBSCRIPTIONS, Subscription from .push import send_notification from .tasks import remind_subscriber app = FastAPI() app.mount("/static", StaticFiles(directory="src/static"), name="static") @app.get("/", response_class=HTMLResponse) async def home_page(request: Request): templates = Jinja2Templates(directory="src/templates") return templates.TemplateResponse("home.jinja2", {"request": request}) @app.get("/sw.js") async def service_worker(): return FileResponse('src/static/sw.js') @app.post("/push/subscription") async def create_subscription(subscription: Subscription): SUBSCRIPTIONS.append(subscription) sample_data = { "title": "Welcome to magicbell.io", "body": "Please confirm your email"
from fastapi import FastAPI from fastapi.staticfiles import StaticFiles from .routes.views_routes import views_router from .routes.user_routes import user_router from .routes.test_routes import test_router from .routes.student_routes import student_router app = FastAPI() app.mount("/static", StaticFiles(directory='src/static'), name="static") app.mount("/data", StaticFiles(directory="data"), name="data") @app.get("/") def root(): return {"message": "The API is working..."} app.include_router(views_router, prefix="/views", tags=["views"]) app.include_router(user_router, prefix="/users", tags=["users"]) app.include_router(test_router, prefix="/tests", tags=["tests"]) app.include_router(student_router, prefix="/students", tags=["students"])
import datetime import logging import shlex import subprocess import toml from expiringdict import ExpiringDict from fastapi import FastAPI, Request from fastapi.responses import HTMLResponse, PlainTextResponse from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates logger = logging.getLogger("uvicorn.dashboard") app = FastAPI() app.mount("/static", StaticFiles(directory="static"), name="static") app.mount("/dashboard/static", StaticFiles(directory="static"), name="static") conf = toml.load("./config.toml") template = Jinja2Templates("./template/") logger.info("Config: %s", conf) class Batch: """Batch Jobs and its Cache""" cache = ExpiringDict( max_len=100, max_age_seconds=datetime.timedelta(minutes=30).seconds) @classmethod def get(cls, name: str):
from fastapi import FastAPI, HTTPException, Request, File, UploadFile from fastapi.responses import HTMLResponse, RedirectResponse from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates from pydantic import BaseModel from redis import Redis from rq import Queue import aiofiles import tempfile from os import path, chmod import random from starlette.status import HTTP_302_FOUND from worker import runTask app = FastAPI() app.mount("/static", StaticFiles(directory="static"), name="static") app.mount("/img", StaticFiles(directory="/tmp/img"), name="img") templates = Jinja2Templates(directory="templates") client = Redis(host='localhost', port=6379) q = Queue('my_queue', connection=client) @app.get('/') def hello(request: Request): return templates.TemplateResponse("welcome.html", {"request": request}) @app.get('/queueSize') def queueSize(): """Test endpoint"""
def list_to_class(_list): new_list = [] for i in _list[0]: new_list.append(i) new_list_class = _Note(importance=new_list[0], cls=new_list[1], denomination=new_list[2], question=new_list[3], answer=new_list[4]) return new_list_class # Route app.mount("/static", StaticFiles(directory="templates"), name="static") templates = Jinja2Templates(directory="templates") @app.get("/add_note/", response_class=HTMLResponse) async def add_note(request: Request): return templates.TemplateResponse("form.html", {"request": request}) @app.get("/", response_class=HTMLResponse) async def view_notes(request: Request): return templates.TemplateResponse("main.html", {"request": request}) @app.get('/api/notes') async def get_notes():
from pydantic import BaseModel import base64 from Crypto.Hash import SHA1, SHA256, SHA512, MD5 from Crypto.Cipher import AES, PKCS1_OAEP from Crypto.Signature import pkcs1_15 from Crypto.PublicKey import RSA from Crypto.Random import get_random_bytes default_string_encoding = 'utf-8' parent_dir_path = os.path.dirname(os.path.realpath(__file__)) app = FastAPI() app.mount("/static", StaticFiles(directory=parent_dir_path + "/static"), name="static") def encode_base64_string(message: str, string_encoding: str = default_string_encoding): message_bytes = message.encode(string_encoding) return encode_base64_bytes(message_bytes) def encode_base64_bytes(message: bytes): base64_bytes = base64.b64encode(message) base64_hex = base64_bytes.hex() base64_ascii = base64_bytes.decode('ascii') return base64_bytes, base64_hex, base64_ascii
from pydantic import BaseSettings class Settings(BaseSettings): ghtoken: str staticdir: str = "static" templatesdir: str = "templates" class Config: env_file = ".env" settings = Settings() app = FastAPI() gh = Github(settings.ghtoken) app.mount("/static", StaticFiles(directory=settings.staticdir), name="static") templates = Jinja2Templates(directory=settings.templatesdir) # run_async(init()) @app.get("/", response_class=HTMLResponse) def index(request: Request): return templates.TemplateResponse("start.j2", {"request": request}) @app.post("/search-repos") async def search_repos(st: SearchString): # log the search query. results = gh.search_repositories( query="{0} language:{1}".format(st.query_text, st.language))
from fastapi import FastAPI, HTTPException, Request, Form from url_shortener.routes.shorten import router as ShortenRouter, shortme from url_shortener.routes.redirect import router as RedirectRouter from mongoengine import connect, disconnect from fastapi.responses import HTMLResponse from fastapi.templating import Jinja2Templates from fastapi.staticfiles import StaticFiles from decouple import config import uvicorn MONGO_URI = config('MONGO_URI') app = FastAPI() templates = Jinja2Templates(directory="url_shortener/templates") app.mount("/static", StaticFiles(directory="url_shortener/static"), name="static") app.include_router(ShortenRouter, tags=["Shortify long URL"], prefix="/api/v1/shortify") app.include_router(RedirectRouter, tags=["Redirect to Short URL"]) @app.get("/", response_class=HTMLResponse) async def index(request: Request): return templates.TemplateResponse("index.html", { "request": request, })
if keep_args: query = dict(request.query_params) | query if query: query = urllib.parse.urlencode(query, doseq=True) result += '?' + query return result self.env.globals['url_for'] = url_for def render(self, name: str, request: Request, **kwargs): return self.TemplateResponse(name, { 'request': request, 'template_name': name } | kwargs) templates = Jinja2Templates(TEMPLATES_DIR) app.mount('/static', StaticFiles(directory=MODULE_DIR / 'static'), 'static') for file in Path(__file__).parent.glob('./routes/*'): if file.stem.startswith('_'): continue module = importlib.import_module(f'{__name__}.routes.{file.stem}') if hasattr(module, 'router'): router.include_router(module.router) @router.get('/') async def home(): return RedirectResponse(router.url_path_for('games'))
async def restore_default_firmware(response: Response) -> Any: try: await autopilot.kill_ardupilot() autopilot.restore_default_firmware() except Exception as error: response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR return {"message": f"{error}"} finally: await autopilot.start_ardupilot() app = VersionedFastAPI(app, version="1.0.0", prefix_format="/v{major}.{minor}", enable_latest=True) app.mount("/", StaticFiles(directory=str(FRONTEND_FOLDER), html=True)) if __name__ == "__main__": if args.sitl: autopilot.current_platform = Platform.SITL loop = asyncio.new_event_loop() # # Running uvicorn with log disabled so loguru can handle it config = Config(app=app, loop=loop, host="0.0.0.0", port=8000, log_config=None) server = Server(config)
from fastapi import FastAPI, File, UploadFile from fastapi.staticfiles import StaticFiles from fastapi.responses import RedirectResponse, HTMLResponse from PIL import Image import torch import torchvision import json import io import responseMaker app = FastAPI() app.mount("/static", StaticFiles(directory="static", html=True), name="static") model = torchvision.models.resnet18(pretrained=True) model.eval() # Image transforms normalize = torchvision.transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = torchvision.transforms.Compose([ torchvision.transforms.Resize(256), torchvision.transforms.CenterCrop(224), torchvision.transforms.ToTensor(), normalize, ]) with open('label_map.json', 'r') as f: label_map = json.load(f) @app.get("/")
from JJMumbleBot.plugins.core.web_server.routing.core_commands import routing as core_commands_routing from JJMumbleBot.plugins.core.web_server.routing.sound_board import routing as sound_board_routing web_app = FastAPI( title="JJMumbleBot Web API", description="This is the REST API for JJMumbleBot built with FastAPI", version=META_VERSION, redoc_url=None ) web_app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_methods=["GET", "POST"], allow_headers=["*"] ) web_app.mount("/static", StaticFiles(directory=f"{get_core_plugin_dir()}/web_server/static"), name="static") web_app.include_router(core_routing.router) web_app.include_router(audio_routing.router) web_app.include_router(bot_commands_routing.router) web_app.include_router(core_commands_routing.router) web_app.include_router(sound_board_routing.router) @web_app.exception_handler(StarletteHTTPException) async def http_exception(request, exc): resp = ResponseModel(404, "error", {"error_message": "This path is invalid!"}) return JSONResponse(resp.toDict(), media_type="application/json", status_code=404) @web_app.get("/") async def serve_app(request: Request):
# _*_ coding:utf-8 _*_ # @File : main.py # @Time : 2020-07-18 18:38 # @Author: zizle from fastapi import FastAPI, HTTPException from fastapi.staticfiles import StaticFiles from routers import router app = FastAPI() app.mount("/download-files/", StaticFiles(directory="F:/ADSCLIENTS/"), name="clientUpdate") @app.get("/", tags=["主页"]) async def index(): return HTTPException(status_code=404) # return {"message": "The Analysis Decision System 2.0 Service."} app.include_router(router, prefix='/api') if __name__ == '__main__': import uvicorn uvicorn.run(app, host="127.0.0.1", port=8000)
from fastapi import FastAPI, Request from fastapi.staticfiles import StaticFiles from datetime import datetime import csv app = FastAPI() @app.post("/result") async def result(request: Request): try: res = await request.json() to_store = [datetime.now().strftime("%Y-%m-%d %H:%M")] + list( res.values()) with open(r'./score.csv', 'a') as f: writer = csv.writer(f) writer.writerow(to_store) except Exception as e: return {"error": e.message} return {"error": ""} app.mount("/ranking", StaticFiles(directory="public/ranking", html=True), name="ranking") app.mount("/", StaticFiles(directory="public/game", html=True), name="public")
def disconnect(self, websocket: WebSocket): self.active_connections.remove(websocket) async def broadcast(self, message: str, websocket: WebSocket): for connection in self.active_connections: if connection != websocket: await connection.send_text(message) app = FastAPI() manager = ConnectionManager() @app.route('/') def hello(self): return RedirectResponse(url="/index.html") @app.websocket("/ws") async def websocket_endpoint(websocket: WebSocket): await manager.connect(websocket) try: while True: data = await websocket.receive_text() await manager.broadcast(data, websocket) except: manager.disconnect(websocket) app.mount("/", StaticFiles(directory="front"), name="static")
import uvicorn from typing import Optional from fastapi import FastAPI, Request, HTTPException from fastapi.staticfiles import StaticFiles from starlette.responses import FileResponse app = FastAPI() @app.get("/tailwind/") async def read_index(): return FileResponse('play-tailwind-main/index.html') app.mount("/tailwind/", StaticFiles(directory="play-tailwind-main"), name="static") @app.get("/") def read_root(): return {"Hello": "World"} @app.get("/hello") def read_root(): return {"Hello": "World"} ACCESS_TOKEN_KEY = os.environ['ACCESS_TOKEN_KEY'] ACCESS_TOKEN_VALUE = os.environ['ACCESS_TOKEN_VALUE']
from fastapi import FastAPI from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates app = FastAPI() app.mount("/static", StaticFiles(directory="./api_app/static"), name="static") templates = Jinja2Templates(directory="./api_app/templates") from api_app.views import main, tasks
<a href='https://docs.wordweaver.ca'>https://docs.wordweaver.ca</a> for more information.""", version="1.0", ) app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) i18n_assets_path = os.path.join(DATA_PATH, WWLANG, "i18n") if os.path.exists(i18n_assets_path): app.mount("/i18n", StaticFiles(directory=i18n_assets_path), name="i18n") @app.get("/", include_in_schema=False) async def home(): return RedirectResponse("/docs") app.include_router(options.router, prefix="/api/v1") app.include_router(pronouns.router, prefix="/api/v1") app.include_router(verbs.router, prefix="/api/v1") app.include_router(conjugations.router, prefix="/api/v1")
# Main application to serve HTML middleware = [ Middleware(SessionMiddleware, secret_key=SECRET_KEY, session_cookie="notify_session") ] app = FastAPI(exception_handlers=exceptions.exception_handlers, middleware=middleware) app.include_router(account.router) app.include_router(notifications.router, prefix="/notifications") app.include_router(settings.router, prefix="/settings") # Serve static files app_dir = Path(__file__).parent.resolve() app.mount("/static", StaticFiles(directory=str(app_dir / "static")), name="static") # API mounted under /api original_api = FastAPI() original_api.include_router(monitoring.router, prefix="/-", tags=["monitoring"]) original_api.include_router(login.router, tags=["login"]) original_api.include_router(users.router, prefix="/users", tags=["users"]) original_api.include_router( services.router, prefix="/services", tags=["services"], )
from workers import thumbnail logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) STATIC_DIR = os.environ.get("STATIC_DIR", "/tmp/static") class Thumbnail(BaseModel): url: str filename: Optional[str] = None app = FastAPI() app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static") @app.post("/thumbnail", response_model=Thumbnail) def create_thumbnail(tn: Thumbnail): try: rw = RandomWord() filename = '_'.join( rw.random_words(3, include_parts_of_speech=["nouns", "adjectives"])) tn.filename = filename thumbnail.create.delay(tn.url, filename) return tn except Exception as e: logger.error('Error encountered:{}'.format(e))
@app.post("/classic/todos") def classic_toggle(todo: Todo) -> None: _todos.todos.append(todo) @app.get("/declarative", response_class=HTMLResponse) def declarative() -> str: return render( PageData( type="declarative", username="******", state=State(todos=[], new=""), )) @app.get("/declarative/todos", response_model=TodoList) def get_todos() -> TodoList: return _todos @app.put("/declarative/todos", response_model=TodoList) def put_todos(todos: TodoList) -> TodoList: _todos.todos = todos.todos return _todos app.mount("/static", StaticFiles(directory=static), name="static") app.mount("/shared", StaticFiles(directory=shared), name="shared")