def create_app(_=None, **settings):
"""Configure and return the WSGI app."""
config = pyramid.config.Configurator(settings=load_settings(settings))
config.include("pyramid_jinja2")
config.include("via.views")
config.include("h_pyramid_sentry")
# Configure Pyramid so we can generate static URLs
static_path = resource_filename("via", "static")
cache_buster = PathCacheBuster(static_path)
print(f"Cache buster salt: {cache_buster.salt}")
config.add_static_view(name="static", path="via:static")
config.add_cache_buster("via:static", cachebust=cache_buster)
app = WhiteNoise(
config.make_wsgi_app(),
index_file=True,
# Config for serving files at static/<salt>/path which are marked
# as immutable
root=static_path,
prefix=cache_buster.immutable_path,
immutable_file_test=cache_buster.get_immutable_file_test(),
)
app.add_files(
# Config for serving files at / which are marked as mutable. This is
# for robots.txt and / -> index.html
root=resource_filename("via", "static"),
prefix="/",
)
return app
def test_serves(self):
whitenoise = WhiteNoise(None, autorefresh=True)
whitenoise.add_files(
static.resolver.resolve("warehouse:/static/dist/").abspath(),
prefix="/static/",
)
path, headers = (whitenoise.find_file("/static/manifest.json")
.get_path_and_headers({}))
headers = dict(headers)
response = pretend.stub()
handler = pretend.call_recorder(lambda request: response)
registry = pretend.stub(whitenoise=whitenoise)
request = pretend.stub(
method="GET",
environ={},
path_info="/static/manifest.json",
registry=registry,
)
tween = static.whitenoise_tween_factory(handler, registry)
resp = tween(request)
assert resp.status_code == 200
assert resp.headers["Content-Type"] == "application/json"
assert resp.headers["Cache-Control"] == "public, max-age=60"
assert resp.headers["Vary"] == "Accept-Encoding"
with open(path, "rb") as fp:
assert resp.body == fp.read()
def test_serves(self):
whitenoise = WhiteNoise(None, autorefresh=True)
whitenoise.add_files(
static.resolver.resolve("warehouse:/static/dist/").abspath(),
prefix="/static/",
)
path, headers = (
whitenoise.find_file("/static/manifest.json").get_path_and_headers(
{}))
headers = dict(headers)
response = pretend.stub()
handler = pretend.call_recorder(lambda request: response)
registry = pretend.stub(whitenoise=whitenoise)
request = pretend.stub(
method="GET",
environ={},
path_info="/static/manifest.json",
registry=registry,
)
tween = static.whitenoise_tween_factory(handler, registry)
resp = tween(request)
assert resp.status_code == 200
assert resp.headers["Content-Type"] == "application/json"
assert resp.headers["Cache-Control"] == "public, max-age=60"
assert resp.headers["Vary"] == "Accept-Encoding"
with open(path, "rb") as fp:
assert resp.body == fp.read()
def static(directory: str) -> WSGIApp:
"""Return a WSGI app that serves static files under the given directory.
Powered by WhiteNoise.
"""
app = WhiteNoise(empty_wsgi_app())
if exists(directory):
app.add_files(directory)
return app
class Statics(object):
preload = True
def __init__(self, root_dir: str=None) -> None:
assert whitenoise is not None, 'whitenoise must be installed.'
from whitenoise import WhiteNoise
self.whitenoise = WhiteNoise(application=None, root=root_dir)
self.whitenoise.add_files(PACKAGE_STATICS, prefix='apistar')
@classmethod
def build(cls, settings: Settings):
root_dir = settings.get(['STATICS', 'DIR'])
return cls(root_dir)
class Statics(object):
preload = True
def __init__(self, root_dir=None):
assert whitenoise is not None, 'whitenoise must be installed.'
from whitenoise import WhiteNoise
self.whitenoise = WhiteNoise(application=None, root=root_dir)
self.whitenoise.add_files(PACKAGE_STATICS, prefix='apistar')
@classmethod
def build(cls, settings: Settings):
root_dir = settings.get(['STATICS', 'DIR'])
return cls(root_dir)
def register(self):
response_handler = WhiteNoise(
self.application.get_response_handler(),
root=self.application.get_storage_path(),
autorefresh=True,
)
for location, alias in (self.application.make(
"storage_capsule").get_storage_assets().items()):
response_handler.add_files(location, prefix=alias)
self.application.set_response_handler(response_handler)
def test_bypasses(self, autorefresh):
whitenoise = WhiteNoise(None, autorefresh=autorefresh)
whitenoise.add_files(
static.resolver.resolve("warehouse:/static/dist/").abspath(),
prefix="/static/",
)
response = pretend.stub()
handler = pretend.call_recorder(lambda request: response)
registry = pretend.stub(whitenoise=whitenoise)
request = pretend.stub(path_info="/other/", registry=registry)
tween = static.whitenoise_tween_factory(handler, registry)
resp = tween(request)
assert resp is response
def test_bypasses(self, autorefresh):
whitenoise = WhiteNoise(None, autorefresh=autorefresh)
whitenoise.add_files(
static.resolver.resolve("warehouse:/static/dist/").abspath(),
prefix="/static/",
)
response = pretend.stub()
handler = pretend.call_recorder(lambda request: response)
registry = pretend.stub(whitenoise=whitenoise)
request = pretend.stub(path_info="/other/", registry=registry)
tween = static.whitenoise_tween_factory(handler, registry)
resp = tween(request)
assert resp is response
def create_app(_=None, **settings):
"""Configure and return the WSGI app."""
config = pyramid.config.Configurator(settings=load_settings(settings))
config.include("pyramid_exclog")
config.include("pyramid_jinja2")
config.include("pyramid_services")
config.include("h_pyramid_sentry")
config.include("via.views")
config.include("via.services")
# Configure Pyramid so we can generate static URLs
static_path = str(importlib_resources.files("via") / "static")
cache_buster = PathCacheBuster(static_path)
print(f"Cache buster salt: {cache_buster.salt}")
config.add_static_view(name="static", path="via:static")
config.add_cache_buster("via:static", cachebust=cache_buster)
# Make the CheckmateClient object available as request.checkmate.
config.add_request_method(ViaCheckmateClient, reify=True, name="checkmate")
config.add_tween("via.tweens.robots_tween_factory")
# Add this as near to the end of your config as possible:
config.include("pyramid_sanity")
app = WhiteNoise(
config.make_wsgi_app(),
index_file=True,
# Config for serving files at static/<salt>/path which are marked
# as immutable
root=static_path,
prefix=cache_buster.immutable_path,
immutable_file_test=cache_buster.get_immutable_file_test(),
)
app.add_files(
# Config for serving files at / which are marked as mutable. This is
# for / -> index.html
root=static_path,
prefix="/",
)
return app
def _create_whitenoise(app, config):
wh_config = config.registry.settings.get("whitenoise", {}).copy()
if wh_config:
# Create our Manifest immutable file checker.
manifest = ImmutableManifestFiles()
for manifest_spec, prefix in config.registry.settings.get(
"whitenoise.manifests", []
):
manifest.add_manifest(manifest_spec, prefix)
# Wrap our WSGI application with WhiteNoise
app = WhiteNoise(app, **wh_config, immutable_file_test=manifest)
# Go through and add all of the files we were meant to add.
for path, kwargs in config.registry.settings.get("whitenoise.files", []):
app.add_files(resolver.resolve(path).abspath(), **kwargs)
return app
def _create_whitenoise(app, config):
wh_config = config.registry.settings.get("whitenoise", {}).copy()
if wh_config:
# Create our Manifest immutable file checker.
manifest = ImmutableManifestFiles()
for manifest_spec, prefix in config.registry.settings.get(
"whitenoise.manifests", []
):
manifest.add_manifest(manifest_spec, prefix)
# Wrap our WSGI application with WhiteNoise
app = WhiteNoise(app, **wh_config, immutable_file_test=manifest)
# Go through and add all of the files we were meant to add.
for path, kwargs in config.registry.settings.get("whitenoise.files", []):
app.add_files(resolver.resolve(path).abspath(), **kwargs)
return app
def static(directory: str) -> WSGIApp:
"""Return a WSGI app that serves static files under the given directory.
Powered by WhiteNoise.
# Parameters
directory (str):
the path to a directory from where static files should be served.
If the directory does not exist, no files will be served.
# Returns
app (WSGIApp): a WSGI-compliant application.
# See Also
- [WhiteNoise](http://whitenoise.evans.io)
- [WSGI](https://wsgi.readthedocs.io)
"""
app = WhiteNoise(empty_wsgi_app())
if exists(directory):
app.add_files(directory)
return app
def test_method_not_allowed(self, autorefresh):
whitenoise = WhiteNoise(None, autorefresh=autorefresh)
whitenoise.add_files(
static.resolver.resolve("warehouse:/static/dist/").abspath(),
prefix="/static/",
)
response = pretend.stub()
handler = pretend.call_recorder(lambda request: response)
registry = pretend.stub(whitenoise=whitenoise)
request = pretend.stub(
method="POST",
environ={"HTTP_ACCEPT_ENCODING": "gzip"},
path_info="/static/manifest.json",
registry=registry,
)
tween = static.whitenoise_tween_factory(handler, registry)
resp = tween(request)
assert resp.status_code == 405
def test_method_not_allowed(self, autorefresh):
whitenoise = WhiteNoise(None, autorefresh=autorefresh)
whitenoise.add_files(
static.resolver.resolve("warehouse:/static/dist/").abspath(),
prefix="/static/",
)
response = pretend.stub()
handler = pretend.call_recorder(lambda request: response)
registry = pretend.stub(whitenoise=whitenoise)
request = pretend.stub(
method="POST",
environ={"HTTP_ACCEPT_ENCODING": "gzip"},
path_info="/static/manifest.json",
registry=registry,
)
tween = static.whitenoise_tween_factory(handler, registry)
resp = tween(request)
assert resp.status_code == 405
"""
WSGI config for Bostan project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/2.1/howto/deployment/wsgi/
"""
import os
from whitenoise import WhiteNoise
from django.core.wsgi import get_wsgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'Bostan.settings')
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
application = get_wsgi_application()
application = WhiteNoise(application, root=os.path.join(BASE_DIR, 'dist'), index_file=True)
application.add_files(os.path.join(BASE_DIR, 'staticfiles'), prefix="static/")
''' Pulls in the gunicorn application '''
from whitenoise import WhiteNoise
from bootstrap.start import app
from config import storage
application = WhiteNoise(app, root='storage/static')
for location, alias in storage.STATICFILES.items():
application.add_files(location, prefix=alias)
import os.path from flask_sslify import SSLify from werkzeug.contrib.fixers import ProxyFix from whitenoise import WhiteNoise from app.app import app SSLify(app, permanent=True) APP_ROOT = os.path.dirname(os.path.abspath(__file__)) wn_app = WhiteNoise(app.wsgi_app, root=os.path.join(APP_ROOT, 'static'), prefix='/static') wn_app.add_files(root=os.path.join(APP_ROOT, 'root_files'), prefix='') app.wsgi_app = wn_app app.wsgi_app = ProxyFix(app.wsgi_app)
"""
WSGI config for phonebook project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/2.1/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from django.conf import settings
from whitenoise import WhiteNoise
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'phonebook.settings')
application = WhiteNoise(get_wsgi_application())
application.add_files(os.path.join(settings.BASE_DIR, 'static'),
prefix='static')
application.add_files(os.path.join(settings.BASE_DIR, 'webapp', 'dist'),
prefix='')
"""
WSGI config for pollsapi project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from whitenoise import WhiteNoise
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'pollsapi.settings')
application = get_wsgi_application()
application = WhiteNoise(application, root='/pollsapi/static/')
application.add_files('/pollsapi/static/', prefix='files/')
"""
WSGI config for evecakes project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.0/howto/deployment/wsgi/
"""
import os
from whitenoise import WhiteNoise
from django.core.wsgi import get_wsgi_application
from .settings import BASE_DIR
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'evecakes.settings')
application = get_wsgi_application()
application = WhiteNoise(application, root=os.path.join(BASE_DIR, 'media'))
application.add_files(os.path.join(BASE_DIR, 'media'), prefix='uploads/')
"""
WSGI config for restaurant_rater project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from whitenoise import WhiteNoise
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'restaurant_rater.settings')
application = get_wsgi_application()
application = WhiteNoise(application,
root=os.environ.get('APP_STATIC_DIR', 'static'))
application.add_files('docs', 'docs')
"""
WSGI config for project_noe project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.0/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from whitenoise import WhiteNoise
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "project_noe.settings")
static_root = os.environ.get("STATIC_ROOT", "/project_noe/static_root")
application = get_wsgi_application()
application = WhiteNoise(application, root=static_root)
application.add_files(static_root, prefix="static/")
# only for local testing via $ heroku local web
#config_name = os.environ.get('FLASK_CONFIG') or 'production'
config_name = os.environ.get('FLASK_CONFIG') or 'production_heroku'
#config_name = os.environ.get('production_heroku')
print(config_name)
from app import create_app, db
from app.models import User
# creating app instance
application = create_app(config_name)
#test print out to confirm config settings
print"CONFIG SETTINGS FOR VIDEO UPLOAD: "
print(application.config["ALLOWED_EXTENSIONS"])
print(application.config["UPLOAD_FOLDER"])
print(application.config["MAX_CONTENT_LENGTH"])
#application = app()
application = WhiteNoise(application, root='/app/static/')
print(application)
application.add_files('/path/to/more/static/files', prefix='more-files/')
class API:
"""The primary web-service class.
:param static_dir: The directory to use for static files. Will be created for you if it doesn't already exist.
:param templates_dir: The directory to use for templates. Will be created for you if it doesn't already exist.
:param auto_escape: If ``True``, HTML and XML templates will automatically be escaped.
:param enable_hsts: If ``True``, send all responses to HTTPS URLs.
"""
status_codes = status_codes
def __init__(
self,
*,
debug=False,
title=None,
version=None,
openapi=None,
openapi_route="/schema.yml",
static_dir="static",
static_route="/static",
templates_dir="templates",
auto_escape=True,
secret_key=DEFAULT_SECRET_KEY,
enable_hsts=False,
docs_route=None,
cors=False,
):
self.secret_key = secret_key
self.title = title
self.version = version
self.openapi_version = openapi
self.static_dir = Path(os.path.abspath(static_dir))
self.static_route = static_route
self.templates_dir = Path(os.path.abspath(templates_dir))
self.built_in_templates_dir = Path(
os.path.abspath(os.path.dirname(__file__) + "/templates")
)
self.routes = {}
self.docs_theme = DEFAULT_API_THEME
self.docs_route = docs_route
self.schemas = {}
self.session_cookie = DEFAULT_SESSION_COOKIE
self.hsts_enabled = enable_hsts
self.cors = cors
self.cors_params = DEFAULT_CORS_PARAMS
# Make the static/templates directory if they don't exist.
for _dir in (self.static_dir, self.templates_dir):
os.makedirs(_dir, exist_ok=True)
self.whitenoise = WhiteNoise(application=self._default_wsgi_app)
self.whitenoise.add_files(str(self.static_dir))
self.whitenoise.add_files(
(
Path(apistar.__file__).parent / "themes" / self.docs_theme / "static"
).resolve()
)
self.apps = {}
self.mount(self.static_route, self.whitenoise)
self.formats = get_formats()
# Cached requests session.
self._session = None
self.background = BackgroundQueue()
if self.openapi_version:
self.add_route(openapi_route, self.schema_response)
if self.docs_route:
self.add_route(self.docs_route, self.docs_response)
self.default_endpoint = None
self.app = self.dispatch
self.add_middleware(GZipMiddleware)
if debug:
self.add_middleware(DebugMiddleware)
if self.hsts_enabled:
self.add_middleware(HTTPSRedirectMiddleware)
self.lifespan_handler = LifespanHandler()
if self.cors:
self.add_middleware(CORSMiddleware, **self.cors_params)
self.add_middleware(ExceptionMiddleware, debug=debug)
# Jinja enviroment
self.jinja_env = jinja2.Environment(
loader=jinja2.FileSystemLoader(
[str(self.templates_dir), str(self.built_in_templates_dir)],
followlinks=True,
),
autoescape=jinja2.select_autoescape(["html", "xml"] if auto_escape else []),
)
self.jinja_values_base = {"api": self} # Give reference to self.
self.requests = (
self.session()
) #: A Requests session that is connected to the ASGI app.
@staticmethod
def _default_wsgi_app(*args, **kwargs):
pass
@property
def _apispec(self):
spec = APISpec(
title=self.title,
version=self.version,
openapi_version=self.openapi_version,
plugins=[MarshmallowPlugin()],
)
for route in self.routes:
if self.routes[route].description:
operations = yaml_utils.load_operations_from_docstring(
self.routes[route].description
)
spec.add_path(path=route, operations=operations)
for name, schema in self.schemas.items():
spec.definition(name, schema=schema)
return spec
@property
def openapi(self):
return self._apispec.to_yaml()
def add_middleware(self, middleware_cls, **middleware_config):
self.app = middleware_cls(self.app, **middleware_config)
def __call__(self, scope):
if scope["type"] == "lifespan":
return self.lifespan_handler(scope)
path = scope["path"]
root_path = scope.get("root_path", "")
# Call into a submounted app, if one exists.
for path_prefix, app in self.apps.items():
if path.startswith(path_prefix):
scope["path"] = path[len(path_prefix) :]
scope["root_path"] = root_path + path_prefix
try:
return app(scope)
except TypeError:
app = WsgiToAsgi(app)
return app(scope)
return self.app(scope)
def dispatch(self, scope):
# Call the main dispatcher.
async def asgi(receive, send):
nonlocal scope, self
req = models.Request(scope, receive=receive, api=self)
resp = await self._dispatch_request(
req, scope=scope, send=send, receive=receive
)
await resp(receive, send)
return asgi
def add_schema(self, name, schema, check_existing=True):
"""Adds a mashmallow schema to the API specification."""
if check_existing:
assert name not in self.schemas
self.schemas[name] = schema
def schema(self, name, **options):
"""Decorator for creating new routes around function and class definitions.
Usage::
from marshmallow import Schema, fields
@api.schema("Pet")
class PetSchema(Schema):
name = fields.Str()
"""
def decorator(f):
self.add_schema(name=name, schema=f, **options)
return f
return decorator
def path_matches_route(self, path):
"""Given a path portion of a URL, tests that it matches against any registered route.
:param path: The path portion of a URL, to test all known routes against.
"""
for (route, route_object) in self.routes.items():
if route_object.does_match(path):
return route
def _prepare_cookies(self, resp):
if resp.cookies:
header = " ".join([f"{k}={v};" for k, v in resp.cookies.items()])
resp.headers["Set-Cookie"] = header
@property
def _signer(self):
return itsdangerous.Signer(self.secret_key)
def _prepare_session(self, resp):
if resp.session:
data = self._signer.sign(
b64encode(json.dumps(resp.session).encode("utf-8"))
)
resp.cookies[self.session_cookie] = data.decode("utf-8")
@staticmethod
def no_response(req, resp, **params):
pass
async def _dispatch_request(self, req, **options):
# Set formats on Request object.
req.formats = self.formats
# Get the route.
route = self.path_matches_route(req.url.path)
route = self.routes.get(route)
# Create the response object.
cont = False
if route:
if route.uses_websocket:
resp = WebSocket(**options)
else:
resp = models.Response(req=req, formats=self.formats)
params = route.incoming_matches(req.url.path)
if route.is_function:
try:
try:
# Run the view.
r = route.endpoint(req, resp, **params)
# If it's async, await it.
if hasattr(r, "cr_running"):
await r
except TypeError as e:
cont = True
except Exception:
self.default_response(req, resp, error=True)
raise
elif route.is_class_based or cont:
try:
view = route.endpoint(**params)
except TypeError:
try:
view = route.endpoint()
except TypeError:
view = route.endpoint
# Run on_request first.
try:
# Run the view.
r = getattr(view, "on_request", self.no_response)(
req, resp, **params
)
# If it's async, await it.
if hasattr(r, "send"):
await r
except Exception:
self.default_response(req, resp, error=True)
raise
# Then run on_method.
method = req.method
try:
# Run the view.
r = getattr(view, f"on_{method}", self.no_response)(
req, resp, **params
)
# If it's async, await it.
if hasattr(r, "send"):
await r
except Exception as e:
self.default_response(req, resp, error=True)
else:
resp = models.Response(req=req, formats=self.formats)
self.default_response(req, resp, notfound=True)
self.default_response(req, resp)
self._prepare_session(resp)
self._prepare_cookies(resp)
return resp
def add_event_handler(self, event_type, handler):
"""Adds an event handler to the API.
:param event_type: A string in ("startup", "shutdown")
:param handler: The function to run. Can be either a function or a coroutine.
"""
self.lifespan_handler.add_event_handler(event_type, handler)
def add_route(
self,
route,
endpoint=None,
*,
default=False,
static=False,
check_existing=True,
websocket=False,
):
"""Adds a route to the API.
:param route: A string representation of the route.
:param endpoint: The endpoint for the route -- can be a callable, or a class.
:param default: If ``True``, all unknown requests will route to this view.
:param static: If ``True``, and no endpoint was passed, render "static/index.html", and it will become a default route.
:param check_existing: If ``True``, an AssertionError will be raised, if the route is already defined.
"""
if check_existing:
assert route not in self.routes
if not endpoint and static:
endpoint = self.static_response
default = True
if default:
self.default_endpoint = endpoint
self.routes[route] = Route(route, endpoint, websocket=websocket)
# TODO: A better data structure or sort it once the app is loaded
self.routes = dict(
sorted(self.routes.items(), key=lambda item: item[1]._weight())
)
def default_response(self, req, resp, notfound=False, error=False):
if resp.status_code is None:
resp.status_code = 200
if self.default_endpoint and notfound:
self.default_endpoint(req, resp)
else:
if notfound:
resp.status_code = status_codes.HTTP_404
resp.text = "Not found."
if error:
resp.status_code = status_codes.HTTP_500
resp.text = "Application error."
def docs_response(self, req, resp):
resp.text = self.docs
def static_response(self, req, resp):
index = (self.static_dir / "index.html").resolve()
resp.content = ""
if os.path.exists(index):
with open(index, "r") as f:
resp.text = f.read()
def schema_response(self, req, resp):
resp.status_code = status_codes.HTTP_200
resp.headers["Content-Type"] = "application/x-yaml"
resp.content = self.openapi
def redirect(
self, resp, location, *, set_text=True, status_code=status_codes.HTTP_301
):
"""Redirects a given response to a given location.
:param resp: The Response to mutate.
:param location: The location of the redirect.
:param set_text: If ``True``, sets the Redirect body content automatically.
:param status_code: an `API.status_codes` attribute, or an integer, representing the HTTP status code of the redirect.
"""
# assert resp.status_code.is_300(status_code)
resp.status_code = status_code
if set_text:
resp.text = f"Redirecting to: {location}"
resp.headers.update({"Location": location})
def on_event(self, event_type: str, **args):
"""Decorator for registering functions or coroutines to run at certain events
Supported events: startup, cleanup, shutdown, tick
Usage::
@api.on_event('startup')
async def open_database_connection_pool():
...
@api.on_event('tick', seconds=10)
async def do_stuff():
...
@api.on_event('cleanup')
async def close_database_connection_pool():
...
"""
def decorator(func):
self.add_event_handler(event_type, func, **args)
return func
return decorator
def route(self, route, **options):
"""Decorator for creating new routes around function and class definitions.
Usage::
@api.route("/hello")
def hello(req, resp):
resp.text = "hello, world!"
"""
def decorator(f):
self.add_route(route, f, **options)
return f
return decorator
def mount(self, route, app):
"""Mounts an WSGI / ASGI application at a given route.
:param route: String representation of the route to be used (shouldn't be parameterized).
:param app: The other WSGI / ASGI app.
"""
self.apps.update({route: app})
def session(self, base_url="http://;"):
"""Testing HTTP client. Returns a Requests session object, able to send HTTP requests to the Responder application.
:param base_url: The URL to mount the connection adaptor to.
"""
if self._session is None:
self._session = TestClient(self)
return self._session
def _route_for(self, endpoint):
for (route, route_object) in self.routes.items():
if route_object.endpoint == endpoint:
return route_object
elif route_object.endpoint_name == endpoint:
return route_object
def url_for(self, endpoint, **params):
# TODO: Absolute_url
"""Given an endpoint, returns a rendered URL for its route.
:param view: The route endpoint you're searching for.
:param params: Data to pass into the URL generator (for parameterized URLs).
"""
route_object = self._route_for(endpoint)
if route_object:
return route_object.url(**params)
raise ValueError
def static_url(self, asset):
"""Given a static asset, return its URL path."""
return f"{self.static_route}/{str(asset)}"
@property
def docs(self):
loader = jinja2.PrefixLoader(
{
self.docs_theme: jinja2.PackageLoader(
"apistar", os.path.join("themes", self.docs_theme, "templates")
)
}
)
env = jinja2.Environment(autoescape=True, loader=loader)
document = apistar.document.Document()
document.content = yaml.safe_load(self.openapi)
template = env.get_template("/".join([self.docs_theme, "index.html"]))
def static_url(asset):
return f"{self.static_route}/{asset}"
# return asset
return template.render(
document=document,
langs=["javascript", "python"],
code_style=None,
static_url=static_url,
schema_url="/schema.yml",
)
def template(self, name_, **values):
"""Renders the given `jinja2 <http://jinja.pocoo.org/docs/>`_ template, with provided values supplied.
Note: The current ``api`` instance is by default passed into the view. This is set in the dict ``api.jinja_values_base``.
:param name_: The filename of the jinja2 template, in ``templates_dir``.
:param values: Data to pass into the template.
"""
# Prepopulate values with base
values = {**self.jinja_values_base, **values}
template = self.jinja_env.get_template(name_)
return template.render(**values)
def template_string(self, s_, **values):
"""Renders the given `jinja2 <http://jinja.pocoo.org/docs/>`_ template string, with provided values supplied.
Note: The current ``api`` instance is by default passed into the view. This is set in the dict ``api.jinja_values_base``.
:param s_: The template to use.
:param values: Data to pass into the template.
"""
# Prepopulate values with base
values = {**self.jinja_values_base, **values}
template = self.jinja_env.from_string(s_)
return template.render(**values)
def run(self, address=None, port=None, debug=False, **options):
"""Runs the application with uvicorn. If the ``PORT`` environment
variable is set, requests will be served on that port automatically to all
known hosts.
:param address: The address to bind to.
:param port: The port to bind to. If none is provided, one will be selected at random.
:param debug: Run uvicorn server in debug mode.
:param options: Additional keyword arguments to send to ``uvicorn.run()``.
"""
if "PORT" in os.environ:
if address is None:
address = "0.0.0.0"
port = int(os.environ["PORT"])
if address is None:
address = "127.0.0.1"
if port is None:
port = 5042
def spawn():
uvicorn.run(self, host=address, port=port, debug=debug, **options)
spawn()
"""
WSGI config for mics project.
This module contains the WSGI application used by Django's development server
and any production WSGI deployments. It should expose a module-level variable
named ``application``. Django's ``runserver`` and ``runfcgi`` commands discover
this application via the ``WSGI_APPLICATION`` setting.
Usually you will have the standard Django WSGI application here, but it also
might make sense to replace the whole Django WSGI application with a custom one
that later delegates to the Django one. For example, you could introduce WSGI
middleware here, or combine a Django application with an application of another
framework.
"""
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "mics.settings")
from django.core.wsgi import get_wsgi_application
from django.conf import settings
from whitenoise import WhiteNoise
application = get_wsgi_application()
application = WhiteNoise(application, root=settings.STATIC_ROOT)
if settings.STATICFILES_DIRS:
application.add_files(os.pathsep.join(settings.STATICFILES_DIRS))
"""
WSGI config for investment_portfolio project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.8/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from whitenoise import WhiteNoise
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "investment_portfolio.settings")
application = get_wsgi_application()
application = WhiteNoise(application, root='static')
application.add_files('staticfiles', prefix='more-files/')
from flask import Flask, render_template
from flask_assets import Bundle, Environment
from webassets.filter import register_filter
from webassets_elm import Elm
from whitenoise import WhiteNoise
# create app
app = Flask('cunhajacaiu')
app.config.from_object('cunhajacaiu.settings')
# config whitenoise
imgs = join(app.config['BASEDIR'], 'cunhajacaiu', 'static', 'imgs')
wsgi = WhiteNoise(app)
for dir in ('css', 'imgs', 'js'):
wsgi.add_files(join(app.config['STATIC_PATH'], dir), prefix=dir)
# create assets
register_filter(Elm)
assets = Environment(app)
css = Bundle(
'sass/app.sass',
depends=('**/*.sass',),
filters=('libsass',),
output='css/app.css'
)
elm = Bundle(
'elm/Main.elm',
depends=('**/*.elm',),
filters=('elm', 'uglifyjs',),
for name, command in [
('DEPLOY_DATE', "TZ=America/Detroit date '+%F %T'"),
]:
output = subprocess.run(command, shell=True, stdout=subprocess.PIPE,
universal_newlines=True).stdout.strip() or "???"
os.environ[name] = os.getenv(name, output)
# Configure the command-line interface
manager = Manager(_app)
@manager.command
def validate():
if _app.template_service.validate():
return 0
else:
return 1
manager.add_command('server', Server(host='0.0.0.0'))
manager.add_command('db', MigrateCommand)
app = WhiteNoise(_app)
app.add_files("data/images")
app.add_files("memegen/static")
if __name__ == '__main__':
manager.run()
"""
WSGI config for djreact project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.0/howto/deployment/wsgi/
"""
import os
from django.conf import settings
from django.core.wsgi import get_wsgi_application
from whitenoise import WhiteNoise
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djreact.settings')
application = get_wsgi_application()
application = WhiteNoise(application, root=settings.STATIC_ROOT)
application.add_files(settings.STATICFILES_DIRS)
import os
from django.core.wsgi import get_wsgi_application
from whitenoise import WhiteNoise
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'planeks.settings')
application = get_wsgi_application()
application = WhiteNoise(application, root='/static/')
application.add_files(root='/static/')
"""
WSGI config for consejero_server project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.11/howto/deployment/wsgi/
"""
import os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
os.environ['DJANGO_SETTINGS_MODULE'] = 'consejero_server.settings'
#from django.core.wsgi import get_wsgi_application
#os.environ.setdefault("DJANGO_SETTINGS_MODULE", "consejero_server.settings")
#application = get_wsgi_application()
#import django.core.handlers.wsgi
from django.core.wsgi import get_wsgi_application
from whitenoise import WhiteNoise
#application = django.core.handlers.wsgi.WSGIHandler()
application = get_wsgi_application()
application = WhiteNoise(application, root=BASE_DIR + '/static')
application.add_files(BASE_DIR + '/media', prefix='media/')
https://docs.djangoproject.com/en/2.1/howto/deployment/wsgi/
"""
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "gettingstarted.settings")
from django.core.wsgi import get_wsgi_application
from django.conf import settings
from whitenoise import WhiteNoise
application = get_wsgi_application()
application = WhiteNoise(application, root=settings.MEDIA_ROOT, prefix='media/')
application.add_files(settings.MEDIA_ROOT, prefix='media/')
# from whitenoise.django import DjangoWhiteNoise
# application = WhiteNoise(
# DjangoWhiteNoise(get_wsgi_application()),
# root=settings.MEDIA_ROOT,
# prefix='/media/',
# )
# from whitenoise import WhiteNoise
# from gettingstarted import MyWSGIApp
# application = MyWSGIApp()
from whitenoise import WhiteNoise
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'bootcampproject.settings')
application = get_wsgi_application()
application = WhiteNoise(application, root='/path/to/static/files')
application.add_files('/path/to/more/static/files', prefix='more-files/')
"""
WSGI config for pos project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.1/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from whitenoise import WhiteNoise
from power_stock.settings import MEDIA_ROOT, STATIC_ROOT
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'power_stock.settings')
application = get_wsgi_application()
application = WhiteNoise(application, root=STATIC_ROOT)
application.add_files(MEDIA_ROOT, prefix='media/')
"""
WSGI config for fruits_learning project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/1.10/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from whitenoise import WhiteNoise
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "fruits_learning.settings.dev")
application = get_wsgi_application()
application = WhiteNoise(
application,
root='/home/fruitschen/workspace/learning/fruits_learning/static')
application.add_files(
'/home/fruitschen/workspace/learning/fruits_learning/media',
prefix='media')
import os.path
from flask_sslify import SSLify
from werkzeug.contrib.fixers import ProxyFix
from whitenoise import WhiteNoise
from app import app
SSLify(app, permanent=True)
APP_ROOT = os.path.dirname(os.path.abspath(__file__))
wn_app = WhiteNoise(app.wsgi_app,
root=os.path.join(APP_ROOT, 'static'),
prefix='/static')
wn_app.add_files(root=os.path.join(APP_ROOT, 'root_files'), prefix='')
app.wsgi_app = wn_app
app.wsgi_app = ProxyFix(app.wsgi_app)
import os
import ddtrace
import django
import psycopg2
import redis
from django.core.wsgi import get_wsgi_application
from gevent import monkey
from whitenoise import WhiteNoise
from common.apm import tracer
ddtrace.patch_all()
ddtrace.patch(gevent=True)
ddtrace.Pin.override(django, tracer=tracer)
ddtrace.Pin.override(psycopg2, tracer=tracer)
ddtrace.Pin.override(redis, tracer=tracer)
monkey.patch_all()
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "turnout.settings")
application = get_wsgi_application()
application = WhiteNoise(application)
application.add_files("/app/static", prefix="static/") # type: ignore
"""
WSGI config for geodjango_news_map project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/2.2/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from whitenoise import WhiteNoise
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'geodjango_news_map.settings')
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
MEDIA_ROOT = os.path.join(BASE_DIR, 'geodjango_news_map_web/media/')
STATIC_ROOT = os.path.join(BASE_DIR, 'geodjango_news_map_web/static/')
application = get_wsgi_application()
application = WhiteNoise(application, root=MEDIA_ROOT)
application.add_files(STATIC_ROOT)
from whitenoise import WhiteNoise
from app import a
application = WhiteNoise(a)
application.add_files('static/', prefix='static/')
"""
WSGI config for PhenoBank project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/2.0/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
from whitenoise import WhiteNoise
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "PhenoBank.settings")
application = get_wsgi_application()
application = WhiteNoise(application)
#'C:/Users/szeme/Documents/Website/PhenoBank/CACHE','/home/admin/PhenoBank/CACHE'
application.add_files('/home/root/PhenoBank/CACHE', '/CACHE')
application.add_files('/home/root/PhenoBank/CACHE/upload', '/upload')
