def init_app(self,
app: FastAPI,
template_directory: str = "templates",
template_directories: Optional[List[str]] = None):
if template_directories is not None:
self.jinja2templates = [
Jinja2Templates(directory=path.join(getcwd(), directory))
for directory in template_directories
]
else:
self.jinja2templates = [
Jinja2Templates(
directory=path.join(getcwd(), template_directory)),
]
async def get(self, request):
# import pdb; pdb.set_trace()
context = {
"request": request,
"ultima_prevision": request.state.session.get('ultima_prevision'),
}
return Jinja2Templates(directory="templates").TemplateResponse("index.html", context)
async def http_exception(request, exc):
global context
log.exception('Error: %s', exc)
if isinstance(exc, HTTPException):
status_code = exc.status_code
error = exc.detail
elif isinstance(exc, AuthlibHTTPError):
status_code = exc.status_code
error = exc.error
elif isinstance(exc, DataError):
status_code = 400
error = str(exc)
else:
status_code = 500
error = str(exc)
response = {
"error": error,
}
fmt = get_response_type(context, request, request)
if fmt == 'json':
return JSONResponse(response, status_code=status_code)
else:
templates = Jinja2Templates(
directory=pres.resource_filename('spinta', 'templates'))
response = {
**response,
'request': request,
}
return templates.TemplateResponse('error.html',
response,
status_code=status_code)
def __init__(self):
super(SpiderApp, self).__init__()
# 指定静态文件存放路径
self.static_dir = '{}/static'.format(Path(__file__).resolve().parent)
self.mount("/static", StaticFiles(directory=self.static_dir), name="static")
# 指定html 存放目录
self.templates = Jinja2Templates(directory=self.static_dir)
self.spiders = {}
self.logger = logging.getLogger(self.__class__.__name__)
self.logger.setLevel(LOG_LEVEL or logging.DEBUG)
if not self.logger.handlers:
sh = logging.StreamHandler()
sh.setLevel(LOG_LEVEL or logging.DEBUG)
formatter = ColoredFormatter(fmt=LOG_FORMAT, datefmt=LOG_DATEFMT)
sh.setFormatter(formatter)
self.logger.addHandler(sh)
# register endpoints
self.get("/")(self.root)
self.get("/{name}")(self.spider_card)
self.get("/{name}/run")(self.run_spider)
self.get("/{name}/info")(self.spider_info)
self.spider_factory = lambda spider: spider()
self.redis_client = redis_client
self._loop = None
def create_tiles_router() -> APIRouter:
"""Create API router with OGC tiles endpoints"""
from titiler.endpoints.stac import STACTiler
template_dir = pkg_resources.resource_filename("titiler", "templates")
templates = Jinja2Templates(directory=template_dir)
titiler_router = STACTiler(
reader_options={
"include_asset_types":
{"image/tiff; application=geotiff; profile=cloud-optimized"}
}).router
@titiler_router.get("/viewer", response_class=HTMLResponse)
def stac_demo(request: Request):
"""STAC Viewer."""
return templates.TemplateResponse(
name="stac_index.html",
context={
"request": request,
"tilejson": request.url_for("tilejson"),
"metadata": request.url_for("info"),
},
media_type="text/html",
)
# TODO: add titiler exception handlers
return titiler_router
async def graphQL(request):
from starlette.templating import Jinja2Templates
from starlette.status import HTTP_400_BAD_REQUEST
from starlette.responses import PlainTextResponse
from starlette.responses import JSONResponse
if request.method == 'POST':
content_type = request.headers.get("Content-Type", "")
if content_type == 'application/json':
data = await request.json()
else:
return PlainTextResponse('Bad Request!', status_code=HTTP_400_BAD_REQUEST)
try:
query = data["query"]
variables = data.get("variables")
except KeyError:
return PlainTextResponse('Bad Request!', status_code=HTTP_400_BAD_REQUEST)
result = graphene.Schema(query=Query).execute(query, variables=variables)
return JSONResponse({"data": result.data})
else:
return Jinja2Templates(directory='Toolkit').TemplateResponse('graphQL.html', {
"request": request,
"resultFilePath": resultFilePath
})
def create_app():
fast_app = FastAPI(debug=False)
register_tortoise(fast_app, config=TORTOISE_ORM)
home_app = FastAPI(root_path="/")
templates_index = Jinja2Templates(directory="front")
@home_app.get('/')
async def main(request: Request):
return templates_index.TemplateResponse('index.html',
{"request": request})
home_app.mount('/', StaticFiles(directory='front'))
fast_app.mount('/app', home_app)
fast_app.mount("/admin", admin_app)
fast_app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
return fast_app
class AppConfig:
templates: Jinja2Templates = Jinja2Templates(directory="templates")
change_pw_redirect_url = "/"
change_pw_template = "starlette_auth/change_password.html"
login_redirect_url = "/"
login_template = "starlette_auth/login.html"
logout_redirect_url = "/"
def build_auth_ui(self, context=None):
if context is None:
context = {}
template_path = Path(self.config.login_ui.template_file)
templates = Jinja2Templates(directory=template_path.parent)
async def login(request: Request, *args, **kwargs):
if not self.oauth_backend.enabled or request.user.is_authenticated:
# This is authenticated so go straight to the homepage
return RedirectResponse(self.config.routing.home_path)
context['request'] = request
if 'login' not in context or context['login'] is None:
post_redirect = self.oauth_backend.authenticator.pop_post_auth_redirect(
request)
context[
'login'] = self.oauth_backend.authenticator.get_login_button(
self.config.routing.login_path, post_redirect)
return templates.TemplateResponse(template_path.name, context)
routes = [
Route(self.config.routing.landing_path,
endpoint=login,
methods=['GET'],
name='login'),
Mount(self.config.login_ui.static_path,
StaticFiles(directory=self.config.login_ui.static_directory),
name='static-login')
]
return routes
def test_templates(tmpdir):
path = os.path.join(tmpdir, "index.html")
with open(path, "w") as file:
file.write(
"<html>Hello, <a href='{{ url_for('homepage') }}'>world</a></html>"
)
app = Starlette(debug=True)
templates = Jinja2Templates(directory=str(tmpdir))
url_for_func = templates.env.globals["url_for"]
with pytest.raises(TypeError):
assert url_for_func({}, "user", "args2", name="tomchristie")
with pytest.raises(TypeError):
assert url_for_func({}, name="tomchristie")
@app.route("/")
async def homepage(request):
return templates.TemplateResponse("index.html", {"request": request})
client = TestClient(app)
response = client.get("/")
assert response.text == "<html>Hello, <a href='http://testserver/'>world</a></html>"
assert response.template.name == "index.html"
assert set(response.context.keys()) == {"request"}
async def read_item(request: Request):
templates = Jinja2Templates(
directory="/Users/dhp/Documents/j_NEW/templates")
# app.mount('/jmeter', StaticFiles(directory='jmeter_re'), name='jmeter_re')
app.mount('/',
StaticFiles(directory='/Users/dhp/Documents/j_NEW/static'),
name='static')
return templates.TemplateResponse('index.html', {"request": request})
def templates() -> Jinja2Templates:
return Jinja2Templates(
os.path.join(
os.path.dirname(__file__),
os.pardir,
os.pardir,
os.environ.get("TEMPLATE_DIR", "templates"),
))
def make_templates() -> Jinja2Templates:
jinja_templates = Jinja2Templates(directory=TEMPLATES_DIR)
jinja_templates.env.filters["unknown"] = (
lambda value: value if value is not None else "<em>(Unknown)</em>"
)
jinja_templates.env.filters["format_url"] = format_url_filter
jinja_templates.env.filters["format_image_url"] = format_image_url_filter
jinja_templates.env.globals["root_url"] = config.root_url
return jinja_templates
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# self.counter: int = 0
self.patients: Dict[int, PatientModel] = {}
self.security = HTTPBasic(auto_error=False)
self.secret_key = SECRET_KEY
self.API_KEY = SESSION_TOKEN
self.cookie_sec = APIKeyCookie(name=self.API_KEY, auto_error=False)
self.templates = Jinja2Templates(directory="templates")
self.user = {'login': '******', 'password': '******'}
def create_application(
database_url: str,
user_pool_emulator_url_base: str,
debug: bool = False,
max_pool_workers: int = 10,
region: str = "mars-east-1",
prepended_routes: typing.Iterable[BaseRoute] = [],
):
from .views import admin as admin_views
from .views import index as index_views
logging.basicConfig(
level=logging.DEBUG if debug else logging.INFO,
force=True,
)
if max_pool_workers > 0:
executor.executor = concurrent.futures.ThreadPoolExecutor(
max_workers=max_pool_workers)
session_factory.configure(bind=sa.create_engine(database_url), )
routes: typing.List[BaseRoute] = list(prepended_routes)
routes += [
Mount(
"/static",
app=StaticFiles(directory=str(basedir / "static")),
name="static",
),
Mount(
"/admin",
name="admin",
app=admin_views.routes,
),
Mount("/", index_views.routes),
]
app = Starlette(
debug=debug,
routes=routes,
middleware=[
Middleware(RequestTimeMiddleware),
Middleware(SQLAlchemyMiddleware),
Middleware(TemplateShortcutMiddleware),
],
on_shutdown=[
lambda: (executor.executor.shutdown(wait=True)
if executor.executor is not None else None),
],
)
app.state.user_pool_emulator_url_base = user_pool_emulator_url_base
app.state.region = region
app.state.templates = Jinja2Templates(directory=str(basedir / "templates"))
app.state.uuidgen = lambda: str(uuid.uuid4())
return app
class Settings(BaseSettings):
templates = Jinja2Templates(directory=Path(THIS_DIR / 'templates'))
debug: bool = False
database_url: Optional[
str] = 'postgres://postgres@localhost:5432/dungeonfinder'
class Config:
fields = {
'database_url': {
'ENV': 'DATABASE_URL'
},
'debug': {
'env': 'DEBUG'
},
}
def get_templates(template_root=None):
from property_app.config import get_config
if template_root is None:
config = get_config()
template_root = pathlib.Path(config.TEMPLATE_ROOT)
template_dir = template_root / pathlib.Path("templates")
templates = Jinja2Templates(directory=template_dir.as_posix())
jinja_env = templates.env
jinja_env.globals["asset_url"] = asset_url
return templates
def test_now_handler_for_jinja_responses():
templates = Jinja2Templates(
directory=os.path.join(BASE_DIR, "tests", "templates"))
application = Starlette(debug=True)
@application.route("/")
async def homepage(request):
template = "index.html"
context = {"request": request, "data": "John"}
return templates.TemplateResponse(template, context)
response = handler(application, get_request_event, None)
assert response["statusCode"] == 200
assert "headers" in response
breakpoint()
class AppConfig:
_config = Config(".env")
# templating configuration
templates: Jinja2Templates = Jinja2Templates(directory="templates")
change_pw_template: str = _config(
"CHANGE_PW_TEMPLATE", default="starlette_auth/change_password.html")
login_template: str = _config("LOGIN_TEMPLATE",
default="starlette_auth/login.html")
reset_pw_template: str = _config(
"RESET_PW_TEMPLATE", default="starlette_auth/password_reset.html")
reset_pw_done_template: str = _config(
"RESET_PW_DONE_TEMPLATE",
default="starlette_auth/password_reset_done.html")
reset_pw_confirm_template: str = _config(
"RESET_PW_CONFIRM_TEMPLATE",
default="starlette_auth/password_reset_confirm.html",
)
reset_pw_complete_template: str = _config(
"RESET_PW_COMPLETE_TEMPLATE",
default="starlette_auth/password_reset_complete.html",
)
# email templating configuration
reset_pw_email_subject_template: str = _config(
"RESET_PW_EMAIL_SUBJECT_TEMPLATE",
default="starlette_auth/password_reset_subject.txt",
)
reset_pw_email_template: str = _config(
"RESET_PW_EMAIL_TEMPLATE",
default="starlette_auth/password_reset_body.txt")
reset_pw_html_email_template: str = _config("RESET_PW_HTML_EMAIL_TEMPLATE",
default="")
# url configuration
change_pw_redirect_url: str = _config("CHANGE_PW_REDIRECT_URL",
default="/")
login_redirect_url: str = _config("LOGIN_REDIRECT_URL", default="/")
logout_redirect_url: str = _config("LOGOUT_REDIRECT_URL", default="/")
# general
reset_pw_timeout: int = _config("RESET_PW_TIMEOUT",
cast=int,
default=(60 * 60 * 24 * 3))
secret_key: typing.Union[str, Secret] = _config("SECRET_KEY",
cast=Secret,
default="")
def test_templates(tmpdir):
path = os.path.join(tmpdir, "index.html")
with open(path, "w") as file:
file.write("<html>Hello, <a href='{{ url_for('homepage') }}'>world</a></html>")
app = Starlette(debug=True)
templates = Jinja2Templates(directory=str(tmpdir))
@app.route("/")
async def homepage(request):
return templates.TemplateResponse("index.html", {"request": request})
client = TestClient(app)
response = client.get("/")
assert response.text == "<html>Hello, <a href='http://testserver/'>world</a></html>"
assert response.template.name == "index.html"
assert set(response.context.keys()) == {"request"}
def TemplateFolder(directory):
"""Usage:
self.templates = TemplateFolder("path")
self.app.add_route(self.templates("file.html", key=value))
"""
template_reader = Jinja2Templates(realpath(directory))
def create_template(filename, **kwargs):
def endpoint(request):
return template_reader.TemplateResponse(filename, {
"request": request,
**kwargs
})
return endpoint
return create_template
def configure_jinja(core: Core) -> Jinja2Templates:
current_dir = Path(__file__).parent.absolute()
templates = Jinja2Templates(directory=current_dir.joinpath("templates"))
templates.env.filters["timestamp"] = timestamp
templates.env.filters["dt"] = timestamp
templates.env.filters["empty"] = empty
templates.env.filters["yes_no"] = yes_no
templates.env.filters["nformat"] = nformat
templates.env.filters["n"] = nformat
templates.env.globals["config"] = core.config
templates.env.globals["now"] = datetime.utcnow
templates.env.globals["raise"] = raise_
templates.env.globals["header_info"] = partial(header_info, core)
templates.env.globals["footer_info"] = partial(footer_info, core)
templates.env.globals[
"confirm"] = """ onclick="return confirm('sure?')" """
return templates
def __init__(self, name, serial=None, debug=False):
self.name = name
self.serial = serial
self.templates = Jinja2Templates(directory=templates_dir)
self.screenshot_queues = set()
routes = [
Route("/", self.index_route),
WebSocketRoute("/ws/screenshots", self.screenshot_endpoint),
WebSocketRoute("/ws/control", self.control_endpoint),
Mount("/static", StaticFiles(directory=static_dir), name="static"),
]
Starlette.__init__(self, debug=debug, routes=routes)
async def startup_handler():
asyncio.ensure_future(self.screenshot_task())
self.add_event_handler("startup", startup_handler)
def create_app() -> Starlette:
load_dotenv()
init_logging()
debug = os.environ.get("DEBUG", "0") == "1"
app = Starlette(
debug=debug # type: ignore
)
app.templates = Jinja2Templates( # type: ignore
os.path.join(
os.path.dirname(__file__),
os.pardir,
os.environ.get("TEMPLATE_DIR", "templates"),
)
)
app = api.add_routes(app)
logger.debug("App created")
return app
def render_daily_messages(
request: Request,
days: List,
number_of_messages: List,
top_ten_accounts: List,
top_ten_engagements: List,
word_cloud: Dict,
hashtag_cloud: Dict,
):
templates = Jinja2Templates(directory="templates")
return templates.TemplateResponse(
"dashboard.html",
{
"request": request,
"days": json.dumps(days),
"number_of_messages": json.dumps(number_of_messages),
"top_ten_accounts": list(top_ten_accounts),
"top_ten_engagements": top_ten_engagements,
"word_cloud": json.dumps(word_cloud),
"hashtag_cloud": json.dumps(hashtag_cloud),
},
)
import uvicorn
from asyncpg import Connection, connect
from fastapi import FastAPI, Form
from pypika import Query, Table, Order
from starlette.config import Config
from starlette.requests import Request
from starlette.responses import JSONResponse
from starlette.staticfiles import StaticFiles
from starlette.templating import Jinja2Templates
config = Config('env')
DATABASE_URL = config('DATABASE_URL')
app = FastAPI()
app.mount('/static', StaticFiles(directory='static'), name='static')
templates = Jinja2Templates(directory='templates')
@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
start_time = time.time()
response = await call_next(request)
process_time = time.time() - start_time
print(process_time)
response.headers["X-Process-Time"] = str(process_time)
return response
async def xyt_to_feature(x, y, temperature):
return {'lat': y, 'lng': x, 'count': float(temperature)}
from fastapi import FastAPI
from starlette.templating import Jinja2Templates # new
from starlette.requests import Request
import db
from models import User, Book
app = FastAPI(title='Cazo Demo App',
description='Cazoのデモアプリ',
version='0.0.1 beta')
# new テンプレート関連の設定 (jinja2)
templates = Jinja2Templates(directory="templates")
jinja_env = templates.env # Jinja2.Environment : filterやglobalの設定用
# def index(request: Request):
# return templates.TemplateResponse('index.html',{'request': request}) # new 変更！
def index(request: Request):
# ユーザとブックを取得
# とりあえず今はmuraseのみ取得
user = db.session.query(User).filter(User.username == 'murase').first()
book = db.session.query(Book).filter(Book.user_id == user.id).all()
db.session.close()
return templates.TemplateResponse('index.html', {
'request': request,
'user': user,
'book': book
})
find_dot_env,
get_english_dt_description_from_now,
icon_class,
)
current_dir = Path(__file__).parent
config = Config(find_dot_env(current_dir))
debug = config("COMMONPLACE_DEBUG", cast=bool, default=False)
db_host = config("EDGEDB_HOST")
db_user = config("EDGEDB_USER")
db_password = config("EDGEDB_PASSWORD", cast=Secret)
db_db = config("EDGEDB_DB", default="commonplace")
db_dsn = URL(f"edgedb://{db_user}:{db_password}@{db_host}/{db_db}")
db_pool: edgedb.AsyncIOPool
templates = Jinja2Templates(directory=str(current_dir / "templates"))
logger = logging.getLogger("commonplace.app")
logger.setLevel(logging.DEBUG if debug else logging.INFO)
app = Starlette(debug=debug)
app.mount("/static", StaticFiles(directory=str(current_dir / "static")), name="static")
@app.on_event("startup")
async def startup() -> None:
global db_pool
logger.info("Creating an async connection pool to EdgeDB")
db_pool = await edgedb.create_async_pool(dsn=str(db_dsn), min_size=1, max_size=16)
from geojson_pydantic.features import Feature, FeatureCollection
from rasterio.crs import CRS
from rasterio.path import parse_path
from rasterio.warp import calculate_default_transform, transform_geom
from rio_tiler.io import COGReader
from starlette.requests import Request
from starlette.responses import HTMLResponse, Response
from starlette.templating import Jinja2Templates
from tilebench import Timer
from tilebench.middleware import NoCacheMiddleware, VSIStatsMiddleware
from tilebench.ressources.responses import GeoJSONResponse
template_dir = str(pathlib.Path(__file__).parent.joinpath("templates"))
static_dir = str(pathlib.Path(__file__).parent.joinpath("static"))
templates = Jinja2Templates(directory=template_dir)
tms = morecantile.tms.get("WebMercatorQuad")
WGS84_CRS = CRS.from_epsg(4326)
def bbox_to_feature(
bbox: Tuple[float, float, float, float], properties: Optional[Dict] = None,
) -> Feature:
"""Create a GeoJSON feature polygon from a bounding box."""
return Feature(
**{
"geometry": {
"type": "Polygon",
"coordinates": [
[
from starlette.templating import Jinja2Templates from kami.config import SITE_NAME, SITE_DESCRIPTION, DISCORD, TWITTER, FAVICON, LOGO templates = Jinja2Templates(directory="kami/templates") templates.env.globals["site_name"] = SITE_NAME templates.env.globals["site_description"] = SITE_DESCRIPTION templates.env.globals["discord_url"] = DISCORD templates.env.globals["twitter_url"] = TWITTER templates.env.globals["favicon"] = FAVICON templates.env.globals["logo"] = LOGO
