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