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
