def init():
app = Starlette()
@app.on_event("startup")
async def async_setup():
await pg_init()
@app.exception_handler(JSONDecodeError)
async def bad_json(request, exc):
return JSONResponse({'reason': 'invalid json', 'details': str(exc)}, status_code=400)
@app.exception_handler(InsufficientPermissionsError)
async def handle_permissions(request, exc):
return JSONResponse({'reason': 'you are not authorized to do that dave'}, status_code=403)
# auth stuff
auth = GoogleAuthBackend(GOOGLE_ID, GOOGLE_SECRET, GOOGLE_ORG)
app.add_middleware(AuthenticationMiddleware,
backend=auth,
on_error=auth.on_error)
app.add_middleware(SessionMiddleware, session_cookie=COOKIE_NAME,
secret_key=COOKIE_KEY, https_only=not LOCAL_DEV,
max_age=2 * 24 * 60 * 60) # 2 days
# sentry stuff
sentry_sdk.init(dsn=SENTRY_URL, environment=ENV_NAME)
app.add_middleware(SentryMiddleware)
async def index_html(request):
static = pathlib.Path('tmeister/static/index.html')
return HTMLResponse(static.read_text())
app.add_route('/api/envs/{name}/toggles', toggles.get_toggle_states_for_env, methods=['GET'])
app.add_route('/api/toggles', toggles.get_all_toggle_states, methods=['GET'])
app.add_route('/api/toggles', toggles.set_toggle_state, methods=['PATCH'])
app.add_route('/api/features', features.get_features)
app.add_route('/api/features', features.create_feature, methods=['POST'])
app.add_route('/api/features/{name}', features.delete_feature, methods=['DELETE'])
app.add_route('/api/envs', environments.get_envs)
app.add_route('/api/envs', environments.add_env, methods=['POST'])
app.add_route('/api/envs/{name}', environments.delete_env, methods=['DELETE'])
app.add_route('/api/auditlog', auditing.get_audit_events)
app.add_route('/heartbeat', health.get_health)
app.add_route('/', index_html)
app.mount('/', app=StaticFiles(directory='tmeister/static'), name='static')
return app
@pytest.fixture(autouse=True)
async def create_database():
engine = await gino.create_engine('postgresql://*****:*****@localhost/test')
try:
print("creating Database")
await db.gino.create_all(engine)
yield
finally:
await db.gino.drop_all(engine)
await engine.close()
app = Starlette()
app.add_middleware(DatabaseMiddleware, db=db, database_url=database_url)
@app.route('/users', methods=['GET', 'POST'])
async def users(request):
if request.method == 'GET':
users = await User.query.gino.all()
result = []
for user in users:
result.append({'id': user.id, 'name': user.name})
return JSONResponse({'status': 'success', 'message': result})
if request.method == 'POST':
body = await request.json()
result = await User.create(**body)
return JSONResponse({'status': 'success', 'message': 'Data Saved'})
def create_app():
app = Starlette()
app.add_route("/session_initialized", session_initialized)
app.add_route("/session_not_initialized", session_not_initialized)
app.add_middleware(DatabaseMiddleware)
return app
elapsed_time = time.perf_counter() - start
except Exception as e:
metric_provider.counter("server.call.exception.counter", tags=tags)
raise e from None
else:
tags.update({"status_code": response.status_code})
metric_provider.timer("server.call.elapsed",
value=elapsed_time,
tags=tags)
metric_provider.counter("server.call.counter", tags=tags)
return response
# we add a middleware class for logging exceptions to Sentry
app.add_middleware(SentryMiddleware)
# we add a middleware class for capturing metrics using Dispatch's metrics provider
app.add_middleware(MetricsMiddleware)
# we install all the plugins
install_plugins()
# we add all the plugin event API routes to the API router
install_plugin_events(api_router)
# we add all API routes to the Web API framework
api.include_router(api_router, prefix="/v1")
# we mount the frontend and app
if STATIC_DIR:
from starlette.responses import PlainTextResponse
from starlette.middleware.cors import CORSMiddleware
import base64
import ssl
# load learner for fast.ai
from fastai import *
from fastai.vision import *
defaults.device = torch.device('cpu')
from io import BytesIO
import uvicorn
app = Starlette()
# !! USE ONLY WHEN JSON SERVER IS DIFFERENT THAN HTTP SERVER !! #
app.add_middleware(CORSMiddleware, allow_origins=['*'])
# To check if server working
@app.route("/ping", methods=["get"])
async def ping(request):
return JSONResponse({"isWorking": "Yes"})
@app.route("/movies_cold", methods=["POST"])
async def movies_cold(request):
return PlainTextResponse(m.movies.sample(20).to_json(orient='records'))
@app.route("/movies_get", methods=["POST"])
"""
template = "404.html"
context = get_request_context(request)
return templates.TemplateResponse(template, context, status_code=404)
@app.exception_handler(500)
async def server_error(request, exc):
"""
Return an HTTP 500 page.
"""
template = "500.html"
context = get_request_context(request)
return templates.TemplateResponse(template, context, status_code=500)
BUCKET_NAME = os.environ.get("BUCKET_NAME", None)
REGION_NAME = os.environ.get("REGION_NAME", None)
S3_AWS_ACCESS_KEY_ID = os.environ.get("S3_AWS_ACCESS_KEY_ID")
S3_AWS_SECRET_ACCESS_KEY = os.environ.get("S3_AWS_SECRET_ACCESS_KEY")
app.add_middleware(
S3StorageMiddleware,
bucket_name=BUCKET_NAME,
region_name=REGION_NAME,
aws_access_key_id=S3_AWS_ACCESS_KEY_ID,
aws_secret_access_key=S3_AWS_SECRET_ACCESS_KEY,
static_dir="static",
)
handler = Mangum(app)
from starlette.applications import Starlette
from starlette.graphql import GraphQLApp
from starlette.middleware.authentication import AuthenticationMiddleware
from graphql.execution.executors.asyncio import AsyncioExecutor
from .models import schema
from .utils.authentication import JWTAuthenticationBackend
from config.settings import (
DEBUG,
DATABASE_URL,
SECRET_KEY,
JWT_ALGORITHM,
DatabaseMiddleware,
)
app = Starlette()
app.debug = DEBUG
app.add_middleware(
AuthenticationMiddleware,
backend=JWTAuthenticationBackend(SECRET_KEY, JWT_ALGORITHM),
)
app.add_middleware(DatabaseMiddleware, database_url=DATABASE_URL)
app.add_route("/query", GraphQLApp(schema=schema, executor=AsyncioExecutor()))
from starlette import status
from starlette.applications import Starlette
from starlette.background import BackgroundTask
from starlette.middleware.cors import CORSMiddleware
from starlette.middleware.trustedhost import TrustedHostMiddleware
from starlette.requests import Request
from starlette.responses import JSONResponse, PlainTextResponse
from starlette_prometheus import PrometheusMiddleware, metrics
from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware
from src import config, store, task
logger = logging.getLogger(__name__)
app = Starlette()
app.add_middleware(PrometheusMiddleware)
app.add_route("/metrics", metrics)
if config.DEBUG:
logger.setLevel(logging.DEBUG)
else:
app.add_middleware(ProxyHeadersMiddleware)
app.add_middleware(TrustedHostMiddleware,
allowed_hosts=config.LOCAL_NETWORKS)
app.add_middleware(CORSMiddleware, allow_origins=config.LOCAL_NETWORKS)
@app.exception_handler(status.HTTP_403_FORBIDDEN)
@app.exception_handler(status.HTTP_404_NOT_FOUND)
@app.exception_handler(status.HTTP_500_INTERNAL_SERVER_ERROR)
if "Authorization" not in request.headers:
return None
auth = request.headers["Authorization"]
try:
scheme, credentials = auth.split()
decoded = base64.b64decode(credentials).decode("ascii")
except (ValueError, UnicodeDecodeError, binascii.Error) as exc:
raise AuthenticationError("Invalid basic auth credentials")
username, _, password = decoded.partition(":")
return AuthCredentials(["authenticated"]), SimpleUser(username)
app = Starlette()
app.add_middleware(AuthenticationMiddleware, backend=BasicAuth())
@app.route("/")
def homepage(request):
return JSONResponse(
{
"authenticated": request.user.is_authenticated,
"user": request.user.display_name,
}
)
@app.route("/dashboard")
@requires("authenticated")
async def dashboard(request):
tasks.add_task(sync_bg_task)
return PlainTextResponse("Hello, world!", background=tasks)
async def async_bg_task():
pass
def sync_bg_task():
pass
routes = [
Route("/async", run_async_bg_task),
Route("/sync", run_sync_bg_task),
]
# Generating target applications
target_application = {}
app = Starlette(routes=routes)
app.add_middleware(ASGIStyleMiddleware)
target_application["asgi"] = AsgiTest(app)
app = Starlette(routes=routes)
app.add_middleware(BaseHTTPStyleMiddleware)
target_application["basehttp"] = AsgiTest(app)
app = Starlette(routes=routes)
target_application["none"] = AsgiTest(app)
from starlette.staticfiles import StaticFiles
from starlette.responses import HTMLResponse
from starlette.templating import Jinja2Templates
from starlette.middleware.gzip import GZipMiddleware
from hello_v1.endpoints import hello_api as hello_v1
from hello_v2.endpoints import hello_api as hello_v2
import uvicorn
import logging
logger = logging.getLogger(__name__)
templates = Jinja2Templates(directory='templates')
app = Starlette(debug=True)
app.add_middleware(GZipMiddleware, minimum_size=1000)
app.mount('/static', StaticFiles(directory='statics'), name='static')
app.mount('/hello/v1', app=hello_v1)
app.mount('/hello/v2', app=hello_v2)
@app.route('/')
async def homepage(request):
template = "index.html"
context = {"request": request}
return templates.TemplateResponse(template, context)
@app.route('/error')
async def error(request):
# -*- coding: utf-8 -*-
from unittest.mock import MagicMock, call, patch
from starlette.applications import Starlette
from starlette.middleware.sessions import SessionMiddleware
from starlette.responses import PlainTextResponse
from starlette.testclient import TestClient
from keycloak.constants import GrantTypes
from keycloak.extensions.starlette import AuthenticationMiddleware
from keycloak.utils import auth_header
app = Starlette()
app.add_middleware(
AuthenticationMiddleware,
callback_url="http://testserver/kc/callback",
login_redirect_uri="/howdy",
logout_redirect_uri="/logout",
)
app.add_middleware(SessionMiddleware, secret_key="key0123456789")
@app.route("/howdy")
async def howdy(request):
return PlainTextResponse("Howdy!")
@app.route("/logout")
async def logout(request):
return PlainTextResponse("Logged out!")
def app(self):
app_ = Starlette()
app_.add_middleware(PrometheusMiddleware, filter_unhandled_paths=True)
app_.add_route("/metrics/", metrics)
return app_
from starlette.staticfiles import StaticFiles
from starlette.templating import Jinja2Templates
from starlette.routing import Route
export_file_url = 'https://drive.google.com/uc?id=190SxQMkQO-7HX46Pw7URQKZrBrQTqL8v&export=download' #'https://drive.google.com/uc?export=download&id=1U6vmC0eY_ejOvFvHIjXUsvI7Jsn31SRd'
export_file_name = 'export.pkl'
classes = ['apple', 'banana', 'strawberry']
path = Path(__file__).parent
templates = Jinja2Templates(directory=str('app/templates'))
app = Starlette()
app.add_middleware(CORSMiddleware,
allow_origins=['*'],
allow_headers=['*'],
allow_methods=['*'],
allow_credentials=['*'])
# app.mount('/static', StaticFiles(directory='app/static'))
app.mount('/templates', StaticFiles(directory='app/templates'))
async def download_file(url, dest):
if dest.exists(): return
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
data = await response.read()
with open(dest, 'wb') as f:
f.write(data)
except KeyError: # pragma: no cover
pytest.skip("DATABASE_URL is not set", allow_module_level=True)
metadata = sqlalchemy.MetaData()
notes = sqlalchemy.Table(
"notes",
metadata,
sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
sqlalchemy.Column("text", sqlalchemy.String),
sqlalchemy.Column("completed", sqlalchemy.Boolean),
)
app = Starlette()
app.add_middleware(
DatabaseMiddleware, database_url=DATABASE_URL, rollback_on_shutdown=True
)
@pytest.fixture(autouse=True, scope="module")
def create_test_database():
engine = sqlalchemy.create_engine(DATABASE_URL)
metadata.create_all(engine)
yield
engine.execute("DROP TABLE notes")
@app.route("/notes", methods=["GET"])
async def list_notes(request):
query = notes.select()
results = await request.database.fetchall(query)
def setup_middleware(app: Starlette) -> None:
app.add_middleware(AuthMiddleware)
from starlette.middleware import Middleware
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.responses import PlainTextResponse
from starlette.routing import Route
from starlette.testclient import TestClient
class CustomMiddleware(BaseHTTPMiddleware):
async def dispatch(self, request, call_next):
response = await call_next(request)
response.headers["Custom-Header"] = "Example"
return response
app = Starlette()
app.add_middleware(CustomMiddleware)
@app.route("/")
def homepage(request):
return PlainTextResponse("Homepage")
@app.route("/exc")
def exc(request):
raise Exception()
@app.route("/no-response")
class NoResponse:
def __init__(self, scope, receive, send):
from starlette.middleware.cors import CORSMiddleware
from starlette.responses import HTMLResponse, JSONResponse
from starlette.staticfiles import StaticFiles
export_file_url = (
"https://drive.google.com/uc?export=download&id=1-1qWJ8qX_eRZfap2tC4RDVbuijB39oDS"
)
export_file_name = "export.pkl"
classes = ["bracelet", "earring", "necklace", "ring"]
path = Path(__file__).parent
app = Starlette()
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_headers=["X-Requested-With", "Content-Type"],
)
app.mount("/static", StaticFiles(directory="app/static"))
class SaveFeatures:
features = None
def __init__(self, m):
self.hook = m.register_forward_hook(self.hook_fn)
self.features = None
def hook_fn(self, module, input, output):
out = output.detach().cpu().numpy()
if isinstance(self.features, type(None)):
from prometheus_client import Counter
ERROR_COUNT = Counter(
"failed_call", "Counts of calls that failed", ("to",))
async def main(request: Request) -> JSONResponse:
async with httpx.AsyncClient(timeout=1.0) as c:
try:
r = await c.get("http://middle:8001")
value = r.json().get('value')
request.app.last_value = value
return JSONResponse({"value": value})
except httpx.TransportError as x:
ERROR_COUNT.labels("middle").inc()
logging.error(
"Failed to talk with the middle service", exc_info=True)
return JSONResponse(
{
"error": x.__class__.__name__,
"value": request.app.last_value
}, status_code=200)
app = Starlette(debug=True, routes=[
Route('/', main),
])
app.last_value = 0
app.add_middleware(PrometheusMiddleware)
app.add_route("/metrics", handle_metrics)
from starlette.applications import Starlette
from starlette.requests import Request
from starlette.responses import JSONResponse
import uvicorn
from starlette_context import context
from starlette_context.middleware import ContextMiddleware
app = Starlette(debug=True)
@app.route("/")
async def index(request: Request):
context["view"] = True
return JSONResponse(context.data)
class ContextFromMiddleware(ContextMiddleware):
async def set_context(self, request: Request) -> dict:
return {"middleware": True}
app.add_middleware(ContextFromMiddleware)
uvicorn.run(app, host="0.0.0.0")
@router.route("/post", methods=["POST"])
async def post(request: HTTPConnection):
form = await request.form()
form = PostForm(form)
name = form.name.data
message = form.message.data
posts = request.session.get("posts")
if posts is None:
posts = []
request.session["posts"] = posts
posts.append((name, message))
return templates.TemplateResponse(
"main.j2",
{
"request": request,
"form": form,
"posts": posts,
"post_create": request.url_for("post"),
},
)
app = Starlette(routes=[Mount("/ssti", app=router)])
app.add_middleware(SessionMiddleware, secret_key="doesntmatter")
async def index_html(request):
logging.info('index page request')
return html_templates.TemplateResponse('index.html', {
'request': request,
})
routes = [
Route('/', index_html, methods=['GET'], name='homepage'),
]
app = Starlette(debug=False, routes=routes)
app.add_middleware(
TimingMiddleware,
client=PrintTimings(),
metric_namer=StarletteScopeToName(prefix='', starlette_app=app),
)
app_log = logging.StreamHandler()
formatter = logging.Formatter(
'%(asctime)s %(process)s %(levelname)s %(name)s %(message)s'
) # noqa: WPS323
app_log.setFormatter(formatter)
logger = logging.getLogger()
logger.handlers = []
logger.addHandler(app_log)
logger.setLevel(logging.INFO)
import os
from starlette.applications import Starlette
from starlette.endpoints import HTTPEndpoint
from starlette.exceptions import HTTPException
from starlette.middleware.trustedhost import TrustedHostMiddleware
from starlette.responses import JSONResponse, PlainTextResponse
from starlette.routing import Host, Mount, Route, Router, WebSocketRoute
from starlette.staticfiles import StaticFiles
from starlette.testclient import TestClient
app = Starlette()
app.add_middleware(TrustedHostMiddleware,
allowed_hosts=["testserver", "*.example.org"])
@app.exception_handler(500)
async def error_500(request, _exc):
return JSONResponse({"detail": "Server Error"}, status_code=500)
@app.exception_handler(405)
async def method_not_allowed(request, _exc):
return JSONResponse({"detail": "Custom message"}, status_code=405)
@app.exception_handler(HTTPException)
async def http_exception(request, exc):
return JSONResponse({"detail": exc.detail}, status_code=exc.status_code)
# The app will not start with this value, forcing the users to set their onw secret
# key. Therefore, the value is used as default here as well.
SECRET_KEY = webgui_config('SECRET_KEY',
cast=Secret,
default="PutSomethingRandomHere")
WEBGUI_PORT = webgui_config('PORT', cast=int, default=8000)
WEBGUI_HOST = webgui_config('HOST', default='0.0.0.0')
DEBUG_MODE = webgui_config('DEBUG', cast=bool, default=True)
app = Starlette(debug=DEBUG_MODE)
# Don't check the existence of the static folder because the wrong parent folder is used if the
# source code is parsed by sphinx. This would raise an exception and lead to failure of sphinx.
app.mount('/static',
StaticFiles(directory='webinterface/statics', check_dir=False),
name='static')
app.add_middleware(AuthenticationMiddleware, backend=SessionAuthBackend())
app.add_middleware(SessionMiddleware,
secret_key=SECRET_KEY,
session_cookie="mercure_session")
app.mount("/modules", modules.modules_app)
app.mount("/queue", queue.queue_app)
async def async_run(cmd):
"""Executes the given command in a way compatible with ayncio."""
proc = await asyncio.create_subprocess_shell(
cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
stdout, stderr = await proc.communicate()
return proc.returncode, stdout, stderr
from gino import Gino
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette_gino.middleware import DatabaseMiddleware
db = Gino()
app = Starlette(debug=True)
app.add_middleware(DatabaseMiddleware,
db=db,
database_url='postgresql://*****:*****@localhost/test')
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
fullname = db.Column(db.String)
def __str__(self):
return "%s - %s" % (self.id, self.name)
class Address(db.Model):
__tablename__ = 'addresses'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(None, db.ForeignKey('users.id'))
email_address = db.Column(db.String, nullable=False)
from starlette.applications import Starlette
from starlette.requests import Request
from starlette.responses import JSONResponse
from starlette.routing import Route
from starlette_session import SessionMiddleware
async def setup_session(request: Request) -> JSONResponse:
request.session.update({"data": "session_data"})
return JSONResponse({"session": request.session})
async def clear_session(request: Request):
request.session.clear()
return JSONResponse({"session": request.session})
async def view_session(request: Request) -> JSONResponse:
return JSONResponse({"session": request.session})
routes = [
Route("/setup_session", endpoint=setup_session),
Route("/clear_session", endpoint=clear_session),
Route("/view_session", endpoint=view_session),
]
app = Starlette(debug=True, routes=routes)
app.add_middleware(SessionMiddleware, secret_key="secret", cookie_name="cookie22")
import graphene
from graphql.execution.executors.asyncio import AsyncioExecutor
from starlette.applications import Starlette
from starlette.graphql import GraphQLApp
from starlette.middleware.cors import CORSMiddleware
from blenheim.schema.schema import Query, Mutations
from blenheim.schema.settings.settings import SettingsMutations
app = Starlette()
app.add_middleware(CORSMiddleware,
allow_origins=['*'],
allow_headers=['*'],
allow_methods=["POST"])
# noinspection PyTypeChecker
app.add_route(
'/',
GraphQLApp(schema=graphene.Schema(query=Query, mutation=Mutations),
executor_class=AsyncioExecutor))
if "Authorization" not in request.headers:
return None
auth = request.headers["Authorization"]
try:
scheme, credentials = auth.split()
decoded = base64.b64decode(credentials).decode("ascii")
except (ValueError, UnicodeDecodeError, binascii.Error):
raise AuthenticationError("Invalid basic auth credentials")
username, _, password = decoded.partition(":")
return AuthCredentials(["authenticated"]), SimpleUser(username)
app = Starlette()
app.add_middleware(AuthenticationMiddleware, backend=BasicAuth())
@app.route("/")
def homepage(request):
return JSONResponse(
{
"authenticated": request.user.is_authenticated,
"user": request.user.display_name,
}
)
@app.route("/dashboard")
@requires("authenticated")
async def dashboard(request):
from starlette.staticfiles import StaticFiles
from starlette.middleware.cors import CORSMiddleware
import uvicorn, aiohttp, asyncio
from io import BytesIO
from fastai import *
from fastai.vision import *
model_file_url = 'https://drive.google.com/uc?export=download&id=1hruHBDzJ0lPegIkAK3PJYyxHfjFR2M68'
model_file_name = 'model'
classes = ['cheetah', 'leopard']
path = Path(__file__).parent
app = Starlette()
app.add_middleware(CORSMiddleware,
allow_origins=['*'],
allow_headers=['X-Requested-With', 'Content-Type'])
app.mount('/static', StaticFiles(directory='app/static'))
async def download_file(url, dest):
if dest.exists(): return
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
data = await response.read()
with open(dest, 'wb') as f:
f.write(data)
async def setup_learner():
await download_file(model_file_url,
NECRO_BASE = os.getenv('NECRO_BASE')
if not NECRO_BASE:
log.warning('NECRO_BASE env var is not defined. Elasticsearch queries to '
'necropolis will not work!')
def http_exception_handler(request, exc):
# We assume that an HTTPException, which has been raised by our code,
# has already been logged.
return JSONResponse(exc.detail, status_code=exc.status_code)
def validation_exception_handler(request, exc):
return JSONResponse(exc.messages, status_code=400)
def misc_exception_handler(request, exc):
log.exception(exc)
return JSONResponse('Unexpected error', status_code=500)
app = Starlette(debug=False)
app.mount('', Router(routes.routes))
app.add_exception_handler(HTTPException, http_exception_handler)
app.add_exception_handler(ValidationError, validation_exception_handler)
app.add_exception_handler(Exception, misc_exception_handler)
app.add_middleware(CORSMiddleware,
allow_origins=['*'],
allow_methods=['GET', 'POST'])
from starlette.staticfiles import StaticFiles
from starlette.middleware.cors import CORSMiddleware
import uvicorn, aiohttp, asyncio
from io import BytesIO
from fastai.vision import ImageDataBunch, create_cnn, open_image, get_transforms, imagenet_stats, models
from fastai import Path
model_file_url = 'https://www.dropbox.com/s/y4kl2gv1akv7y4i/stage-2.pth?raw=1'
model_file_name = 'model'
classes = ['black', 'grizzly', 'teddys']
path = Path(__file__).parent
app = Starlette()
app.add_middleware(CORSMiddleware, allow_origins=['*'], allow_headers=['X-Requested-With', 'Content-Type'])
app.mount('/static', StaticFiles(directory='app/static'))
async def download_file(url, dest):
if dest.exists(): return
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
data = await response.read()
with open(dest, 'wb') as f: f.write(data)
async def setup_learner():
await download_file(model_file_url, path/'models'/f'{model_file_name}.pth')
data_bunch = ImageDataBunch.single_from_classes(path, classes,
tfms=get_transforms(), size=224).normalize(imagenet_stats)
learn = create_cnn(data_bunch, models.resnet34, pretrained=False)
learn.load(model_file_name)
async def index(request):
results = "Home page"
return templates.TemplateResponse("index.html", {
"request": request,
"results": results
})
routes = [
Route("/", index),
]
app = Starlette(debug=True, routes=routes)
app.mount("/static", StaticFiles(directory="static"), name="static")
app.mount("/accounts", accounts_routes)
app.add_middleware(AuthenticationMiddleware, backend=UserAuthentication())
app.add_middleware(SessionMiddleware, secret_key=SECRET_KEY)
# middleware for secure headers
@app.middleware("http")
async def set_secure_headers(request, call_next):
response = await call_next(request)
secure_headers.starlette(response)
return response
@app.exception_handler(404)
async def not_found(request, exc):
"""
Return an HTTP 404 page.
