templates = Jinja2Templates(directory="templates")
templates.env.filters["power"] = format_power
templates.env.filters["distance"] = format_length
templates.env.filters["voltage"] = format_voltage
templates.env.filters["percent"] = format_percent
templates.env.filters["country_name"] = country_name
templates.env.globals["osm_link"] = osm_link
app = Starlette(
debug=DEBUG,
on_startup=[database.connect],
on_shutdown=[database.disconnect],
routes=[
Mount("/static", app=StaticFiles(directory="static"), name="static"),
Route("/sitemap.xml", sitemap),
],
)
@app.route("/")
async def main(request):
# Dummy response - this endpoint is served statically in production from the webpack build
return PlainTextResponse("")
@app.route("/about")
@cache_for(3600)
async def about(request):
return templates.TemplateResponse("about.html", {"request": request})
def create_app() -> Starlette:
routes = [
Route("/", Homepage, name="home"),
Mount("/assets", StaticFiles(directory="kami/static"), name="static"),
Route("/login", Login, name="login"),
Route("/logout", Logout, name="logout"),
Mount("/dashboard",
routes=[
Route("/", Dashboard, name="dashboard"),
Mount("/account",
routes=[
Route("/security",
SecurityEndpoint,
name="security"),
Route("/security/changepassword",
ChangePassword,
name="changepassword")
]),
Mount("/admin",
routes=[
Route("/anime", AnimeEndpoint, name="anime"),
Route("/anime/add", AnimeAdd, name="anime_add"),
Route("/anime/remove",
AnimeRemove,
name="anime_remove"),
Route("/anime/edit/{id:int}",
AnimeEdit,
name="anime_edit"),
Route("/fansub", FansubEndpoint, name="fansub"),
Route("/fansub/add", FansubAdd, name="fansub_add"),
Route("/fansub/remove",
FansubRemove,
name="fansub_remove"),
Route("/fansub/edit/{id:int}",
FansubEdit,
name="fansub_edit"),
Route("/pages", PagesEndpoint, name="pages"),
Route("/pages/add", PagesAdd, name="pages_add"),
Route("/pages/remove",
PagesRemove,
name="pages_remove"),
Route("/pages/edit/{id:int}",
PagesEdit,
name="pages_edit")
])
]),
Route("/{slug}", PagesGet, name="pages_get")
]
exceptions = {404: not_found}
middleware = [
Middleware(TrustedHostMiddleware, allowed_hosts=list(ALLOWED_HOSTS)),
Middleware(JwtMiddleware),
Middleware(PagesMiddleware)
]
app = Starlette(debug=DEBUG,
routes=routes,
exception_handlers=exceptions,
middleware=middleware)
return app
from starlette.applications import Starlette
from starlette.routing import Route, Mount
from starlette.responses import JSONResponse
from starlette.graphql import GraphQLApp
from starlette.staticfiles import StaticFiles
import graphene
from geolite2 import geolite2
from visual_attacks.schema import schema
async def geoip(request):
reader = geolite2.reader()
latlons = []
for ip in await request.json():
info = reader.get(ip)
if info and "location" in info:
loc = info["location"]
latlons.append({'lat': loc['latitude'], 'lng': loc['longitude']})
return JSONResponse(latlons)
routes = [
Route('/api', GraphQLApp(schema=schema, graphiql=True)),
Route('/geoip', geoip, methods=["POST"]),
Mount('/',
app=StaticFiles(directory='visualization-frontend/dist', html=True)),
]
app = Starlette(routes=routes)
def test_mount_at_root():
mounted = Router([Mount("/", ok, name="users")])
client = TestClient(mounted)
assert client.get("/").status_code == 200
import sys, requests, uvicorn, uuid
from utils.utilities import Utilities
from FHIR.utilities import Utilities
from FHIR.create import create
from translation.FHIRTranslation import FHIRTranslation
from translation.translationConstants import TranslationConstants
from starlette.applications import Starlette
from starlette.responses import JSONResponse
from starlette.routing import Mount, Route, Router
from xml.etree import ElementTree
router = Router([Mount("/create", app=create)])
app = Starlette(debug=True)
app.mount("", router)
def getPatient(id):
return ElementTree.parse(
'../example-ehr-data/' + TranslationConstants.EHR_PATH +
("-extract" if TranslationConstants.DEMO else "-full") + '.xml').find(
TranslationConstants.EHR_ENTRY_POINT)
@app.route("/simulateTranslatePatient")
def simulateTranslatePatient(request):
FHIRTranslation.translatePatient(getPatient("4917111072"))
trace = f"switch mail trigger {trigger_id}"
content = {'errors': ''}
console.print(trace, style="blue")
else:
content = {'errors': {'message': 'Trigger id is missing'}}
console.print(f"error during switch status trigger", style="red")
return JSONResponse(content)
# The API Routes
api = Router(routes=[
Mount('/yeoboseyo', app=Router([
Route('/', endpoint=get_all, methods=['GET']),
Route('/{trigger_id}', endpoint=get, methods=['GET']),
Route('/', endpoint=create, methods=['POST']),
Route('/{trigger_id}', endpoint=update, methods=['PATCH']),
Route('/{trigger_id}', endpoint=delete, methods=['DELETE']),
Route('/switch/{switch_type}/{trigger_id:int}', switch, methods=['PATCH'], name='switch'),
]))
])
app = Starlette(
debug=True,
routes=[
Route('/', homepage, methods=['GET'], name='homepage'),
Mount('/static', StaticFiles(directory="static")),
],
)
main_app.mount('/api', app=api)
main_app.mount('/', app=app)
resp=Response(HTTP_200=Resp, HTTP_401=None),
tags=['api', 'test'])
async def user_score(request):
score = [randint(0, request.context.json.limit) for _ in range(5)]
score.sort(reverse=request.context.query.order)
assert request.context.cookies.pub == 'abcdefg'
assert request.cookies['pub'] == 'abcdefg'
return JSONResponse({'name': request.context.json.name, 'score': score})
app = Starlette(routes=[
Route('/ping', Ping),
Mount('/api',
routes=[
Mount('/user',
routes=[
Route('/{name}', user_score, methods=['POST']),
])
])
])
api.register(app)
@pytest.fixture
def client():
with TestClient(app) as client:
yield client
def test_starlette_validate(client):
resp = client.get('/ping')
from starlette.middleware.gzip import GZipMiddleware
from starlette.middleware.sessions import SessionMiddleware
from starlette.routing import Mount, Route
from starlette.staticfiles import StaticFiles
from app import admin, db, endpoints, globals, handlers, settings
starlette_admin.config.templates = globals.templates
starlette_auth.config.templates = globals.templates
static = StaticFiles(directory="static", packages=["starlette_admin"])
staticapp = GZipMiddleware(static)
routes = [
Route("/", endpoints.Home, methods=["GET"], name="home"),
Mount("/admin", app=admin.adminsite, name=admin.adminsite.name),
Mount("/auth", app=starlette_auth.app, name="auth"),
Mount("/static", app=staticapp, name="static"),
]
middleware = [
Middleware(starlette_core.middleware.DatabaseMiddleware),
Middleware(CORSMiddleware, allow_origins=settings.ALLOWED_HOSTS),
Middleware(SessionMiddleware, secret_key=settings.SECRET_KEY),
Middleware(AuthenticationMiddleware,
backend=starlette_auth.ModelAuthBackend()),
]
exception_handlers = {
404: handlers.not_found,
500: handlers.server_error,
from starlette.routing import Mount, Route, Router
from .websocket import websockets_routes
from .users import users_routes
# mounted app can also be an instance of `Router()`
routes = Router([
# Route('/', endpoint=Homepage, methods=['GET']),
Mount('/users', app=users_routes),
Mount('/ws', app=websockets_routes),
])
def __init__(self,
enablePiCamera=False,
stabilize=False,
source=None,
camera_num=0,
stream_mode=False,
backend=0,
colorspace=None,
resolution=(640, 480),
framerate=25,
logging=False,
time_delay=0,
**options):
"""
This constructor method initializes the object state and attributes of the WebGear_RTC class.
Parameters:
enablePiCamera (bool): provide access to PiGear(if True) or CamGear(if False) APIs respectively.
stabilize (bool): enable access to Stabilizer Class for stabilizing frames.
camera_num (int): selects the camera module index which will be used as Rpi source.
resolution (tuple): sets the resolution (i.e. `(width,height)`) of the Rpi source.
framerate (int/float): sets the framerate of the Rpi source.
source (based on input): defines the source for the input stream.
stream_mode (bool): controls the exclusive YouTube Mode.
backend (int): selects the backend for OpenCV's VideoCapture class.
colorspace (str): selects the colorspace of the input stream.
logging (bool): enables/disables logging.
time_delay (int): time delay (in sec) before start reading the frames.
options (dict): provides ability to alter Tweak Parameters of WebGear_RTC, CamGear, PiGear & Stabilizer.
"""
# raise error(s) for critical Class imports
import_dependency_safe("starlette" if starlette is None else "")
import_dependency_safe("aiortc" if aiortc is None else "")
# initialize global params
self.__logging = logging
custom_data_location = "" # path to save data-files to custom location
data_path = "" # path to WebGear_RTC data-files
overwrite_default = False
self.__relay = None # act as broadcaster
# reformat dictionary
options = {str(k).strip(): v for k, v in options.items()}
# assign values to global variables if specified and valid
if options:
if "custom_data_location" in options:
value = options["custom_data_location"]
if isinstance(value, str):
assert os.access(
value, os.W_OK
), "[WebGear_RTC:ERROR] :: Permission Denied!, cannot write WebGear_RTC data-files to '{}' directory!".format(
value)
assert os.path.isdir(
os.path.abspath(value)
), "[WebGear_RTC:ERROR] :: `custom_data_location` value must be the path to a directory and not to a file!"
custom_data_location = os.path.abspath(value)
else:
logger.warning(
"Skipped invalid `custom_data_location` value!")
del options["custom_data_location"] # clean
if "overwrite_default_files" in options:
value = options["overwrite_default_files"]
if isinstance(value, bool):
overwrite_default = value
else:
logger.warning(
"Skipped invalid `overwrite_default_files` value!")
del options["overwrite_default_files"] # clean
if "enable_live_broadcast" in options:
value = options["enable_live_broadcast"]
if isinstance(value, bool):
if value:
self.__relay = MediaRelay()
options[
"enable_infinite_frames"] = True # enforce infinite frames
logger.critical(
"Enabled live broadcasting for Peer connection(s)."
)
else:
None
else:
logger.warning(
"Skipped invalid `enable_live_broadcast` value!")
del options["enable_live_broadcast"] # clean
# check if custom certificates path is specified
if custom_data_location:
data_path = generate_webdata(
custom_data_location,
c_name="webgear_rtc",
overwrite_default=overwrite_default,
logging=logging,
)
else:
# otherwise generate suitable path
data_path = generate_webdata(
os.path.join(expanduser("~"), ".vidgear"),
c_name="webgear_rtc",
overwrite_default=overwrite_default,
logging=logging,
)
# log it
if self.__logging:
logger.debug(
"`{}` is the default location for saving WebGear_RTC data-files."
.format(data_path))
# define Jinja2 templates handler
self.__templates = Jinja2Templates(
directory="{}/templates".format(data_path))
# define custom exception handlers
self.__exception_handlers = {
404: self.__not_found,
500: self.__server_error
}
# define routing tables
self.routes = [
Route("/", endpoint=self.__homepage),
Route("/offer", self.__offer, methods=["GET", "POST"]),
Mount(
"/static",
app=StaticFiles(directory="{}/static".format(data_path)),
name="static",
),
]
# define middleware support
self.middleware = []
# Handle RTC video server
if source is None:
self.config = {"server": None}
self.__default_rtc_server = None
if self.__logging:
logger.warning("Given source is of NoneType!")
else:
# Handle video source
self.__default_rtc_server = RTC_VideoServer(
enablePiCamera=enablePiCamera,
stabilize=stabilize,
source=source,
camera_num=camera_num,
stream_mode=stream_mode,
backend=backend,
colorspace=colorspace,
resolution=resolution,
framerate=framerate,
logging=logging,
time_delay=time_delay,
**options)
# define default frame generator in configuration
self.config = {"server": self.__default_rtc_server}
# add exclusive reset connection node
self.routes.append(
Route("/close_connection",
self.__reset_connections,
methods=["POST"]))
# copying original routing tables for further validation
self.__rt_org_copy = self.routes[:]
# collects peer RTC connections
self.__pcs = set()
import uvicorn
from starlette.applications import Starlette
from starlette.middleware.authentication import AuthenticationMiddleware
from starlette.responses import PlainTextResponse
from starlette.routing import Mount
from starlette_api.users import UsersApp, auth
from starlette_api.warehouse import WarehouseApp
from . import settings
from .database import database
routes = [Mount("/", app=WarehouseApp), Mount("/users", app=UsersApp)]
app = Starlette(routes=routes)
app.debug = settings.DEBUG
app.add_middleware(
AuthenticationMiddleware,
backend=auth.ModelTokenAuth(),
on_error=lambda _, exc: PlainTextResponse(str(exc), status_code=401),
)
@app.on_event("startup")
async def startup() -> None:
await database.connect()
@app.on_event("shutdown")
async def shutdown() -> None:
await database.disconnect()
tags=['api'])
async def predict(request):
"""
async api
descriptions about this function
"""
print(request.path_params)
print(request.context)
return JSONResponse({'label': 5, 'score': 0.5})
class Ping(HTTPEndpoint):
@api.validate(tags=['health check', 'api'])
def get(self, request):
"""
health check
"""
return JSONResponse({'msg': 'pong'})
if __name__ == '__main__':
app = Starlette(routes=[
Route('/ping', Ping),
Mount('/api',
routes=[Route('/predict/{luck:int}', predict, methods=['POST'])])
])
api.register(app)
uvicorn.run(app, log_level='info')
db_name = scope['path_params']['db']
request_state = scope.setdefault('state', {})
try:
request_state['db'] = app.state.dbs[db_name]
request_state['db_name'] = db_name
except KeyError:
response = JSONResp(DB_NOT_FOUND, 404)
await response(scope, receive, send)
return
await self.db_app(scope, receive, send)
db_app = build_db_app(middleware=[Middleware(DBLoaderMiddleware)])
fauxton_path = os.path.join(os.path.dirname(__file__), 'fauxton')
app = Starlette(routes=[
Route('/', root),
Route('/_all_dbs', all_dbs),
Route('/_session', session),
Mount('/_utils', StaticFiles(directory=fauxton_path, html=True)),
Route('/_uuids', uuids),
Route('/{db}/', put_db, methods=['PUT']),
Route('/{db}/', delete_db, methods=['DELETE']),
Mount('/{db}', db_app),
])
# used to keep track of all the databases
app.state.dbs = sortedcontainers.SortedDict()
# for replication:
app.state.server_id = uuid.uuid4()
"download_archive": ydl_vars["YDL_ARCHIVE_FILE"],
"updatetime": ydl_vars["YDL_UPDATE_TIME"] == "True",
}
def download(url, request_options):
with YoutubeDL(get_ydl_options(request_options)) as ydl:
ydl.download([url])
routes = [
Route("/youtube-dl", endpoint=dl_queue_list),
Route("/youtube-dl/q", endpoint=q_put, methods=["POST"]),
Route("/youtube-dl/update", endpoint=update_route, methods=["PUT"]),
Mount("/youtube-dl/static",
app=StaticFiles(directory="static"),
name="static"),
]
app = Starlette(debug=True, routes=routes)
print("Updating youtube-dl to the newest version")
update()
app_vars = ChainMap(os.environ, app_defaults)
if __name__ == "__main__":
uvicorn.run(app,
host=app_vars["YDL_SERVER_HOST"],
port=int(app_vars["YDL_SERVER_PORT"]))
assert cookies.pub == "abcdefg"
assert request.cookies["pub"] == "abcdefg"
return JSONResponse({"name": json.name, "score": score})
app = Starlette(routes=[
Route("/ping", Ping),
Mount(
"/api",
routes=[
Mount(
"/user",
routes=[
Route("/{name}", user_score, methods=["POST"]),
],
),
Mount(
"/user_annotated",
routes=[
Route("/{name}", user_score_annotated, methods=["POST"]),
],
),
],
),
Mount("/static", app=StaticFiles(directory="docs"), name="static"),
])
api.register(app)
@pytest.fixture
def client():
from starlette.routing import Route, Mount
from starlette.responses import JSONResponse
from ipproject.core.users.resources import routes as user_routes
from ipproject.core.roles.resources import routes as roles_routes
from ipproject.core.permissions.resources import get_apps
async def ping(request):
return JSONResponse({'onPing': 'wePong'})
routes = [
Route('/ping', ping),
Route('/apps', get_apps, methods=['GET']),
Mount('/users', routes=user_routes),
Mount('/roles', routes=roles_routes),
]
from starlette.routing import Router, Route, Mount
from dplaapi import handlers
from dplaapi.handlers import v2 as v2_handlers
from . import v2 as v2_routes
routes = [
Route('/', methods=['GET'], endpoint=handlers.redir_to_recent_version),
Mount('/v2', app=Router(v2_routes.routes)),
# These paths go to the most recent protocol version of the API; in this
# case, /v2:
Route('/items',
methods=['GET', 'OPTIONS'],
endpoint=v2_handlers.multiple_items),
Route('/items/{id_or_ids}',
methods=['GET', 'OPTIONS'],
endpoint=v2_handlers.specific_item),
]
def user_no_match(request): # pragma: no cover
content = "User fixed no match"
return Response(content, media_type="text/plain")
def staticfiles(request):
return Response("xxxxx", media_type="image/png")
app = Router([
Route("/", endpoint=homepage, methods=["GET"]),
Mount(
"/users",
app=Router([
Route("/", endpoint=users),
Route("/me", endpoint=user_me),
Route("/{username}", endpoint=user),
Route("/nomatch", endpoint=user_no_match),
]),
),
Mount("/static", app=staticfiles),
])
@app.route("/func")
def func_homepage(request):
return Response("Hello, world!", media_type="text/plain")
@app.route("/func", methods=["POST"])
def contact(request):
from starlette.applications import Starlette
from starlette.responses import HTMLResponse
from starlette.routing import Route, Mount
from starlette.staticfiles import StaticFiles
async def homepage(request):
"""
Homepage which uses server push to deliver the stylesheet.
"""
await request.send_push_promise("/static/style.css")
return HTMLResponse(
'<html><head><link rel="stylesheet" href="/static/style.css"/></head></html>'
)
routes = [
Route("/", endpoint=homepage),
Mount("/static", StaticFiles(directory="static"), name="static") ,
Mount('/static', app=StaticFiles(directory='static', packages=['bootstrap4']), name="static"),
]
app = Starlette(routes=routes)
from raiseexception.subscription.views import subscription_views
def index(request):
return settings.TEMPLATE.TemplateResponse('index.html',
{'request': request})
def privacy_policy_view(request):
return settings.TEMPLATE.TemplateResponse('privacy_policy.html',
{'request': request})
routes = [
Route('/', index),
Mount('/auth', routes=auth_views.routes, name='auth'),
Mount('/admin', routes=admin_views.routes, name='admin'),
Mount('/blog', routes=blog_views.routes, name='blog'),
Route('/privacy-policy', privacy_policy_view, name='privacy_policy'),
Mount('/subscription',
routes=subscription_views.routes,
name='subscription')
]
if settings.DEBUG:
from starlette.staticfiles import StaticFiles
routes.extend((Mount('/static',
app=StaticFiles(directory=settings.STATIC_DIR),
name='static'),
Mount('/media',
app=StaticFiles(directory=settings.MEDIA_DIR),
content = "User fixed me"
return Response(content, media_type="text/plain")
def user_no_match(request): # pragma: no cover
content = "User fixed no match"
return Response(content, media_type="text/plain")
app = Router([
Route("/", endpoint=homepage, methods=["GET"]),
Mount(
"/users",
routes=[
Route("/", endpoint=users),
Route("/me", endpoint=user_me),
Route("/{username}", endpoint=user),
Route("/nomatch", endpoint=user_no_match),
],
),
Mount("/static", app=Response("xxxxx", media_type="image/png")),
])
@app.route("/func")
def func_homepage(request):
return Response("Hello, world!", media_type="text/plain")
@app.route("/func", methods=["POST"])
def contact(request):
from starlette.middleware import Middleware
from starlette.config import Config
from starlette.responses import RedirectResponse
from starlette.routing import Route, Mount
from starlette.staticfiles import StaticFiles
from src import settings
from .resources import database
from .views import login, logout, balances, transactions
middleware = [
Middleware(SessionMiddleware, secret_key=settings.SECRET, https_only=False)
]
routes = [
Route("/transactions", endpoint=transactions, methods=["GET", "POST"]),
Route("/balances", endpoint=balances, methods=["GET"]),
Route("/login", endpoint=login, methods=["POST"]),
Route("/logout", endpoint=logout, methods=["GET", "POST"]),
Mount('/docs/', app=StaticFiles(directory='docs'), name="docs"),
Route('/docs',
endpoint=lambda request: RedirectResponse("/docs/index.html"),
name="docs")
]
app = Starlette(debug=settings.DEBUG,
routes=routes,
middleware=middleware,
on_startup=[database.connect],
on_shutdown=[database.disconnect])
from .steam import SteamLogin, SteamValidate, SteamLogout
from ..resources import Config
ERROR_HANDLERS = {
WebargsHTTPException: api_error,
404: not_found,
500: server_error
}
ROUTES = [
Route("/", HomePage, name="HomePage"),
Mount("/login",
routes=[
Route("/steam", SteamLogin, name="SteamLogin"),
Route("/validate", SteamValidate),
Route("/logout", SteamLogout, name="SteamLogout")
]),
Route("/download/{match_id}", DownloadPage, name="DownloadPage"),
Mount("/assets", StaticFiles(directory=Config.assets_dir), name="assets"),
Mount("/c/{community}",
routes=[
Route("/disable",
CommunityDisablePage,
name="CommunityDisablePage"),
Route("/update-key",
CommunityUpdateKeyPage,
name="CommunityUpdateKeyPage"),
Route("/", CommunityPage, name="CommunityPage"),
Route("/{page:int}",
CommunityPage,
def test_mount_at_root(test_client_factory):
mounted = Router([Mount("/", ok, name="users")])
client = test_client_factory(mounted)
assert client.get("/").status_code == 200
async def shutdown():
global RUNNING
RUNNING = False
routes = [
Route('/', index),
Route('/api/spend', spend, methods=['POST']),
Route('/api/spend_power', spend_power, methods=['POST']),
# These two methods are only going to be usable when the game is in setup status
Route('/api/gain_money', gain_money, methods=['POST']),
Route('/api/gain_power', gain_power, methods=['POST']),
# The about two methods are only going to be usable when the game is in setup status
Route('/api/create_game', create_game, methods=['POST']),
Route('/api/join_game', join_game, methods=['POST']),
Route('/api/event_stream', endpoint=event_stream),
Route('/api/game_stream/{game_id}', endpoint=game_event_stream),
Route('/api/player/{player_id}', player),
Mount('/static', StaticFiles(directory='static/dist'), name='static')
]
app = Starlette(routes=routes,
middleware=middleware,
on_startup=[startup],
on_shutdown=[shutdown])
def run():
return app
if "curl" in request.headers['user-agent']:
return templates.TemplateResponse('index.txt', {'request': request})
else:
if not global_state["INITIALIZED"]:
_setup(request)
return templates.TemplateResponse('index.html', {'request': request})
def headers(request):
return JSONResponse(dumps({k: v for k, v in request.headers.items()}))
routes = [
Route('/', endpoint=index),
Route('/headers', endpoint=headers),
Mount('/static', app=StaticFiles(directory='static'), name='static'),
]
app = Starlette(debug=True, routes=routes)
app.add_middleware(PrometheusMiddleware)
app.add_route("/metrics", handle_metrics)
config = Config()
if __name__ == "__main__":
uvicorn.run("app:app",
host="0.0.0.0",
port=int(getenv('PORT', 8000)),
log_level=getenv('LOG_LEVEL', "info"),
debug=getenv('DEBUG', False),
proxy_headers=True)
def __init__(self,
database_settings: DatabaseSettings,
stripe_settings: StripeSettings,
smtp_settings: SmtpSettings,
friendly_url: str,
frontend_url: str,
root_steam_id: str,
system_email: str,
upload_settings: Tuple[
B2UploadSettings, LocalUploadSettings] = None,
map_images: Dict[str, str] = MAP_IMAGES,
upload_delay: float = 0.00001,
free_upload_size: float = 30.0,
max_upload_size: float = 100.0,
cost_per_mb: float = 0.15,
timestamp_format: str = "%m/%d/%Y-%H:%M:%S",
community_types: List[str] = COMMUNITY_TYPES,
webhook_timeout: float = 3.0,
match_max_length: timedelta = timedelta(hours=3),
payment_expires: timedelta = timedelta(days=31),
demo_expires: timedelta = timedelta(weeks=20),
clear_cache: bool = True,
**kwargs) -> None:
"""SQLMatches API.
Parameters
----------
database_settings : DatabaseSettings
stripe_settings : StripeSettings
friendly_url : str
frontend_url : str
root_steam_id : str
system_email : str
upload_settings : [B2UploadSettings, LocalUploadSettings], optional
by default None
map_images : Dict[str, str], optional
by default MAP_IMAGES
upload_delay : float, optional
by default 0.00001
free_upload_size : float, optional
by default 50.0
max_upload_size : float, optional
by default 100.0
cost_per_mb : float, optional
by default 0.15
timestamp_format : str, optional
by default "%m/%d/%Y-%H:%M:%S"
community_types : List[str], optional
by default COMMUNITY_TYPES
webhook_timeout : float, optional
by default 3.0
match_max_length : timedelta, optional
by default timedelta(hours=3)
payment_expires : timedelta, optional
by default timedelta(days=31)
"""
startup_tasks = [self._startup]
shutdown_tasks = [self._shutdown]
if "on_startup" in kwargs:
startup_tasks = startup_tasks + kwargs["on_startup"]
if "on_shutdown" in kwargs:
shutdown_tasks = shutdown_tasks + kwargs["on_shutdown"]
middlewares = [
Middleware(SessionMiddleware,
secret_key=KeyLoader(name="session").load()),
Middleware(AuthenticationMiddleware, backend=APIAuthentication(),
on_error=auth_error),
Middleware(
CORSMiddleware,
allow_origins=["*"],
allow_methods=["GET", "POST", "DELETE", "OPTIONS"]
)
]
if "middleware" in kwargs:
middlewares = middlewares + kwargs["middleware"]
if "routes" in kwargs:
routes = kwargs["routes"] + ROUTES
else:
routes = ROUTES
if "exception_handlers" in kwargs:
exception_handlers = kwargs["exception_handlers"] + ERROR_HANDLERS
else:
exception_handlers = ERROR_HANDLERS
if friendly_url[:1] != "/":
friendly_url += "/"
if frontend_url[:1] != "/":
frontend_url += "/"
Config.url = friendly_url
Config.map_images = map_images
Config.upload_delay = upload_delay
Config.free_upload_size = free_upload_size
Config.max_upload_size = max_upload_size
Config.cost_per_mb = cost_per_mb
Config.timestamp_format = timestamp_format
Config.root_steam_id_hashed = bcrypt.hashpw(
root_steam_id.encode(), bcrypt.gensalt()
)
Config.root_webhook_key_hashed = bcrypt.hashpw(
(KeyLoader("webhook").load()).encode(), bcrypt.gensalt()
)
Config.webhook_timeout = webhook_timeout
Config.match_max_length = match_max_length
Config.payment_expires = payment_expires
Config.system_email = system_email
Config.frontend_url = frontend_url
Config.currency = stripe_settings.currency
Config.receipt_url_base = stripe_settings.receipt_url_base
Config.demo_expires = demo_expires
self.community_types = community_types
self.clear_cache = clear_cache
self.product_name = stripe_settings.product_name
database_url = "://{}:{}@{}:{}/{}?charset=utf8mb4".format(
database_settings.username,
database_settings.password,
database_settings.server,
database_settings.port,
database_settings.database
)
Sessions.database = Database(
database_settings.engine + database_url
)
create_tables(
"{}+{}{}".format(
database_settings.engine,
database_settings.alchemy_engine,
database_url
)
)
Sessions.smtp = SMTP(
hostname=smtp_settings.hostname,
port=smtp_settings.port,
use_tls=smtp_settings.use_tls,
password=smtp_settings.password,
username=smtp_settings.username
)
Sessions.stripe = Stripe(
stripe_settings.api_key,
stripe_settings.testing
)
if upload_settings:
Config.demo_pathway = upload_settings.pathway
Config.demo_extension = upload_settings.extension
if isinstance(upload_settings, B2UploadSettings):
Config.cdn_url = upload_settings.cdn_url
Config.upload_type = B2UploadSettings
self.b2 = backblaze.Awaiting(
upload_settings.key_id,
upload_settings.application_key
)
Sessions.bucket = self.b2.bucket(
upload_settings.bucket_id
)
elif isinstance(upload_settings, LocalUploadSettings):
Config.cdn_url = None
Config.upload_type = LocalUploadSettings
# Dynamically adding mount if local storage.
# Name attribute for Mount isn't working correctly here,
# so please don't change '/demos/'.
for mount in routes:
if type(mount) == Mount and mount.name == "api":
mount.app.routes.append(
Mount(
"/demos/",
StaticFiles(directory=Config.demo_pathway)
)
)
break
logger.warning(
"Using local storage for demos, use b2 for production."
)
else:
Config.upload_type = None
super().__init__(
routes=routes,
exception_handlers=exception_handlers,
middleware=middlewares,
on_startup=startup_tasks,
on_shutdown=shutdown_tasks,
**kwargs
)
from starlette.routing import Mount, Route
from starlette.staticfiles import StaticFiles
from .settings import BASE_DIR
from .views import index
routes = [
# main page
Route("/", index, methods=["GET"]),
# static stuff
Mount("/css", StaticFiles(directory=f"{BASE_DIR}/css")),
Mount("/icon", StaticFiles(directory=f"{BASE_DIR}/icon")),
Mount("/images", StaticFiles(directory=f"{BASE_DIR}/images")),
Mount("/js", StaticFiles(directory=f"{BASE_DIR}/js"))
]
async def predict(request):
"""
async api
descriptions about this function
"""
print(request.path_params)
print(request.context)
return JSONResponse({"label": 5, "score": 0.5})
class Ping(HTTPEndpoint):
@api.validate(tags=["health check", "api"])
def get(self, request):
"""
health check
"""
return JSONResponse({"msg": "pong"})
if __name__ == "__main__":
app = Starlette(routes=[
Route("/ping", Ping),
Mount("/api",
routes=[Route("/predict/{luck:int}", predict, methods=["POST"])
]),
])
api.register(app)
uvicorn.run(app, log_level="info")
from config import is_docker
routes = [
Route('/replicas', endpoint=ReplicasHandlers),
Route('/replicas/{id}', endpoint=ReplicaHandlers),
Route('/login', endpoint=Login),
Route('/change_password', endpoint=ChangePassword),
Route('/users', endpoint=UsersHandler),
Route('/users/deactivate', endpoint=UsersDeactivate),
Route('/users/new_password', endpoint=UsersNewPassword),
Route('/patients/{id}', endpoint=PatientHandler),
Route('/files/upload', endpoint=Upload),
Route('/files/download_token', endpoint=DownloadToken),
Route('/files/download.zip', endpoint=DownloadFiles),
Route('/files/download.csv', endpoint=DownloadData),
Route('/files', endpoint=FilesHandler),
Route('/files/{id}', endpoint=FileHandler),
Route('/files/{id}/changes', endpoint=FileChangesHandler),
Route('/files/{id}/share', endpoint=ShareFilesHandler),
Route('/files/{id}/data', endpoint=ServeFile),
Route('/logs', endpoint=LogsHandler),
Route('/ws_token', endpoint=WSToken),
WebSocketRoute('/ws', endpoint=WebsocketHandler)
]
routes = [
Mount('/api', app=Router(routes)),
]
if is_docker:
routes.append(
Mount('/', app=StaticFiles(directory='static'), name="static"))
