import pathlib
from starlette.exceptions import HTTPException as StarletteHTTPException
from fastapi import status, FastAPI
from fastapi.exception_handlers import http_exception_handler
from fastapi.templating import Jinja2Templates
app_path = pathlib.Path(__file__).parent.parent.absolute()
template_path = (app_path / 'templates').absolute()
templates = Jinja2Templates(directory=template_path)
def register_handlers(app: FastAPI):
@app.exception_handler(StarletteHTTPException)
async def custom_exception_handler(request, exc):
if exc.status_code == status.HTTP_403_FORBIDDEN:
return templates.TemplateResponse('access_forbidden.html',
{'request': request})
return await http_exception_handler(request, exc)
from datetime import timedelta
from fastapi import APIRouter, Request, Depends
from fastapi.templating import Jinja2Templates
templates = Jinja2Templates(directory="frontend/templates")
router = APIRouter()
@router.get("/")
def home(request: Request):
return templates.TemplateResponse("home.html", {"request": request})
if pk in patients.keys():
return patients[pk]
else:
raise HTTPException(status_code=204, detail="Patient doesn't exists")
# Wykład 3 - libraries
from hashlib import sha256
from fastapi import FastAPI, HTTPException, Depends, status, Response, Cookie, Request
from fastapi.security import HTTPBasic, HTTPBasicCredentials
from fastapi.responses import RedirectResponse
import secrets
from fastapi.templating import Jinja2Templates
from fastapi.responses import JSONResponse
templates = Jinja2Templates(directory="html")
app.secret_key = "Mariusz"
security = HTTPBasic()
app.sessions = {}
# Wykład 3 - zadanie 1 i 4
@app.get('/welcome/')
def hi(request: Request, session_token: str = Cookie(None)):
if session_token not in app.sessions:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Error",
headers={"WWW-Authenticate": "Basic"},
from typing import List
from fastapi import Depends, FastAPI, HTTPException, Request
from sqlalchemy.orm import Session
from fastapi.templating import Jinja2Templates
from fastapi.staticfiles import StaticFiles
from . import crud, models, schemas, bot
from .database import SessionLocal, engine
models.Base.metadata.create_all(bind=engine)
app = FastAPI()
templates = Jinja2Templates(directory='chat_app/templates/')
app.mount("/static", StaticFiles(directory="chat_app/static"), name="static")
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
@app.get('/')
def index(request: Request):
return templates.TemplateResponse('index.html',
context={'request': request})
else:
class SessionMiddleware:
pass
# TODO: fixed uuid for now, it will come from the FastAPI session
TEST_SESSION_UUID = "1234"
STATE_EVENT = "State changed"
frontend_static_dir = os.path.join(FRONTEND_DIR, "static")
api_app_delta_queue: Queue = None
template = {"ui": {}, "app": {}}
templates = Jinja2Templates(directory=FRONTEND_DIR)
# TODO: try to avoid using global var for state store
global_app_state_store = InMemoryStateStore()
global_app_state_store.add(TEST_SESSION_UUID)
lock = Lock()
app_spec: Optional[List] = None
logger = logging.getLogger(__name__)
# This can be replaced with a consumer that publishes states in a kv-store
# in a serverless architecture
import logging
import re
import ssl
from fastapi import FastAPI, Request, Form, HTTPException, Header
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from google.cloud import ndb, secretmanager_v1 as secretmanager
from typing import Optional
import models
app = FastAPI()
app.mount('/static', StaticFiles(directory='static'), name='static')
templates = Jinja2Templates(directory='templates')
ssl_context = ssl.create_default_context(cafile=certifi.where())
@app.get('/')
async def index(request: Request):
return templates.TemplateResponse("form.html", {
'request': request,
'content': 'Save your credentials'
})
@app.post('/userdata/')
async def userdata(request: Request,
apikey: str = Form(...),
from MQTTManager.app import webapp
from .menu import MAIN_FRAME
from fastapi.templating import Jinja2Templates
from fastapi.staticfiles import StaticFiles
from markupsafe import escape
from fastapi import Request, HTTPException
from fastapi.responses import HTMLResponse, RedirectResponse
SIDE_BAR = MAIN_FRAME["side-bar"]
templates = Jinja2Templates(directory="MQTTManager/routers/templates")
webapp.mount(
"/static",
StaticFiles(directory="MQTTManager/routers/templates/static"),
name="static",
)
from fastapi import APIRouter, Request, Form
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
from ory_hydra_client import ConsentRequest
from starlette import status
from starlette.responses import RedirectResponse
from starlette_wtf import csrf_token, csrf_protect
from app.db import find_by_email
from app.hydra import Hydra
router = APIRouter()
templates = Jinja2Templates("app/templates")
hydra = Hydra()
@router.get("/consent", response_class=HTMLResponse)
async def get_consent(consent_challenge: str, request: Request):
consent: ConsentRequest = hydra.client.get_consent_request(
consent_challenge)
return templates.TemplateResponse(
'consent.html', {
'request': request,
'challenge': consent_challenge,
'csrf_token': csrf_token(request),
'user': consent.subject,
'client': consent.client,
'requested_scope': consent.requested_scope,
})
from fastapi import APIRouter
from fastapi.templating import Jinja2Templates
from starlette.requests import Request
templates = Jinja2Templates("templates")
router = APIRouter()
@router.get('/', include_in_schema=False)
def index(request: Request):
return templates.TemplateResponse("index.html", {"request": request})
from fastapi import APIRouter, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
router = APIRouter()
templates = Jinja2Templates(directory="fastapi_plotly/templates")
@router.get("/", response_class=HTMLResponse)
async def index(request: Request, title="Hello"):
return templates.TemplateResponse("index.html", {
"request": request,
"title": title
})
import data.emails as data
from data.templates import get_default_template
from fastapi import APIRouter, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
router = APIRouter(prefix="/dashboard", include_in_schema=False)
templates = Jinja2Templates(directory="api/templates")
@router.get("", response_class=HTMLResponse)
async def get_dashboard(request: Request):
campaign_config = data.get_campaign_config_default()
campaigns = data.get_all_campaigns_unpaginated()
subscribers = data.get_all_emails_unpaginated()
uppy_config = data.get_uppy_config()
total_campaigns = data.get_campaign_count()
default_template = get_default_template()
return templates.TemplateResponse(
"dashboard.html",
{
"request": request,
"user": {
"username": "******"
},
"campaign_config": campaign_config,
"campaigns": [campaign for campaign in campaigns],
"subscribers": [subscriber for subscriber in subscribers],
"uppy_config": uppy_config,
""" Core Website Pages """
from fastapi import APIRouter, Request
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
import os
router = APIRouter()
templates = Jinja2Templates(directory='Chess_Club/templates')
@router.get('/', response_class=HTMLResponse)
async def get_index(request: Request):
return templates.TemplateResponse('index.html', {'request': request})
@router.get('/about', response_class=HTMLResponse)
async def login(request: Request):
return templates.TemplateResponse('about.html', {'request': request})
@router.get('/learning', response_class=HTMLResponse)
async def settings(request: Request):
return templates.TemplateResponse('learning.html', {'request': request})
@router.get('/tournaments', response_class=HTMLResponse)
async def signup(request: Request):
return templates.TemplateResponse('tournaments.html', {'request': request})
@router.get('/calendar', response_class=HTMLResponse)
from fastapi.templating import Jinja2Templates
import uvicorn
import io
import cv2
import pytesseract
import numpy as np
import requests
from pydantic import BaseModel
from starlette.middleware.cors import CORSMiddleware
app = FastAPI()
app.mount("/static",
StaticFiles(directory="ocrpytesseract/static"),
name="static")
templates = Jinja2Templates(directory="ocrpytesseract/templates")
app.add_middleware(CORSMiddleware,
allow_origins=["*"],
allow_methods=["*"],
allow_headers=["*"])
class ImageType(BaseModel):
url: str
def getLang(x, lang):
pytesseract.pytesseract.tesseract_cmd = '/usr/bin/tesseract'
#pytesseract.pytesseract.tesseract_cmd = 'C:\\Program Files\\Tesseract-OCR\\tesseract.exe'
async def stream_initialize(self):
pass
async def system_restart(self):
raise NotImplementedError
_this_dir = pathlib.Path(__file__).parent
static_dir = _this_dir / "static"
app = FastAPI()
app.mount("/static",
StaticFiles(directory=static_dir, packages=["bootstrap4"]),
name="static")
templates = Jinja2Templates('eigersim/templates')
@app.get('/')
def index(request: Request):
return templates.TemplateResponse('index.html', {'request': request})
# DETECTOR MODULE =============================================================
@app.get('/detector/api/version/')
def version():
return dict(value='1.6.0', value_type='string')
import os
from fastapi import FastAPI, Request, Response
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
app = FastAPI()
SERVER_ROOT = os.path.dirname(__file__)
app.mount("/static",
StaticFiles(directory=os.path.join(SERVER_ROOT, "static")),
name="static")
templates = Jinja2Templates(directory=os.path.join(SERVER_ROOT, "templates"))
# option for routing `@app.X` where `X` is one of
# post: to create data.
# get: to read data.
# put: to update data.
# delete: to delete data.
# `127.0.0.1:8000/docs` endpoint will have autogenerated docs for the written code
# Test Driven Development --> https://fastapi.tiangolo.com/tutorial/testing/
@app.get("/")
def landing(request: Request) -> Response:
return templates.TemplateResponse("index.html", {"request": request})
from fastapi import FastAPI, Request
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
app = FastAPI()
app.mount("/static", StaticFiles(directory="./tutorial/static"), name='static')
templates = Jinja2Templates(directory="./tutorial/templates")
@app.get("/")
async def index():
return {"message":"Hello Tutorial!"}
@app.get("/home")
async def home(request: Request):
return templates.TemplateResponse("home.html", {"request": request})
from tutorial.views.next import next
from fastapi import FastAPI, Request
from fastapi.responses import FileResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
import time
import matplotlib.pyplot as plt
import requests
import pandas as pd
import json
app = FastAPI()
path = "graph.png"
url = "https://random-data-api.com/api/color/random_color"
app.mount("/static", StaticFiles(directory="source/static"), name="static")
templates = Jinja2Templates(directory="source/views")
def request_api(indexFake):
time.sleep(1)
try:
rawReceive = requests.get(url)
rawDict = rawReceive.json()
cleanDict = {
"y": rawDict['id'],
"color_name": rawDict['color_name'],
"hex_value": rawDict['hex_value'],
"x": indexFake
}
buff = pd.DataFrame([cleanDict])
return buff
except:
import os
from fastapi import FastAPI, Request
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
import logic
app = FastAPI(title="Stask")
app.mount('/static',
StaticFiles(directory=os.path.join(os.getcwd(), 'static')),
name='static')
templates = Jinja2Templates(directory=os.path.join(os.getcwd(), 'templates'))
@app.get('/')
def index(request: Request):
table = logic.Table(use_config_file=True)
table.defect()
table.run()
return templates.TemplateResponse('index.html', {
'request': request,
'table': table.table,
})
from fastapi import FastAPI, Request
from fastapi.templating import Jinja2Templates
import uvicorn
from utils import load_config
config = load_config()
templates = Jinja2Templates(directory="web")
app = FastAPI()
@app.get("/")
async def root(request: Request):
return templates.TemplateResponse("commands.html", {
"request": request,
"categories": config.cogs
})
uvicorn.run(app, host="0.0.0.0", port=8181)
},
]
app = FastAPI(
# 元数据
title="系统接口",
version="0.0.1",
openapi_tags=tags_metadata,
# 文档 URL
docs_url="/openapi", #Swagger UI
redoc_url="/apidoc" #ReDoc
)
# 页面模板
templates = Jinja2Templates(directory="./page")
# 挂载静态目录
app.mount("/static", StaticFiles(directory="./static"), name="static")
app.include_router(usersRouter, prefix="/user", tags=['users'])
app.include_router(itemsRouter, prefix="/items", tags=['Items'])
app.include_router(fileRouter, prefix="/file", tags=['file'])
app.include_router(socketRouter, prefix="/socket", tags=['socket'])
'''
async def get_redis_pool() -> Redis:
redis = await create_redis_pool(r"redis://:@"+redishost+":"+redisport+"/"+redisdb+"?encoding=utf-8")
return redis
@app.on_event("startup")
async def startup_event():
app.state.redis = await get_redis_pool()
from fastapi import FastAPI, Request, Form
from fastapi.responses import HTMLResponse, FileResponse
from fastapi.templating import Jinja2Templates
from fastapi.staticfiles import StaticFiles
from iris import ml
from urllib.parse import urljoin
app = FastAPI()
app.mount("/images", StaticFiles(directory="images"), name="images")
templates = Jinja2Templates(directory="ui")
@app.get("/")
async def form(request: Request):
return templates.TemplateResponse("form.html", {"request": request})
@app.post("/iris", response_class=HTMLResponse
) ## yaaha html file ke form se values lega aur dekhega
async def login(request: Request,
w: int = Form(...),
x: int = Form(...),
y: int = Form(...),
z: int = Form(...)):
flower = ml(int(w), int(x), int(y), int(z))
img_url = 'images/' + flower + '.jpg'
# html_response = """
# <!DOCTYPE html>
# <html>
# <head>
#!/usr/bin/python3
import uvicorn
from fastapi import FastAPI, Request
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from app import utils
from app.routers import displacy
from app.utils import get_args
args = get_args()
app = FastAPI()
app.mount("/static", StaticFiles(directory="app/static"), name="static")
templates = Jinja2Templates(directory="app/pages")
app.include_router(
displacy.router,
prefix="/api",
tags=["display"]
)
app.include_router(
utils.router,
prefix="",
tags=["display"]
)
@app.get("/", tags=["pages"])
@app.get("/index", tags=["pages"], response_class=HTMLResponse)
from fastapi.templating import Jinja2Templates from core import config templates = Jinja2Templates(directory=config.TEMPLATE_DIR)
# Cors middleware
origins = [
"*",
]
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
models.Base.metadata.create_all(bind=engine) # create sqlalchemy base model objects
templates = Jinja2Templates(directory="templates") # load frontend template
@app.get("/")
def home(request: Request, db : Session = Depends(get_db)):
"""
Displays the dashboard for wrist ml application
"""
acti = db.query(Acti).all()
wrist = db.query(Wrist).all()
return templates.TemplateResponse("home.html", {
"request": request,
"actis": acti,
"wrists": wrist
})
from fastapi.requests import Request
from fastapi.responses import FileResponse, ORJSONResponse
from fastapi.templating import Jinja2Templates
import nereid.bg_worker as bg
from nereid.api.api_v1.models import network_models
from nereid.api.api_v1.utils import (
run_task,
standard_json_response,
wait_a_sec_and_see_if_we_can_return_some_data,
)
from nereid.core import config
router = APIRouter()
templates = Jinja2Templates(directory=r"nereid/api/templates")
@router.post(
"/network/validate",
tags=["network", "validate"],
response_model=network_models.NetworkValidationResponse,
response_class=ORJSONResponse,
)
async def validate_network(graph: network_models.Graph = Body(
...,
example={
"directed": True,
"nodes": [{
"id": "A"
}, {
class CustomApp(FastAPI):
templates = Jinja2Templates(directory=settings.TEMPLATES_DIR)
import os
import pathlib
from fastapi import FastAPI, Form, Request
from fastapi.templating import Jinja2Templates
from dotenv import load_dotenv
from functools import lru_cache
from .airtable import Airtable
BASE_DIR = pathlib.Path(__file__).parent # src
app = FastAPI()
templates = Jinja2Templates(directory=BASE_DIR / "templates")
@lru_cache()
def cached_dotenv():
load_dotenv()
cached_dotenv()
AIRTABLE_BASE_ID = os.environ.get("AIRTABLE_BASE_ID")
AIRTABLE_API_KEY = os.environ.get("AIRTABLE_API_KEY")
AIRTABLE_TABLE_NAME = os.environ.get("AIRTABLE_TABLE_NAME")
# Routes
'''
- Use this command to run:
uvicorn src.app:app --reload
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.exception_handlers import http_exception_handler
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from starlette.exceptions import HTTPException
from fyscience.routers.api import api_router
from fyscience.routers.html import html_router
from fyscience.routers.deps import TEMPLATE_PATH
STATIC_PATH = os.path.join(os.path.abspath(os.path.dirname(__file__)),
"static")
templates = Jinja2Templates(directory=TEMPLATE_PATH)
app = FastAPI(title="Free Your Science")
app.include_router(api_router)
app.include_router(html_router, include_in_schema=False)
app.mount("/static", StaticFiles(directory=STATIC_PATH), name="static")
app.add_middleware(
CORSMiddleware,
allow_origins=[
"http://localhost",
"http://localhost:8080",
"http://localhost:8000",
],
allow_credentials=True,
allow_methods=["*"],
sqlalchemy.Column("code", sqlalchemy.String(500)),
sqlalchemy.Column("expired", sqlalchemy.String(500)),
sqlalchemy.Column("uuid", sqlalchemy.String(500)),
sqlalchemy.Column("created_time", sqlalchemy.DateTime),
sqlalchemy.Column("edited_time", sqlalchemy.DateTime),
)
engine = sqlalchemy.create_engine(
DATABASE_URL, connect_args={"check_same_thread": False}
)
metadata.create_all(engine)
app = FastAPI()
templates = Jinja2Templates(directory="templates")
codedb = []
all_item = []
uni_item = []
class CodeIn(BaseModel):
client: str
code: Optional[str] = False
expired: str
uuid: str
created_time: Optional[datetime] = False
edited_time: Optional[datetime] = False
# post model
from fastapi.exceptions import HTTPException
from fastapi.responses import Response
from fastapi.templating import Jinja2Templates
from fastapi_sqlalchemy import db
from send_to_bot import send_command_to_bot
from sqlalchemy import func
from starlette.requests import Request
from starlette.responses import FileResponse
from starlette.responses import JSONResponse
from models import TriviaQuestions
router = APIRouter()
web_api_key = getenv("WEB_API_KEY")
templates = Jinja2Templates(directory="static_files/trivia")
@router.get("/trivia/q")
async def trivia_q(request: Request, key: str = None):
if key != web_api_key:
return Response(status_code=403)
question = (
db.session.query(TriviaQuestions)
.filter(TriviaQuestions.last_used_date < date.today(), TriviaQuestions.enabled == True) # noqa:E712
.order_by(func.random())
.limit(1)
.one_or_none()
)
