from fastapi.middleware.cors import CORSMiddleware
from starlette.middleware import Middleware
from starlette.responses import JSONResponse
from hekshermgmt._version import __version__
from hekshermgmt.api.v1 import router as v1_router
from hekshermgmt.app import HeksherManagement
middleware = []
if __debug__:
middleware.append(
Middleware(
CORSMiddleware,
allow_origins=["*"],
allow_methods=["*"],
allow_headers=["*"],
))
app = HeksherManagement(title="HeksherManagement",
version=__version__ or "0.0.1",
middleware=middleware)
app.include_router(v1_router)
@app.on_event("startup")
async def startup():
await app.startup()
@app.on_event("shutdown")
async def shutdown():
def test_middleware_repr():
middleware = Middleware(CustomMiddleware)
assert repr(middleware) == "Middleware(CustomMiddleware)"
def server(model, allowed_origins=None):
middleware = [Middleware(CORSMiddleware, allow_origins=allowed_origins)
] if allowed_origins else None
app = FastAPI(middleware=middleware)
input_features = {f[COLUMN] for f in model.config["input_features"]}
@app.get("/")
def check_health():
return NumpyJSONResponse({"message": "Ludwig server is up"})
@app.post("/predict")
async def predict(request: Request):
try:
form = await request.form()
entry, files = convert_input(form, model.model.input_features)
except Exception:
logger.exception("Failed to parse predict form")
return NumpyJSONResponse(COULD_NOT_RUN_INFERENCE_ERROR,
status_code=500)
try:
if (entry.keys() & input_features) != input_features:
return NumpyJSONResponse(ALL_FEATURES_PRESENT_ERROR,
status_code=400)
try:
resp, _ = model.predict(dataset=[entry], data_format=dict)
resp = resp.to_dict("records")[0]
return NumpyJSONResponse(resp)
except Exception as exc:
logger.exception(f"Failed to run predict: {exc}")
return NumpyJSONResponse(COULD_NOT_RUN_INFERENCE_ERROR,
status_code=500)
finally:
for f in files:
os.remove(f.name)
@app.post("/batch_predict")
async def batch_predict(request: Request):
try:
form = await request.form()
data, files = convert_batch_input(form, model.model.input_features)
data_df = pd.DataFrame.from_records(data["data"],
index=data.get("index"),
columns=data["columns"])
except Exception:
logger.exception("Failed to parse batch_predict form")
return NumpyJSONResponse(COULD_NOT_RUN_INFERENCE_ERROR,
status_code=500)
if (set(data_df.columns) & input_features) != input_features:
return NumpyJSONResponse(ALL_FEATURES_PRESENT_ERROR,
status_code=400)
try:
resp, _ = model.predict(dataset=data_df)
resp = resp.to_dict("split")
return NumpyJSONResponse(resp)
except Exception:
logger.exception("Failed to run batch_predict: {}")
return NumpyJSONResponse(COULD_NOT_RUN_INFERENCE_ERROR,
status_code=500)
return app
def test_raw_middleware_wrong_plugin():
with pytest.raises(ConfigurationError):
Starlette(middleware=[
Middleware(RawContextMiddleware, plugins=(NotAPlugin(), ))
])
import sys
import sqlalchemy
from starlette.config import Config
from starlette.middleware import Middleware
from starlette.applications import Starlette
from starlette.middleware.cors import CORSMiddleware
sys.path.append('..')
from api.routes.web import routes, db
config = Config('.env')
DATABASE_URL = config('DATABASE_URL')
metadata = sqlalchemy.MetaData()
middleware = [
Middleware(CORSMiddleware, allow_origins=['*'], allow_methods=['*'])
]
app = Starlette(debug=True,
routes=routes,
middleware=middleware,
on_startup=[db.connect],
on_shutdown=[db.disconnect])
from fastapi import FastAPI, HTTPException
from starlette.middleware import Middleware
from starlette.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from fastapi.openapi.docs import (
get_redoc_html,
get_swagger_ui_html,
get_swagger_ui_oauth2_redirect_html,
)
# application modules
from src.routes import label, collection, speech_api, summary
from src.utils import exception_handler
# add middlewares
middlewares = [Middleware(CORSMiddleware, allow_origins=["*"])]
# create FastAPI instance
app = FastAPI(
title="VoiceGen Admin",
middleware=middlewares,
description="A REST API service to be used as voicegen admin backend",
exception_handlers={
Exception: exception_handler,
HTTPException: exception_handler
},
docs_url=None,
redoc_url=None)
app.mount("/static", StaticFiles(directory="static"), name="static")
# add routes
def test_cors_allow_origin_regex(test_client_factory):
def homepage(request):
return PlainTextResponse("Homepage", status_code=200)
app = Starlette(
routes=[Route("/", endpoint=homepage)],
middleware=[
Middleware(
CORSMiddleware,
allow_headers=["X-Example", "Content-Type"],
allow_origin_regex="https://.*",
allow_credentials=True,
)
],
)
client = test_client_factory(app)
# Test standard response
headers = {"Origin": "https://example.org"}
response = client.get("/", headers=headers)
assert response.status_code == 200
assert response.text == "Homepage"
assert response.headers["access-control-allow-origin"] == "https://example.org"
assert response.headers["access-control-allow-credentials"] == "true"
# Test standard credentialed response
headers = {"Origin": "https://example.org", "Cookie": "star_cookie=sugar"}
response = client.get("/", headers=headers)
assert response.status_code == 200
assert response.text == "Homepage"
assert response.headers["access-control-allow-origin"] == "https://example.org"
assert response.headers["access-control-allow-credentials"] == "true"
# Test disallowed standard response
# Note that enforcement is a browser concern. The disallowed-ness is reflected
# in the lack of an "access-control-allow-origin" header in the response.
headers = {"Origin": "http://example.org"}
response = client.get("/", headers=headers)
assert response.status_code == 200
assert response.text == "Homepage"
assert "access-control-allow-origin" not in response.headers
# Test pre-flight response
headers = {
"Origin": "https://another.com",
"Access-Control-Request-Method": "GET",
"Access-Control-Request-Headers": "X-Example, content-type",
}
response = client.options("/", headers=headers)
assert response.status_code == 200
assert response.text == "OK"
assert response.headers["access-control-allow-origin"] == "https://another.com"
assert response.headers["access-control-allow-headers"] == (
"Accept, Accept-Language, Content-Language, Content-Type, X-Example"
)
assert response.headers["access-control-allow-credentials"] == "true"
# Test disallowed pre-flight response
headers = {
"Origin": "http://another.com",
"Access-Control-Request-Method": "GET",
"Access-Control-Request-Headers": "X-Example",
}
response = client.options("/", headers=headers)
assert response.status_code == 400
assert response.text == "Disallowed CORS origin"
assert "access-control-allow-origin" not in response.headers
"debug_no_middleware": (False, True, {}),
"teapot_exception_handler_no_middleware": (False, False, {}),
}
target_application = dict()
for app_name, flags in app_name_map.items():
# Bind options
middleware_on, debug, exception_handlers = flags
# Instantiate app
if not middleware_on:
app = Starlette(debug=debug, routes=routes, exception_handlers=exception_handlers)
else:
if Middleware:
app = Starlette(debug=debug, routes=routes, middleware=[Middleware(middleware_factory)], exception_handlers=exception_handlers)
else:
app = Starlette(debug=debug, routes=routes, exception_handlers=exception_handlers)
# in earlier versions of starlette, middleware is not a legal argument on the Starlette application class
# In order to keep the counts the same, we add the middleware twice using the add_middleware interface
app.add_middleware(middleware_factory)
app.add_middleware(middleware_factory)
app.middleware("http")(middleware_decorator)
# Adding custom exception handlers
app.add_exception_handler(HandledError, async_error_handler)
# Add exception handler multiple times to verify the handler is not double wrapped
app.add_exception_handler(NonAsyncHandledError, non_async_error_handler)
app.add_exception_handler(NonAsyncHandledError, non_async_error_handler)
import uvicorn
from starlette.applications import Starlette
from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import JSONResponse
from examples.example_with_logger.logger import log
from starlette_context import context, middleware, plugins
middleware = [
Middleware(
middleware.ContextMiddleware,
plugins=(
plugins.CorrelationIdPlugin(),
plugins.RequestIdPlugin(),
plugins.DateHeaderPlugin(),
plugins.ForwardedForPlugin(),
plugins.UserAgentPlugin(),
),
)
]
app = Starlette(debug=True, middleware=middleware)
@app.route("/")
async def index(_: Request):
log.info("Log from view")
return JSONResponse(context.data)
from starlette_x_bugsnag.middleware import BugsnagMiddleware
from . import __version__
from .middleware import FooMiddleware
from .routes import exception, health, hello, home
from .settings import BUGSNAG_API_KEY, DEBUG
routes = [
Route("/", home),
Route("/health", health),
Route("/hello/{name}", hello),
Route("/exception/{secret}", exception),
]
release_stage = "development" if DEBUG else "production"
application = Starlette(
debug=DEBUG,
routes=routes,
middleware=[
Middleware(FooMiddleware),
Middleware(
BugsnagMiddleware,
api_key=str(BUGSNAG_API_KEY),
app_version=__version__,
project_root=None,
release_stage=release_stage,
),
],
)
Route(r"/api/service/{source_label:str}/{resource_name:str}",
service_fetch,
methods=["GET", "POST"]),
# Call a worker in a background job that executes after HTTP response is sent out
Route(r"/api/background/{app_name:str}/{worker_name:str}",
worker_background,
methods=["POST"]),
# `await` a worker in the HTTP request, thus returning the response of the worker
Route(r"/api/execute/{app_name:str}/{worker_name:str}",
worker_execute,
methods=["POST"]),
]
middlewares = [
Middleware(DwataAppMiddleware),
]
"""
Middleware(
CORSMiddleware,
allow_origins=settings.ALLOWED_ORIGINS,
allow_methods=["OPTIONS", "GET", "POST", "PUT"],
allow_headers="Authorization,Access-Control-Allow-Headers,Origin,Accept,X-Requested-With"
",Content-Type,Access-Control-Request-Method,Access-Control-Request-Headers"
),
"""
app = Starlette(debug=True,
on_startup=[dwata_meta_db.connect],
on_shutdown=[dwata_meta_db.disconnect],
routes=handlers,
from starlette.middleware import Middleware
from starlette.middleware.sessions import SessionMiddleware
from starlette.responses import RedirectResponse, FileResponse, JSONResponse
from starlette.staticfiles import StaticFiles
from starlette.templating import Jinja2Templates
from utils.github.app import SignInNeededException, BadEventSignatureException
from utils.github.starlette_app import StarletteGitHubApp, RequestContextMiddleware
from utils.github_requests import GitHubRequests
# from utils.logging import configure as configure_logging
config = Config('.env')
SECRET_KEY = config('SECRET_KEY', cast=Secret)
middleware = [
Middleware(SessionMiddleware, secret_key=SECRET_KEY),
Middleware(RequestContextMiddleware),
]
github_app = StarletteGitHubApp(config, 'signin')
github_requests = GitHubRequests(github_app)
async def on_shutdown():
await github_app.close()
app = Starlette(debug=True, middleware=middleware, on_shutdown=[on_shutdown])
templates = Jinja2Templates(directory='templates')
app.mount('/static', StaticFiles(directory='static'), name='static')
# configure_logging(app)
from starlette.middleware import Middleware from starlette.middleware.authentication import AuthenticationMiddleware from auth.middleware import BasicAuthBackend middleware = [Middleware(AuthenticationMiddleware, backend=BasicAuthBackend())]
def create_app(middleware: Sequence[Tuple[type, dict]]) -> ASGIApp:
return Starlette(
routes=routes,
middleware=[Middleware(cls, **options) for cls, options in middleware],
)
SessionMiddleware, )
from starlette.routing import (
Route, )
# Local libraries
import four_shells.config
import four_shells.handlers
import four_shells.cachipfs.handlers
# Constants
APP = Starlette(
middleware=[
Middleware(
cls=SessionMiddleware,
https_only=four_shells.config.PRODUCTION,
max_age=four_shells.config.SESSION_DURATION,
same_site='lax',
secret_key=four_shells.config.SESSION_SECRET,
session_cookie=four_shells.config.SESSION_COOKIE,
),
],
on_startup=[
four_shells.handlers.on_startup,
],
on_shutdown=[
four_shells.handlers.on_shutdown,
],
routes=[
Route(
endpoint=four_shells.cachipfs.handlers.namespace_associate,
methods=['POST'],
path='/api/v1/cachipfs/namespace/{id:str}/associate',
if info['bday']:
client.ibustats.racers.update_one(
{'wiki.ru': wiki}, {'$set': {
'bday': str(info['bday'])
}},
upsert=False)
client.ibustats.racers.update_one(
{'wiki.ru': wiki}, {'$set': {
'last_modified': datetime.now()
}},
upsert=False)
await asyncio.sleep(4 + random.randint(4, 12))
await asyncio.sleep(32)
middleware = [Middleware(LoggingMiddleware)]
app = Starlette(debug=True,
routes=[
Route('/api/humans/', HumansEndpoint),
Route('/api/rels/humans/{wikidataid}', HumanEndpoint),
Route('/api/rels/countries', CountriesEndpoint),
Route('/api/rels/countries/{wikidataid}', CountryEndpoint),
Route('/api/rels/instances', InstancesEndpoint),
Route('/api/rels/instances/{wikidataid}',
InstanceEndpoint),
Route('/api/feeds/latest', latest_feeds),
Route('/api/feeds/{feed_id}', FeedEndpoint),
Route('/api/feeds/{feed_id}/source', FeedSourceEndpoint),
Route('/api/tasks/{name}', TaskEndpoint),
Route('/reader/feeds/{feed_id}', RssReaderEndpoint),
@functools.lru_cache()
def get_pipeline() -> Pipeline:
task = os.environ["TASK"]
model_id = os.environ["MODEL_ID"]
if task not in ALLOWED_TASKS:
raise EnvironmentError(
f"{task} is not a valid pipeline for model : {model_id}")
return ALLOWED_TASKS[task](model_id)
routes = [
Route("/{whatever:path}", status_ok),
Route("/{whatever:path}", pipeline_route, methods=["POST"]),
]
middleware = [Middleware(GZipMiddleware, minimum_size=1000)]
if os.environ.get("DEBUG", "") == "1":
from starlette.middleware.cors import CORSMiddleware
middleware.append(
Middleware(
CORSMiddleware,
allow_origins=["*"],
allow_headers=["*"],
allow_methods=["*"],
))
app = Starlette(routes=routes, middleware=middleware)
@app.on_event("startup")
def app_with_scout(*, middleware=None, scout_config=None):
"""
Context manager that configures and installs the Scout plugin for a basic
Starlette application.
"""
if scout_config is None:
scout_config = {}
scout_config["core_agent_launch"] = False
scout_config.setdefault("monitor", True)
async def home(request):
return PlainTextResponse("Welcome home.")
def sync_home(request):
return PlainTextResponse("Welcome home, synchronously.")
class HelloEndpoint(HTTPEndpoint):
async def get(self, request):
return PlainTextResponse("Hello World!")
class SyncHelloEndpoint(HTTPEndpoint):
def get(self, request):
return PlainTextResponse("Hello Synchronous World!")
async def crash(request):
raise ValueError("BØØM!") # non-ASCII
async def return_error(request):
return PlainTextResponse("Something went wrong", status_code=503)
async def background_jobs(request):
def sync_noop():
pass
async def async_noop():
pass
tasks = BackgroundTasks()
tasks.add_task(sync_noop)
tasks.add_task(async_noop)
return PlainTextResponse("Triggering background jobs",
background=tasks)
class InstanceApp:
async def __call__(self, scope, receive, send):
resp = PlainTextResponse(
"Welcome home from an app that's a class instance.")
await resp(scope, receive, send)
routes = [
Route("/", endpoint=home),
Route("/sync-home/", endpoint=sync_home),
Route("/hello/", endpoint=HelloEndpoint),
Route("/sync-hello/", endpoint=SyncHelloEndpoint),
Route("/crash/", endpoint=crash),
Route("/return-error/", endpoint=return_error),
Route("/background-jobs/", endpoint=background_jobs),
Route("/instance-app/", endpoint=InstanceApp()),
]
async def raise_error_handler(request, exc):
# Always raise exceptions
raise exc
if middleware is None:
middleware = []
# As per http://docs.scoutapm.com/#starlette
Config.set(**scout_config)
middleware.insert(0, Middleware(ScoutMiddleware))
app = Starlette(
routes=routes,
middleware=middleware,
exception_handlers={500: raise_error_handler},
)
try:
yield app
finally:
Config.reset_all()
key = "from_plugin"
async def process_request(self, request: Request) -> dict:
self.value = await request.json()
return self.value
class GetPayloadFromBodyMiddleware(ContextMiddleware):
async def set_context(self, request: Request) -> dict:
from_plugin = await super(GetPayloadFromBodyMiddleware,
self).set_context(request)
return {"from_middleware": await request.json(), **from_plugin}
middleware = [
Middleware(GetPayloadFromBodyMiddleware,
plugins=(GetPayloadUsingPlugin(), ))
]
app = Starlette(middleware=middleware)
@app.route("/", methods=["POST"])
async def index(request: Request):
return JSONResponse(context.data)
client = TestClient(app)
def test_async_body():
payload = {"test": "payload"}
resp = client.post("/", json=payload)
from starlette.authentication import AuthCredentials, AuthenticationBackend, AuthenticationError, SimpleUser
from starlette.middleware import Middleware
from starlette.middleware.authentication import AuthenticationMiddleware
from pystargazer.app import app
class SimpleAuthBackend(AuthenticationBackend):
async def authenticate(self, request):
if "Authorization" not in request.headers:
return
auth = request.headers["Authorization"]
try:
scheme, credentials = auth.split()
if scheme.lower() != 'bearer':
return
except ValueError:
raise AuthenticationError('Invalid auth credentials')
if credentials == app.credentials.get("admin_token"):
return AuthCredentials(["admin"]), SimpleUser("admin")
else:
return
app.register_middleware(
Middleware(AuthenticationMiddleware, backend=SimpleAuthBackend()))
from starlette.applications import Starlette
from starlette.middleware import Middleware
from starlette.requests import Request
from starlette.responses import JSONResponse
import uvicorn
from starlette_context import context, plugins
from starlette_context.middleware import ContextMiddleware
middleware = [
Middleware(
ContextMiddleware,
plugins=(plugins.RequestIdPlugin(), plugins.CorrelationIdPlugin()),
)
]
app = Starlette(debug=True, middleware=middleware)
@app.route("/")
async def index(request: Request):
return JSONResponse(context.data)
uvicorn.run(app, host="0.0.0.0")
from starlette.testclient import TestClient
from starlette_context import context, plugins
from starlette_context.header_keys import HeaderKeys
from starlette_context.middleware import RawContextMiddleware
plugins_to_use = (
plugins.CorrelationIdPlugin(),
plugins.RequestIdPlugin(),
plugins.UserAgentPlugin(),
plugins.ForwardedForPlugin(),
plugins.DateHeaderPlugin(),
)
middleware = [Middleware(
RawContextMiddleware,
plugins=plugins_to_use,
)]
app = Starlette(middleware=middleware)
client = TestClient(app)
@app.route("/")
async def index(request: Request) -> JSONResponse:
return JSONResponse(content=context.data)
def test_valid_request():
resp = client.get("/")
assert resp.status_code == status.HTTP_200_OK
class LoggingMiddleware(BaseHTTPMiddleware):
"""Example logging middleware."""
async def dispatch(self, request: Request,
call_next: RequestResponseEndpoint) -> Response:
await logger.info("request log", request=request)
response = await call_next(request)
await logger.info("response log", response=response)
return response
middlewares = [
Middleware(
RawContextMiddleware,
plugins=(
plugins.CorrelationIdPlugin(),
plugins.RequestIdPlugin(),
),
),
Middleware(LoggingMiddleware),
]
app = Starlette(debug=True, middleware=middlewares)
@app.on_event("startup")
async def startup_event() -> None:
from setup_logging import setup_logging
setup_logging()
"type": "string",
},
"method": {
"type": "string",
}
},
},
},
Request,
)
await self.add_available_event(
"overheated",
{
"description":
"The lamp has exceeded its safe operating temperature",
"type": "number",
"unit": "degree celsius",
},
)
return self
with background_thread_loop() as loop:
app = ThingTalk(loop,
Light,
additional_middlewares=[
Middleware(CORSMiddleware, allow_origins=['*'])
]).create()
"""
try:
web = WebGear(logging=True)
web.config["generator"] = generator
client = TestClient(web(), raise_server_exceptions=True)
response_video = client.get("/video")
assert response_video.status_code == 200
web.shutdown()
except Exception as e:
if result:
pytest.fail(str(e))
test_data_class = [
(None, False),
([Middleware(CORSMiddleware, allow_origins=["*"])], True),
([Route("/hello", endpoint=hello_webpage)], False), # invalid value
]
@pytest.mark.parametrize("middleware, result", test_data_class)
def test_webgear_custom_middleware(middleware, result):
"""
Test for WebGear API's custom middleware
"""
try:
web = WebGear(source=return_testvideo_path(), logging=True)
web.middleware = middleware
client = TestClient(web(), raise_server_exceptions=True)
response = client.get("/")
assert response.status_code == 200
def homepage(request):
return FileResponse(os.path.join(os.getcwd(), 'client', 'index.html'))
async def analyser(request):
try:
_f = await request.form()
_fileData = await _f['file'].read()
image_bytes = BytesIO(_fileData)
res = app.state.CAPTIONER.predict(
Image.open(image_bytes).convert('RGB'))
return JSONResponse({'res': res})
except IndexError:
return JSONResponse({e: "No Data Found"}, 500)
def startup():
app.state.CAPTIONER = Captioner.Captioner()
routers = [
Route('/api/analyze', analyser, methods=["POST"]),
Route('/', homepage, methods=['GET']),
Route('/result', homepage, methods=['GET']),
Mount('/', app=StaticFiles(directory='client'), name="FrontEnd")
]
middleware = [Middleware(HTTPSRedirectMiddleware)]
app = Starlette(debug=True, on_startup=[startup], routes=routers)
self,
app: ASGIApp,
) -> None:
self.app = app
async def __call__(
self,
scope: Scope,
receive: Receive,
send: Send,
) -> ASGIApp:
if scope["type"] == "http":
request = Request(scope=scope, receive=receive)
headers = Headers(scope=scope)
debug(f"{request.method} {request.url}")
debug("Params:")
for name, value in request.path_params.items():
debug(f"\t{name}: {value}")
debug("Headers:")
for name, value in headers.items():
debug(f"\t{name}: {value}")
return await self.app(scope=scope, receive=receive, send=send)
middleware = [
Middleware(HTTPLogMiddleware),
]
from starlette.middleware import Middleware
from starlette.middleware.cors import CORSMiddleware
from starlette.middleware.sessions import SessionMiddleware
from . import settings
middleware = [
Middleware(
CORSMiddleware,
allow_origins=["*"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
),
Middleware(SessionMiddleware,
secret_key=settings.SECRET_KEY,
same_site="None"),
]
def add_middleware(self, middleware_class: type,
**options: typing.Any) -> None:
self.user_middleware.insert(0, Middleware(middleware_class, **options))
self.middleware_stack = self.build_middleware_stack()
async def process():
async for msg in k.execute(exec_msg):
if raw:
print(msg)
yield json.dumps(msg) + "\n"
else:
if msg['msgtype'] == 'write':
yield msg['data']
return StreamingResponse(process(), media_type='text/plain')
middleware = [
Middleware(
CORSMiddleware,
allow_origins=['*'],
allow_methods=['GET', 'POST'],
allow_headers=['x-falcon-mode', 'x-falcon-env', 'x-falcon-args'])
]
app = Starlette(routes=[
Route('/', home),
Route('/exec', livecode_exec, methods=['POST']),
Route('/runtimes/{runtime}', runtime_exec, methods=['POST']),
WebSocketRoute("/livecode", LiveCode),
Mount('/static/codemirror',
app=StaticFiles(directory=codemirror_dir),
name="codemirror"),
Mount('/static', app=StaticFiles(directory=static_dir), name="static"),
],
middleware=middleware)
