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"))