from .analytics import router from .helpers import getAllthings from .filters import flagize, hmantime, getConutryCode from datetime import datetime from jinja2 import Template from .analytics import TITLE from .auth import manager from fastapi.responses import HTMLResponse from fastapi.templating import Jinja2Templates from fastapi import APIRouter, Request, Depends from os import path router = APIRouter() pth = path.dirname(__file__) templates = Jinja2Templates(directory=path.join(pth, "templates")) templates.env.filters['flagize'] = flagize templates.env.filters['dateit'] = hmantime templates.env.filters['getctCode'] = getConutryCode @router.get("/dash", response_class=HTMLResponse) def renderIndex(request: Request, user=Depends(manager)): js = Template(open(path.join(pth, "templates/chart.js")).read()) dayHits = getAllthings(dayNeed=True) refs, hiturls, hours, hhits, iptime, totHits, os, browsers, dev, lt, ctDict = getAllthings( ) ipSorted = sorted(iptime, key=lambda k: sorted(k.keys()), reverse=True) return templates.TemplateResponse( "index.html",
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})
from fastapi import FastAPI, Form, Request from fastapi.staticfiles import StaticFiles from fastapi.responses import FileResponse from fastapi.responses import HTMLResponse from fastapi.templating import Jinja2Templates from .ner import NER from requests.exceptions import ConnectionError app = FastAPI() templates = Jinja2Templates(directory="app/static/templates") @app.post("/", response_class=HTMLResponse) async def root(request: Request, data: str = Form(...)): ner = NER(data) try: result = ner.result() except ConnectionError: if not result: return templates.TemplateResponse( "error.html", { "request": request, "data": data, "error": "Unable to connect to one of NLP servers", }) print(result) # return {"result": ner.result()} return templates.TemplateResponse("result.html", { "request": request, "data": data,
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
from typing import Dict, List from fastapi import FastAPI, Request, Response, Cookie, HTTPException, Depends, status from fastapi.security import HTTPBasic, HTTPBasicCredentials from fastapi.responses import JSONResponse from fastapi.templating import Jinja2Templates from pydantic import BaseModel from hashlib import sha256 import secrets app = FastAPI() security = HTTPBasic() templates = Jinja2Templates(directory="templates") app.counter = 0 app.patients = dict() app.secret_key = "LPYGCwTTEXBzhjLp86TRAYQBvXa5fAEf249YxC9RAfS7YSj2rHUdf6W4S7jzN4yw" app.users = {"trudnY": "PaC13Nt"} app.sessions = {} def check_session(session_token: str = Cookie(None)): if session_token not in app.sessions: session_token = None return session_token @app.get("/") def root():
# Local Library from . import util # Third-Party Library from fastapi import FastAPI, Request from fastapi.templating import Jinja2Templates alpm = util.Alpm() def regex_replace(string, find, replace): return re.sub(find, replace, string) app = FastAPI() template = Jinja2Templates("templates") template.env.filters["regex_replace"] = regex_replace @app.get("/") async def root(request: Request): return template.TemplateResponse( "root.html", { "request": request, "pkgs": alpm.get_pkgs(["firefox", "chromium", "discord"]) }) @app.get("/package/{pkgname}") async def package(request: Request, pkgname: str): pkg = alpm.get_pkg(pkgname)
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'))
import math import urllib.request import json import pandas as pd import numpy as np import time app = FastAPI() app.mount("/fastapi_app/static", StaticFiles(directory="fastapi_app/static"), name="static") models.Base.metadata.create_all(bind=engine) templates = Jinja2Templates(directory="fastapi_app/templates") grid_db = "grid.db" def get_db(): try: db = SessionLocal() yield db finally: db.close() @app.get("/favicon.ico") async def redirect(): response = RedirectResponse(url='/fastapi_app/static/favicon.ico')
import redis from fastapi import APIRouter, Request, Response from fastapi.templating import Jinja2Templates from configuration import (ESL_HOST, ESL_PORT, ESL_SECRET, MAX_SPS, MAX_SESSION, FIRST_RTP_PORT, LAST_RTP_PORT, REDIS_HOST, REDIS_PORT, REDIS_DB, REDIS_PASSWORD, SCAN_COUNT) from utilities import logify, get_request_uuid # api router declaration fsxmlrouter = APIRouter() # template location templates = Jinja2Templates(directory="templates/fsxml") #----------------------------------------------------------------------------------------------------------------------------------------------------------------------- @fsxmlrouter.get("/fsxmlapi/acl", include_in_schema=False) def esl(request: Request, response: Response): try: result = templates.TemplateResponse("acl.j2.xml", { "request": request, "ips": [] }, media_type="application/xml") response.status_code = 200 except Exception as e: response.status_code, result = 500, str() logify(
# Database Model class Currency(Base): __tablename__ = "currency" ticker = Column(String) date = Column(Date) rates = Column(JSON, primary_key=True) Base.metadata.create_all(bind=engine) # FastAPI app = FastAPI() # For static files templates = Jinja2Templates(directory="frontend/templates") app.mount("/static", StaticFiles(directory="frontend/static"), name="static") # Tickers for updating database tickers = [ 'USD', "EUR", 'PHP', 'DKK', 'HUF', 'CZK', 'AUD', 'RON', 'SEK', 'IDR', 'INR', 'BRL', 'RUB', 'HRK', 'JPY', 'THB', 'CHF', 'SGD', 'PLN', 'BGN', 'TRY', 'CNY', 'NOK', 'NZD', 'ZAR', 'USD', 'MXN', 'ILS', 'GBP', 'KRW', 'MYR', 'CAD' ] # Updates database async def update_db(tick, preference): """ Updates database asynchronously
from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates from deta import Deta import secrets app = FastAPI() # create app instance deta = Deta("") # provide project key db = deta.Base("minishort") # create a DetaBase app.mount("/static", StaticFiles(directory="static"), name="static") pages = Jinja2Templates(directory="pages") @app.get("/") async def get_home(request: Request): return pages.TemplateResponse("index.html", {"request": request}) @app.post("/shorten") async def shorten_url(url): # data = jsonable_encoder(url) token = secrets.token_urlsafe(6) db.put(url, key=token) return {"url": token}
import requests from fastapi import FastAPI, Request, Response, HTTPException from pydantic import BaseModel from fastapi.responses import HTMLResponse, FileResponse, RedirectResponse from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates Config = configparser.ConfigParser() Config.read('./config.ini') SERVER_HOST_ADDRESS = "localhost:8080" if Config['NETWORK-MODE'][ 'localhost'] is True else 'backend' app = FastAPI() app.mount("/static", StaticFiles(directory="static"), name="static") templates = Jinja2Templates(directory="static") @app.on_event("startup") def startup(): print("starting server....") @app.on_event("shutdown") def shutdown(): print("server shutting down....") @app.get("/") def root(response_model: RedirectResponse): return RedirectResponse("/portfolio")
import os import jinja2 from asyncio import Lock from fastapi import FastAPI, Form, HTTPException, status, Request from fastapi.templating import Jinja2Templates from starlette.responses import Response, HTMLResponse, PlainTextResponse from pprint import pprint app = FastAPI() _base_path = os.path.dirname(os.path.abspath(__file__)) t = Jinja2Templates(directory=os.path.join(_base_path, "t")) @app.get("/") @app.get("/index") async def index(req: Request, resp: Response) -> Response: return t.TemplateResponse('index.jhtml', { "request": req, }, headers={"X-Powered-By":"FastAPI"}) @app.get("/flag") @app.get("/flag.txt") async def no_flag(req: Request, resp: Response): resp.headers["X-Powered-By"] = "FastAPI" return "flag? No. You don't need it"
from fastapi import APIRouter, status, Request, Form, Response from fastapi.responses import RedirectResponse from fastapi.templating import Jinja2Templates from ..core import crud, schema, models from typing import List, Optional import asyncio router = APIRouter() templates = Jinja2Templates(directory="project_underhill/templates") @router.get("/create") async def create_deck(request: Request, deck_id: Optional[str] = None): labels = [] for type in schema.CardType.__members__: for n in range(1, 6): label = [f"{type} {n}", f"{type[0]}{n}"] labels.append(label) return templates.TemplateResponse("create_deck.html", { "request": request, "labels": labels, "deck_id": deck_id }) @router.post("/create/add_to_db", status_code=status.HTTP_201_CREATED) async def receive_cards( request: Request, owner_id: str = "test",
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): """Returns Jobs Result""" if name in cls.cache: return cls.cache[name]
import os from os.path import join from fastapi import APIRouter, Request, HTTPException from fastapi.templating import Jinja2Templates from loguru import logger from db0mb3r.service import prepare_services router = APIRouter() templates = Jinja2Templates(directory=join(os.getcwd(), "app", "templates")) @logger.catch @router.get("/") def index(request: Request): if request.app.state.only_api: raise HTTPException(status_code=404) services = prepare_services() return templates.TemplateResponse( "index.html", { "request": request, "service_count": len(services[7]), }, # 7 corresponds to Russia which is a default choice )
async def home_page(request: Request): templates = Jinja2Templates(directory="src/templates") return templates.TemplateResponse("home.jinja2", {"request": request})
logger = logging.getLogger("Noticrawl") app = FastAPI() app.include_router(auth_router) app.include_router(user_router) app.include_router(crawling_router) database_schemas.create() asyncio.create_task(scheduler.run_scheduler()) app.mount("/static", StaticFiles(directory="../frontend/build/static"), name="static") templates = Jinja2Templates(directory="../frontend/build") @app.get("/", tags=["Statics"]) @app.get("/code/{status_code}", tags=["Statics"]) @app.get("/manifest.json", tags=["Statics"]) @app.get("/favicon.ico", tags=["Statics"]) def show_public_statics(request: Request): return templates.TemplateResponse("index.html", {"request": request}) @app.get( "/.*", dependencies=[Depends(verify_token)], tags=["Statics"], responses={401: {
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)) top10 = results[:10]
from fastapi import FastAPI, HTTPException, Request from tortoise.contrib.fastapi import register_tortoise, HTTPNotFoundError from pydantic import BaseModel from models import Student, Student_Pydantic, StudentIn_Pydantic from fastapi.responses import HTMLResponse from fastapi.templating import Jinja2Templates class Message(BaseModel): message: str templates = Jinja2Templates('templates') app = FastAPI(title='Student ORM') @app.get('/') async def root(): return {'Server status': 'Online'} @app.post('/student', response_model=Student_Pydantic) async def create(student: StudentIn_Pydantic): obj = await Student.create(**student.dict(exclude_unset=True)) return await Student_Pydantic.from_tortoise_orm(obj) @app.get('/student/{student_id}', response_model=Student_Pydantic, responses={404: {
default_static_folder = 'static' dirname = os.path.dirname(os.path.abspath(__file__)) static_foldername = config.get( 'STATIC_FOLDER', os.path.join(dirname, '../', default_static_folder)) if not os.path.exists(static_foldername): # If the specified static folder doesn't exist, an exception is thrown, which breaks unit tests and # test discovery in visual studio code. It's a pain figuring out why it's failing - so rather just # switch to a default folder that is know to exist, and log a warning. logger.warning( 'static folder "%s" doesn\'t exists, using "%s" instead', static_foldername, default_static_folder) static_foldername = os.path.join(dirname, '../', default_static_folder) return static_foldername templates = Jinja2Templates(directory=get_static_foldername()) def add_security_headers(scope, response): """ Add security headers to statically served content """ if config.get('HOSTNAME') != 'localhost': # For anything else - force https. response.headers.setdefault('Content-Security-Policy', 'upgrade-insecure-requests') path = scope.get('path') # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options if (path and path[path.rfind('.'):] in ('.css', '.js', '.png', '.xml', '.svg', '.json', '.txt'))\ or response.media_type in ('text/html',): response.headers.setdefault('X-Content-Type-Options', 'nosniff') if (path and path[path.rfind('.'):]
import os import uvicorn from fastapi import FastAPI, Request from fastapi.responses import HTMLResponse, FileResponse from fastapi.staticfiles import StaticFiles from fastapi.templating import Jinja2Templates base_path = os.path.dirname(__file__) static_path = os.path.join(base_path, "static") templates_path = os.path.join(base_path, "templates") images_path = os.path.join(static_path, "images") app = FastAPI() app.mount("/static", StaticFiles(directory=static_path), name="static") templates = Jinja2Templates(directory="web/templates") @app.get("/", response_class=HTMLResponse) async def home(request: Request): return templates.TemplateResponse("index.html", {"request": request}) @app.get('/favicon.ico') def favicon(): return FileResponse(os.path.join(images_path, 'favicon.png')) if __name__ == "__main__": # use this if you need to debug through vscode # uvicorn.run(app, # host="127.0.0.1",
'''OIDC server example''' import time from authlib.oauth2 import OAuth2Error from fastapi import APIRouter, Request, Form, status from fastapi.responses import RedirectResponse from fastapi.templating import Jinja2Templates from werkzeug.security import gen_salt from src.oauth2 import authorization, require_oauth, generate_user_info from src.database import db from src.models import User, OAuth2Client router = APIRouter() templates = Jinja2Templates(directory='src/templates') @router.get('/') def home(request: Request): '''List all clients''' clients = db.query(OAuth2Client).all() # pylint: disable=E1101 return templates.TemplateResponse('home.html', { 'request': request, 'clients': clients }) @router.get('/create_client') def get_create_client(request: Request): '''Display form to create client''' return templates.TemplateResponse('create_client.html',
import aiofiles from fastapi import FastAPI, Form, Request from fastapi.responses import HTMLResponse from fastapi.templating import Jinja2Templates from ..worker.tasks import * from ..worker.celery import app as celery_app, logger app = FastAPI() templates = Jinja2Templates(directory="src/app/templates") TASKS = { name: { "name": name, "last_id": None } for name in TASKS } async def get_index_template(request: Request, **kwargs) -> templates.TemplateResponse: async with aiofiles.open("celery.log", "r") as celery_log: log = await celery_log.read() log = log.split("\n") return templates.TemplateResponse( "index.html", {"request": request, "tasks": list(TASKS.values()), "log": log, **kwargs} )
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, })
import pathlib from fastapi import FastAPI, Request from fastapi.templating import Jinja2Templates BASE_DIR = pathlib.Path(__file__).parent #src app = FastAPI() templates = Jinja2Templates(directory=BASE_DIR / "templates") @app.get("/") def home_view(request: Request): return templates.TemplateResponse("home.html", {"request": request})
from datetime import datetime from typing import Any, List import redis from async_chat.models import Message from fastapi import FastAPI, HTTPException, Request, WebSocket, websockets from fastapi.templating import Jinja2Templates app = FastAPI() rd = redis.Redis() rd.lpush('messages', '') templates = Jinja2Templates(directory='templates') connections: List[WebSocket] = [] @app.get('/{username}') async def get(request: Request, username: str) -> Any: return templates.TemplateResponse('chat_page.html', { 'request': request, 'username': username }) @app.get('/messages/last/{count}') async def get_last_messages(request: Request, count: str) -> Any: try: count_messages = int(count) except ValueError:
from datetime import datetime from multiprocessing import Process import pathlib from message_passing_tree.prelude import * from message_passing_tree import SocketChannel from message_passing_tree.utils import json_stringify from message_passing_tree import ansi from spectralsequence_chart import SseqSocketReceiver, InteractiveChartAgent from ..repl.executor import Executor from .. import config from fastapi.templating import Jinja2Templates templates = Jinja2Templates(directory=str(config.TEMPLATE_DIR)) @subscribe_to("*") @collect_handlers(inherit=True) class TestChannel(SocketChannel): def __init__(self, name, repl_agent): super().__init__(name) self.repl_agent = repl_agent self.executor = Executor(repl_agent) self.chart = InteractiveChart(name) self.setup_executor_namespace() self.last_screenshot = None channels = {}
async def serve_app(request: Request): return Jinja2Templates(directory=f"{get_core_plugin_dir()}/web_server/templates").TemplateResponse("index.html", {"request": request})
def setup_http_app(composition: 'Composition', debug: bool) -> 'FastAPI': from flash import __version__ app = FastAPI( debug=debug, version=__version__, title="GridServe", ) # Endpoint Route # `/gridserve/alive` app.get( "/gridserve/alive", name="alive", description="If you can reach this endpoint, the server is runnning.", response_model=Alive, )(_build_alive_check()) _no_optimization_dsk = build_composition( endpoint_protocol=first(composition.endpoint_protocols.values()), components=composition.components, connections=composition.connections, ) pth = Path(__file__).parent.joinpath("templates") templates = Jinja2Templates(directory=str(pth.absolute())) # Endpoint Route # `/gridserve/component_dags` app.get( "/gridserve/component_dags", name="component_dags", summary="HTML Rendering of Component DAGs", response_class=HTMLResponse, )(_build_visualization(dsk_composition=_no_optimization_dsk, templates=templates, no_optimization=True)) # Endpoint Route # `/gridserve/dag_json` app.get( "/gridserve/dag_json", name="components JSON DAG", summary="JSON representation of component DAG", response_model=ComponentJSON, )(_build_dag_json( components=composition.components, ep_proto=None, show_connected_components=False, )) for ep_name, ep_proto in composition.endpoint_protocols.items(): dsk = build_composition( endpoint_protocol=ep_proto, components=composition.components, connections=composition.connections, ) RequestModel = ep_proto.request_model # skipcq: PYL-W0621 ResponseModel = ep_proto.response_model # skipcq: PYL-W0621 # Endpoint Route # `/{proto} app.post( f"{ep_proto.route}", name=ep_name, tags=[ep_name], summary="Perform a Compution.", description= "Computes results of DAG defined by these components & endpoint.", response_model=ResponseModel, )(_build_endpoint(RequestModel, dsk, ResponseModel)) # Endpoint Route: # `/{proto}/meta` app.get( f"{ep_proto.route}/meta", name=f"{ep_name} meta schema", tags=[ep_name], summary="OpenAPI schema", description="OpenAPI schema for this endpoints's compute route.", )(_build_meta(RequestModel)) # Endpoint Route # `/{proto}/dag` app.get( f"{ep_proto.route}/dag", name=f"{ep_name} DAG Visualization", tags=[ep_name], summary="HTML Rendering of DAG", description=( "Displays an html image rendering the DAG of functions " "& components executed to reach the endpoint outputs."), response_class=HTMLResponse, )(_build_visualization(dsk, templates)) # Endpoint Route # `/{proto}/dag_json` app.get( f"{ep_proto.route}/dag_json", name=f"{ep_name} JSON DAG", tags=[ep_name], summary="JSON representatino of DAG", response_model=MergedJSON, )(_build_dag_json( components=composition.components, ep_proto=ep_proto, show_connected_components=True, )) return app