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()
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)
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_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 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
from os.path import join 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',),
import eventlet from flask import Flask from flask import render_template from flask_socketio import SocketIO from flask_socketio import disconnect, emit from whitenoise import WhiteNoise import time eventlet.monkey_patch() app = Flask(__name__) app.wsgi_app = WhiteNoise(app.wsgi_app, root="static/") app.config['SECRET_KEY'] = 'Intel' socketio = SocketIO(app=app) COUNT = 0 @app.route("/", methods=["GET"]) def index(): """Send HTML file""" return render_template("index.html") @socketio.on("connect") def handle_connect(): """ Send current count to html page when anyone connect.
def __init__( self, *, debug=False, title=None, version=None, description=None, terms_of_service=None, contact=None, license=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, cors_params=DEFAULT_CORS_PARAMS, allowed_hosts=None, ): self.background = BackgroundQueue() self.secret_key = secret_key self.title = title self.version = version self.description = description self.terms_of_service = terms_of_service self.contact = contact self.license = license self.openapi_version = openapi if static_dir is not None: if static_route is None: static_route = static_dir static_dir = Path(os.path.abspath(static_dir)) self.static_dir = static_dir self.static_route = static_route self.built_in_templates_dir = Path( os.path.abspath(os.path.dirname(__file__) + "/templates")) if templates_dir is not None: templates_dir = Path(os.path.abspath(templates_dir)) self.templates_dir = templates_dir or self.built_in_templates_dir self.apps = {} self.routes = {} self.before_requests = {"http": [], "ws": []} 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 = cors_params self.debug = debug if not allowed_hosts: # if not debug: # raise RuntimeError( # "You need to specify `allowed_hosts` when debug is set to False" # ) allowed_hosts = ["*"] self.allowed_hosts = allowed_hosts # Make the static/templates directory if they don't exist. for _dir in (self.static_dir, self.templates_dir): if _dir is not None: os.makedirs(_dir, exist_ok=True) if self.static_dir is not None: self.whitenoise = WhiteNoise(application=self._notfound_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.mount(self.static_route, self.whitenoise) self.formats = get_formats() # Cached requests session. self._session = None 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.asgi self.add_middleware(GZipMiddleware) if self.hsts_enabled: self.add_middleware(HTTPSRedirectMiddleware) self.add_middleware(TrustedHostMiddleware, allowed_hosts=self.allowed_hosts) self.lifespan_handler = Lifespan() if self.cors: self.add_middleware(CORSMiddleware, **self.cors_params) self.add_middleware(ServerErrorMiddleware, debug=debug) # Jinja environment 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.
path('redstoneideas/', viewIdea), path('ads.txt', ads) ] if settings.DEBUG: import os from django.conf.urls.static import static print(os.path.join(settings.LOCAL_STATIC_CDN_PATH, 'static')) urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT) urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) else: 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', 'django_blog.settings') WhiteNoise.autorefresh = True application = WhiteNoise( application=get_wsgi_application(), root=settings.MEDIA_ROOT, prefix=settings.MEDIA_URL )
""" WSGI config for the 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 django.conf import settings from whitenoise import WhiteNoise # Use our production settings as our default settings, which is most secure os.environ.setdefault( "DJANGO_SETTINGS_MODULE", "twilio_sample_project.settings.production") # Get a WSGI application for our project application = get_wsgi_application() # Use Whitenoise to serve static files # See: https://whitenoise.readthedocs.org/ application = WhiteNoise(application, root=settings.STATIC_ROOT)
import os import sys from whitenoise import WhiteNoise from app.start import app from config import storage application = WhiteNoise(app, root='storage/static') for location, alias in storage.STATICFILES.iteritems(): application.add_files(location, prefix=alias)
import os from bottle import Bottle, response from whitenoise import WhiteNoise from ..settings import DATA_PATH api = Bottle() @api.hook('after_request') def enable_cors(): response.headers['Access-Control-Allow-Origin'] = '*' response.headers['Access-Control-Allow-Methods'] = 'GET, POST, DELETE' application = WhiteNoise(api) application.add_files(os.path.join(DATA_PATH, 'thumbnails'), prefix='thumbnails/') application.add_files(os.path.join(DATA_PATH, 'medias'), prefix='medias/')
# 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/')
status = '404 Not Found' response_headers = [ ('Content-Type', 'text/plain'), ('Content-Length', str(len(response_body))), ] start_response(status, response_headers) return [response_body.encode()] # Wrap the 404 responder above around a static file handler (Whitenoise) # This will intercept requests for serve static files and serve them if found # If not found, it will default to the 404 response APP = WhiteNoise( application_404, root=STATIC_FILE_DIR, index_file=True, mimetypes=MIME_TYPES, max_age=ONE_DAY, autorefresh=AUTO_REFRESH, ) # Define the lambda event handler to route all requests through the app above def lambda_handler(event, context): return awsgi.response(APP, event, context, base64_content_types=BASE64_CONTENT_TYPES) # Define local testing environment: AUTO_REFRESH=True python app.py if __name__ == '__main__':
def test_immutable_file_test_accepts_regex(self): instance = WhiteNoise(None, immutable_file_test=r'\.test$') self.assertTrue(instance.immutable_file_test('', '/myfile.test')) self.assertFalse(instance.immutable_file_test('', 'file.test.txt'))
import os import sys # Set up paths and environment variables sys.path.append(os.getcwd()) os.environ['DJANGO_SETTINGS_MODULE'] = 'multicassa.settings' import django.core.handlers.wsgi from django.core.wsgi import get_wsgi_application from whitenoise import WhiteNoise SCRIPT_NAME = 'multicassa/wsgi.py' SCRIPT_NAME = '' #solution for damn link problem class PassengerPathInfoFix(object): def __init__(self, app): self.app = app def __call__(self, environ, start_response): from urllib.parse import unquote environ['SCRIPT_NAME'] = SCRIPT_NAME request_uri = unquote(environ['REQUEST_URI']) script_name = unquote(environ.get('SCRIPT_NAME', '')) offset = request_uri.startswith(script_name) and len(environ['SCRIPT_NAME']) or 0 environ['PATH_INFO'] = request_uri[offset:].split('?', 1)[0] return self.app(environ, start_response) application = get_wsgi_application() application = PassengerPathInfoFix(application) application = WhiteNoise(application, root='/home/multikas/multicassa/static')
""" WSGI config for OnboardingApp 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', 'OnboardingApp.settings') application = get_wsgi_application() BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) application = WhiteNoise(application, root=os.path.join(BASE_DIR, 'root'))
from waitress import serve import os from croma.wsgi import application from whitenoise import WhiteNoise import logging if __name__ == '__main__': BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) logger = logging.getLogger('waitress') logger.setLevel(logging.INFO) my_application = serve(application, listen='*:8000') application = WhiteNoise(my_application, root=os.path.join(BASE_DIR, "static"))
""" WSGI config for askadev 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 from django.conf import settings os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'askadev.settings') application = get_wsgi_application() application = WhiteNoise(application, root=settings.STATIC_ROOT) application.add_files(settings.STATIC_ROOT, prefix='more-files/')
from whitenoise import WhiteNoise # import variable app (Flask instanse) from file app.py from app import app # create WhiteNoise application as decorator of Flask application application = WhiteNoise(app) # connect WhiteNoise application with static files application.add_files('static/', prefix='static/')
""" 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 JellyBot 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 # Django os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'JellyBot.settings') application = get_wsgi_application() application = WhiteNoise(application, root='static')
import os from flask import Flask from whitenoise import WhiteNoise from app import create_app from dotenv import load_dotenv load_dotenv() PROJECT_ROOT = os.path.dirname(os.path.abspath(__file__)) STATIC_ROOT = os.path.join(PROJECT_ROOT, 'app', 'static') STATIC_URL = 'static/' app = Flask('app') create_app(app) application = WhiteNoise(app, STATIC_ROOT, STATIC_URL)
""" WSGI server for 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/3.0/howto/deployment/wsgi/ """ import os from django.core.wsgi import get_wsgi_application from whitenoise import WhiteNoise #from whitenoise.django import DjangoWhiteNoise os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'server.settings.prod') application = get_wsgi_application() application = WhiteNoise( application, root='/home/ubuntu/srv/Chatt-project-backend/staticfiles') #application = DjangoWhiteNoise(application)
""" WSGI config for DPMMain 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 os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'DPMMain.settings') application = get_wsgi_application() application = WhiteNoise(application, root='DPMAPI') application.add_files('DPMAPI', prefix='static/')
docs = db.collection(u'Models').document(u'IPOWERFAN').collection( u'Assets').stream() for doc in docs: dic = doc.to_dict() dic['id'] = doc.id assets.append(dic) return assets except google.cloud.exceptions.NotFound: return 'error' updateAssetLists('IPOWERFAN001MPU', True) app = Flask(__name__) app.wsgi_app = WhiteNoise(app.wsgi_app) my_static_folders = ('static/assets/js/', 'static/bower_components/') for static in my_static_folders: app.wsgi_app.add_files(static) data = pd.read_csv("data.csv") data = data.drop(columns=['||__time']) data = shuffle(data) feature_cols = data.drop(['Normality', 'RUL'], axis=1).columns X = data[feature_cols] y = data.Normality # split the data into test/train X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20) neigh = KNeighborsClassifier(n_neighbors=7) neigh.fit(X_train, y_train)
import requests from whitenoise import WhiteNoise from gtts import gTTS from flask import (Flask, flash, redirect, render_template, request, send_from_directory, url_for) import run_script UPLOAD_FOLDER = './static/images/' ALLOWED_EXTENSIONS = set(['jpg', 'jpeg', 'png']) YANDEX_API_KEY = 'YOUR API KEY HERE' SECRET_KEY = '7d441f27d441f27567d441f2b6176a' app = Flask(__name__) app.wsgi_app = WhiteNoise(app.wsgi_app, root='static/') app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER app.secret_key = SECRET_KEY @app.route('/<path:path>') def static_file(path): return app.send_static_file(path) # check if file extension is right def allowed_file(filename): return '.' in filename and \ filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
def make_wsgi_app(): passwd = {'admin': '123'} # BasicAuth applications create = BasicAuth(BlogCreate, 'www', passwd) update = BasicAuth(BlogUpdate, 'www', passwd) delete = BasicAuth(BlogDelete, 'www', passwd) # URL dispatching middleware dispatch = selector.Selector() dispatch.add('/', GET=BlogIndex) dispatch.prefix = '/article' dispatch.add('/add', GET=create, POST=create) dispatch.add('/{id:digits}', GET=BlogRead) dispatch.add('/{id:digits}/edit', GET=update, POST=update) dispatch.add('/{id:digits}/delete', GET=delete) return dispatch if __name__ == '__main__': app = make_wsgi_app() from whitenoise import WhiteNoise app = WhiteNoise(app) app.add_files('./static/', prefix='static/') from paste.httpserver import serve serve(app, host='0.0.0.0', port=8000)
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", "smswebapp.settings") application = get_wsgi_application() # Only *after* the application is initialised above will the Django settings be available. from django.conf import settings # noqa: E402 whitenoise_params = {} if settings.DEBUG: # In development (when DEBUG is True), enable the whitenoise autorefresh feature which will # check if the file has updated on disk before responding. whitenoise_params['autorefresh'] = True application = WhiteNoise( application, root=settings.FRONTEND_APP_BUILD_DIR, prefix='/', index_file=True, **whitenoise_params, )
""" WSGI config for fech 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", "fech.settings.dev") application = get_wsgi_application() application = WhiteNoise(application) application.add_files('./static', prefix='static') application.add_files('./media', prefix='media')
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. :param title: The title of the application (OpenAPI Info Object) :param version: The version of the OpenAPI document (OpenAPI Info Object) :param description: The description of the OpenAPI document (OpenAPI Info Object) :param terms_of_service: A URL to the Terms of Service for the API (OpenAPI Info Object) :param contact: The contact dictionary of the application (OpenAPI Contact Object) :param license: The license information of the exposed API (OpenAPI License Object) """ status_codes = status_codes def __init__( self, *, debug=False, title=None, version=None, description=None, terms_of_service=None, contact=None, license=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, cors_params=DEFAULT_CORS_PARAMS, allowed_hosts=None, ): self.background = BackgroundQueue() self.secret_key = secret_key self.title = title self.version = version self.description = description self.terms_of_service = terms_of_service self.contact = contact self.license = license self.openapi_version = openapi if static_dir is not None: if static_route is None: static_route = static_dir static_dir = Path(os.path.abspath(static_dir)) self.static_dir = static_dir self.static_route = static_route self.built_in_templates_dir = Path( os.path.abspath(os.path.dirname(__file__) + "/templates")) if templates_dir is not None: templates_dir = Path(os.path.abspath(templates_dir)) self.templates_dir = templates_dir or self.built_in_templates_dir self.apps = {} self.routes = {} self.before_requests = {"http": [], "ws": []} 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 = cors_params self.debug = debug if not allowed_hosts: # if not debug: # raise RuntimeError( # "You need to specify `allowed_hosts` when debug is set to False" # ) allowed_hosts = ["*"] self.allowed_hosts = allowed_hosts # Make the static/templates directory if they don't exist. for _dir in (self.static_dir, self.templates_dir): if _dir is not None: os.makedirs(_dir, exist_ok=True) if self.static_dir is not None: self.whitenoise = WhiteNoise(application=self._notfound_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.mount(self.static_route, self.whitenoise) self.formats = get_formats() # Cached requests session. self._session = None 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.asgi self.add_middleware(GZipMiddleware) if self.hsts_enabled: self.add_middleware(HTTPSRedirectMiddleware) self.add_middleware(TrustedHostMiddleware, allowed_hosts=self.allowed_hosts) self.lifespan_handler = Lifespan() if self.cors: self.add_middleware(CORSMiddleware, **self.cors_params) self.add_middleware(ServerErrorMiddleware, debug=debug) # Jinja environment 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(environ, start_response): pass @staticmethod def _notfound_wsgi_app(environ, start_response): start_response("404 NOT FOUND", [("Content-Type", "text/plain")]) return [b"Not Found."] def before_request(self, websocket=False): def decorator(f): if websocket: self.before_requests.setdefault("ws", []).append(f) else: self.before_requests.setdefault("http", []).append(f) return f return decorator @property def before_http_requests(self): return self.before_requests.get("http", []) @property def before_ws_requests(self): return self.before_requests.get("ws", []) @property def _apispec(self): info = {} if self.description is not None: info["description"] = self.description if self.terms_of_service is not None: info["termsOfService"] = self.terms_of_service if self.contact is not None: info["contact"] = self.contact if self.license is not None: info["license"] = self.license spec = APISpec( title=self.title, version=self.version, openapi_version=self.openapi_version, plugins=[MarshmallowPlugin()], info=info, ) for route in self.routes: if self.routes[route].description: operations = yaml_utils.load_operations_from_docstring( self.routes[route].description) spec.path(path=route, operations=operations) for name, schema in self.schemas.items(): spec.components.schema(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) async def __call__(self, scope, receive, send): if scope["type"] == "lifespan": await self.lifespan_handler(scope, receive, send) return 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: await app(scope, receive, send) return except TypeError: app = WSGIMiddleware(app) await app(scope, receive, send) return await self.app(scope, receive, send) async def asgi(self, scope, receive, send): assert scope["type"] in ("http", "websocket") if scope["type"] == "websocket": await self._dispatch_ws(scope=scope, receive=receive, send=send) else: req = models.Request(scope, receive=receive, api=self) resp = await self._dispatch_http(req, scope=scope, send=send, receive=receive) await resp(scope, receive, send) async def _dispatch_http(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) if route: resp = models.Response(req=req, formats=self.formats) for before_request in self.before_http_requests: await self.background(before_request, req=req, resp=resp) await self._execute_route(route=route, req=req, resp=resp, **options) else: resp = models.Response(req=req, formats=self.formats) self.default_response(req=req, resp=resp, notfound=True) self.default_response(req=req, resp=resp) self._prepare_session(resp) return resp async def _dispatch_ws(self, scope, receive, send): ws = WebSocket(scope=scope, receive=receive, send=send) route = self.path_matches_route(ws.url.path) route = self.routes.get(route) if route: for before_request in self.before_ws_requests: await self.background(before_request, ws=ws) await self.background(route.endpoint, ws) else: await send({"type": "websocket.close", "code": 1000}) 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 @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 _execute_route(self, *, route, req, resp, **options): params = route.incoming_matches(req.url.path) cont = True if route.is_function: try: try: # Run the view. r = self.background(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: await self.background(self.default_response, req, resp, error=True) raise if route.is_class_based or cont: try: view = route.endpoint(**params) except TypeError: try: view = route.endpoint() except TypeError: view = route.endpoint pass # Run on_request first. try: # Run the view. r = getattr(view, "on_request", self.no_response) r = self.background(r, req, resp, **params) # If it's async, await it. if hasattr(r, "send"): await r except Exception: await self.background(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) r = self.background(r, req, resp, **params) # If it's async, await it. if hasattr(r, "send"): await r except Exception: await self.background(self.default_response, req, resp, error=True) raise 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=None, endpoint=None, *, default=False, static=False, check_existing=True, websocket=False, before_request=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 before_request: if websocket: self.before_requests.setdefault("ws", []).append(endpoint) else: self.before_requests.setdefault("http", []).append(endpoint) return if route is None: route = f"/{uuid4().hex}" if check_existing: assert route not in self.routes if static: assert self.static_dir is not None if not endpoint: 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=None, resp=None, websocket=False, notfound=False, error=False): if websocket: return if resp.status_code is None: resp.status_code = 200 if self.default_endpoint and notfound: self.default_endpoint(req=req, resp=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.html = self.docs def static_response(self, req, resp): assert self.static_dir is not None index = (self.static_dir / "index.html").resolve() if os.path.exists(index): with open(index, "r") as f: resp.html = f.read() else: resp.status_code = status_codes.HTTP_404 resp.text = "Not found." 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, shutdown Usage:: @api.on_event('startup') async def open_database_connection_pool(): ... @api.on_event('shutdown') 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=None, **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, base_url=base_url) return self._session def _route_for(self, endpoint): for route_object in self.routes.values(): if endpoint in (route_object.endpoint, route_object.endpoint_name): return route_object def url_for(self, endpoint, **params): # TODO: Absolute_url """Given an endpoint, returns a rendered URL for its route. :param endpoint: 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.""" assert None not in (self.static_dir, self.static_route) 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"])) return template.render( document=document, langs=["javascript", "python"], code_style=None, static_url=self.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 serve(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() def run(self, **kwargs): if "debug" not in kwargs: kwargs.update({"debug": self.debug}) self.serve(**kwargs)
""" WSGI config for bhtom 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 django.conf import settings from django.contrib.staticfiles.handlers import StaticFilesHandler from whitenoise import WhiteNoise os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'bhtom.settings') # if settings.DEBUG: # application = StaticFilesHandler(get_wsgi_application()) # else: # application = get_wsgi_application() application = get_wsgi_application() application = WhiteNoise(application, root='/Users/wyrzykow/bhtom/myapp/static') #application.add_files('/path/to/more/static/files', prefix='more-files/')
""" WSGI config for devfolio 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", "devfolio.settings") application = get_wsgi_application() application = WhiteNoise(application)
""" WSGI config for keeper 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", "keeper.settings") # for Heroku application = WhiteNoise(get_wsgi_application())
import os from django.core.wsgi import get_wsgi_application from whitenoise import WhiteNoise os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings.dev') application = get_wsgi_application() application = WhiteNoise(application, root='./staticfiles')
def register(): config.registry.whitenoise = WhiteNoise(None, **kwargs)
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)
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')
def test_directory_path_can_be_pathlib_instance(self): from pathlib import Path root = Path(Files('root').directory) # Check we can construct instance without it blowing up WhiteNoise(None, root=root, autorefresh=True)
""" 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/')
# app.py from flask import * from whitenoise import WhiteNoise app = Flask(__name__) app.wsgi_app = WhiteNoise(app.wsgi_app, root='static/', prefix='static/', index_file="index.htm", autorefresh=True) @app.route('/', methods=['GET']) def hello(): return make_response("Hello, world!!!!!!!!!!!!!") if __name__ == "__main__": app.run(threaded=True, port=5000)
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()
from prototype_bootstrap_navbar import app from whitenoise import WhiteNoise application = WhiteNoise(app, root='/static') if __name__ == "__main__": application.run()