def generate_context(self): if self.settings['WEBASSETS']: from webassets import Environment as AssetsEnvironment # Define the assets environment that will be passed to the # generators. The StaticGenerator must then be run first to have # the assets in the output_path before generating the templates. # Let ASSET_URL honor Pelican's RELATIVE_URLS setting. # Hint for templates: # Current version of webassets seem to remove any relative # paths at the beginning of the URL. So, if RELATIVE_URLS # is on, ASSET_URL will start with 'theme/', regardless if we # set assets_url here to './theme/' or to 'theme/'. # XXX However, this breaks the ASSET_URL if user navigates to # a sub-URL, e.g. if he clicks on a category. To workaround this # issue, I use # <link rel="stylesheet" href="{{ SITEURL }}/{{ ASSET_URL }}"> # instead of # <link rel="stylesheet" href="{{ ASSET_URL }}"> if self.settings.get('RELATIVE_URLS'): assets_url = './theme/' else: assets_url = self.settings['SITEURL'] + '/theme/' assets_src = os.path.join(self.output_path, 'theme') self.assets_env = AssetsEnvironment(assets_src, assets_url) if logging.getLevelName(logger.getEffectiveLevel()) == "DEBUG": self.assets_env.debug = True
def setup(self): # Setup the assets environment. assets_env = AssetsEnvironment('', '') self.foo_bundle = Bundle() self.bar_bundle = Bundle() assets_env.register('foo_bundle', self.foo_bundle) assets_env.register('bar_bundle', self.bar_bundle) # Inject a mock bundle class into the Jinja2 extension, so we # can check on what exactly it does. test_instance = self class MockBundle(Bundle): urls_to_fake = ['foo'] def __init__(self, *a, **kw): Bundle.__init__(self, *a, **kw) self.env = assets_env # Kind of hacky, but gives us access to the last Bundle # instance used by the extension. test_instance.the_bundle = self def urls(self, *a, **kw): return self.urls_to_fake self._old_bundle_class = AssetsExtension.BundleClass AssetsExtension.BundleClass = self.BundleClass = MockBundle # Setup the Jinja2 environment. self.jinja_env = JinjaEnvironment() self.jinja_env.add_extension(AssetsExtension) self.jinja_env.assets_environment = assets_env
def get_jinja_renderer(template_path): """ This returns a method render(template, data) that will render the provided template with the given data using an initialized jinja2 environment. The primary reasons why we need this are: - asset handling (for example for logos) - reloading of templates (while designing the template) :param template_path: the directory that contains all templates and assets """ # template_path asset_path = os.path.join(template_path, "assets") if not os.path.isdir(template_path): raise ValueError("%s must be a directory" % template_path) if not os.path.isdir(asset_path): raise ValueError("%s must be a directory" % asset_path) assets_env = AssetsEnvironment(asset_path, "file://" + os.path.abspath(asset_path)) jinja2_env = Jinja2Environment( extensions=[AssetsExtension], loader=FileSystemLoader(template_path), auto_reload=True, autoescape=True, # undefined=StrictUndefined ) jinja2_env.assets_environment = assets_env def jinja_env_renderer(template_filename, data): template = jinja2_env.get_template(template_filename) return template.render(data) return jinja_env_renderer
def __init__(self, path, output, static_path='static', static_url='static', asset_config='config.yml'): self.path = path self.output = output self.output_path = os.path.join(path, output) self.env = Environment(loader=FileSystemLoader(path), extensions=[AssetsExtension]) try: config_path = os.path.join(self.path, asset_config) asset_config = YAMLLoader(config_path) self.assets_env = asset_config.load_environment() except IOError: self.assets_env = AssetsEnvironment() if 'directory' not in self.assets_env.config: self.assets_env.directory = self.output_path if 'url' not in self.assets_env.config: self.assets_env.url = static_url self.assets_env.load_path = [self.path] self.env.assets_environment = self.assets_env
def compile_pages_and_assets(dev=False): compiledSass = '' sass_files_to_compile = ['main.scss'] for sassFile in sass_files_to_compile: # with open('resources/css/scss/'+sassFile, 'r') as thisfile: # SassData=thisfile.read() compiledSass += sass.compile(filename='resources/css/scss/'+sassFile, include_paths='resources/css/scss/vendor/') with open('resources/css/sass.css', 'w') as outputFile: outputFile.write(compiledSass) if(dev): all_js = Bundle('**/*.js', filters='noop', output='packed.js') all_css = Bundle('**/*.css', filters='noop', output="main.css") else: all_js = Bundle('**/*.js', filters='jsmin', output='packed.js') all_css = Bundle('**/*.css', filters='cssmin', output="main.css") jinja_env = Jinja2Environment(extensions=[AssetsExtension]) jinja_env.loader = FileSystemLoader('.') assets_env = AssetsEnvironment(url='/assets', directory='resources') assets_env.register('all_js', all_js) assets_env.register('all_css', all_css) jinja_env.assets_environment = assets_env pages = [] pages_dir = 'pages' for path, subdirs, files in os.walk(pages_dir): for name in files: pages.append(os.path.join(path, name)[6:]) # print(pages) for page in pages: thisTemplate = jinja_env.get_template('pages/' + page) thisTempRendered = thisTemplate.render() file_name = 'output/' + page body_content_location = 'output/content/' + page pathlib.Path(os.path.dirname(file_name)).mkdir(parents=True, exist_ok=True) pathlib.Path(os.path.dirname(body_content_location)).mkdir(parents=True, exist_ok=True) with open(file_name, 'w') as tempFile: tempFile.write(thisTempRendered) # This bit is used for my ajax shenanigans # anything you want on a page needs to go on body though... result = re.search('<body>(.*)<\/body>', '"' + thisTempRendered.replace('"', '\"').replace('\n',' ') + '"') # print(result) onlyTheBodyPart = result.group(1) with open(body_content_location, 'w') as tempFile: tempFile.write(onlyTheBodyPart) src = 'resources' dst = 'output/assets' filelist = [] files = ['main.css', 'packed.js'] for filename in files: filelist.append(filename) fullpath = src + '/' + filename shutil.move(os.path.join(src, filename), os.path.join(dst, filename))
def __init__(self): tornado.web.Application.__init__(self, urls, **settings) self.assets_env = AssetsEnvironment('../static', '') self.env = Jinja2Environment(loader=FileSystemLoader( settings.get('template_path')), extensions=[AssetsExtension]) self.env.assets_environment = self.assets_env
def add_template_env(self, lang): self.template_envs[lang] = Environment( loader=PackageLoader('frontend', 'templates'), extensions=[ 'jinja2.ext.i18n', 'webassets.ext.jinja2.AssetsExtension' ]) self.template_envs[lang].install_gettext_translations( self.babel_envs[lang]) self.template_envs[lang].filters['markdown'] = markdown_filter asset_env = AssetsEnvironment(config.MEDIA_ROOT, config.MEDIA_URL) self.template_envs[lang].assets_environment = asset_env
def generate_context(self): if self.settings['WEBASSETS']: from webassets import Environment as AssetsEnvironment # Define the assets environment that will be passed to the # generators. The StaticGenerator must then be run first to have # the assets in the output_path before generating the templates. assets_url = self.settings['SITEURL'] + '/theme/' assets_src = os.path.join(self.output_path, 'theme') self.assets_env = AssetsEnvironment(assets_src, assets_url) if logging.getLevelName(logger.getEffectiveLevel()) == "DEBUG": self.assets_env.debug = True
def register_assets(): """ Initialize webassets environment and its bundles NOTE: The asset bundles building is lazy, webassets only do building when he is invoked by his template tag **assets** and if it detect that a file in a bundle has changed. """ logger = logging.getLogger('optimus') if not settings.ENABLED_BUNDLES: logger.warning( "Asset registering skipped as there are no enabled bundles") return None logger.info("Starting asset registering") # Assets bundles AVAILABLE_BUNDLES = getattr(settings, 'BUNDLES', {}) # Initialize webassets environment assets_env = AssetsEnvironment() assets_env.debug = settings.DEBUG assets_env.url = settings.STATIC_URL assets_env.directory = settings.STATIC_DIR assets_env.load_path = [settings.SOURCES_DIR] assets_env.cache = settings.WEBASSETS_CACHE # assets_env.optimus_registry = AssetRegistry() # Register enabled assets bundles for bundle_name in settings.ENABLED_BUNDLES: logger.debug("Registering bundle: %s", bundle_name) # Little trick because Bundle does not know their used name in the webassets # environment AVAILABLE_BUNDLES[bundle_name]._internal_env_name = bundle_name assets_env.register(bundle_name, AVAILABLE_BUNDLES[bundle_name]) assets_env.optimus_registry.add_bundle(AVAILABLE_BUNDLES[bundle_name]) # for debugging purpopse for bundle_name in settings.ENABLED_BUNDLES: logger.info(" Processing: %s", assets_env[bundle_name].resolve_output()) # TODO: conditionnal on the log level to avoid to loop on multiple items if not # in a debug log level for url in assets_env[bundle_name].urls(): logger.debug(" - %s", url) return assets_env
def initialize(self): loader = FileSystemLoader([ self.settings['template_path'], self.settings['snippet_path']]) assets_env = AssetsEnvironment(self.settings['static_path'], self.static_url('')) register_filter(LibSass) self.template_env = JinjaEnvironment( loader=loader, extensions=[AssetsExtension]) self.template_env.assets_environment = assets_env self.template_env.filters['stylesheet_tag'] = self.stylesheet_tag self.template_env.filters['javascript_tag'] = self.javascript_tag self.template_env.filters['theme_image_url'] = self.theme_image_url self.template_env.globals = self.get_globals() self.site = self.settings['site']
def get_webassets_env(conf): '''Get a preconfigured WebAssets environment''' # Configure webassets assets_environment = AssetsEnvironment(conf.get('static_files_dir', DEFAULT_STATIC), '/') assets_environment.debug = conf.get('debug', False) assets_environment.auto_build = conf.get('debug', False) assets_environment.config['less_paths'] = ( 'bower/bootstrap/less', 'bower/etalab-assets/less', 'bower/bootstrap-markdown/less', ) # Load bundle from yaml file loader = YAMLLoader(resource_stream(__name__, '../assets.yaml')) bundles = loader.load_bundles() for name, bundle in bundles.items(): assets_environment.register(name, bundle) return assets_environment
def __init__(self, settings): handlers = routes.get_routes() + [ tornado.web.URLSpec( r'/login/google', GoogleLoginHandler, name='login_google'), tornado.web.URLSpec(r'/', MainHandler, name='home'), tornado.web.URLSpec(r'/(.*)', tornado.web.StaticFileHandler, {'path': os.path.join(PRJ_ROOT, 'static')}, name='homestatic'), tornado.web.URLSpec(r'/login/', LoginHandler, name='login'), tornado.web.URLSpec(r'/login/facebook', FacebookLoginHandler, name='login_facebook'), tornado.web.URLSpec( r'/login/twitter', TwitterLoginHandler, name='login_twitter'), tornado.web.URLSpec(r'/logout', AuthLogoutHandler, name='logout'), #(r'/static/(.*)', tornado.web.StaticFileHandler, # {'path': os.path.join(PRJ_ROOT, 'static')}), ] if not settings['db_uri'].startswith('mongodb://'): settings['db_connection'] = connect(settings['db_uri']) else: #_tmp_db = settings['db_uri'][10:] #_tmp_db_name = _tmp_db.split('/')[1] #host="localhost", port=27017 #settings['db_connection'] = connect(_tmp_db_name, host="localhost", port=27017) pass template_dirs = [] jinja2_env = None if settings.get('template_path'): template_dirs.append(settings['template_path']) assets_env = AssetsEnvironment(settings['static_path'], '/') settings['jinja2_env'] = Jinja2Environment( loader=FileSystemLoader(template_dirs), extensions=[AssetsExtension]) settings['jinja2_env'].assets_environment = assets_env tornado.web.Application.__init__(self, handlers, **settings)
def render_template(self, template_name, **kw): if not self._jinja_env: self._jinja_env = Environment(loader=FileSystemLoader( self.settings['template_path']), extensions=[AssetsExtension]) self._jinja_env.filters.update({ 'utc2cst': lambda dt: dt + datetime.timedelta(hours=8), 'jstime2py': lambda ts: datetime.datetime.fromtimestamp(ts / 1000), 'time_format': lambda dt: datetime.datetime.strftime(dt, '%Y/%m/%d %H:%M:%S'), }) if not self._assets_env: self._assets_env = AssetsEnvironment( self.settings['static_path'], self.settings['static_url_prefix'], ) self._jinja_env.assets_environment = self._assets_env template = self._jinja_env.get_template(template_name) content = template.render(kw) return content
app.config['SECURITY_USER_IDENTITY_ATTRIBUTES'] = 'username' app.config['BABEL_DEFAULT_LOCALE'] = 'he' app.config['OAUTH_CREDENTIALS'] = { 'facebook': { 'id': os.environ.get('FACEBOOK_KEY'), 'secret': os.environ.get('FACEBOOK_SECRET') }, 'google': { 'id': os.environ.get('GOOGLE_LOGIN_CLIENT_ID'), 'secret': os.environ.get('GOOGLE_LOGIN_CLIENT_SECRET') } } assets = Environment() assets.init_app(app) assets_env = AssetsEnvironment(os.path.join(utilities._PROJECT_ROOT, 'static'), '/static') jinja_environment = jinja2.Environment(autoescape=True, loader=jinja2.FileSystemLoader( os.path.join( os.path.dirname(__file__), "../templates")), extensions=[AssetsExtension]) jinja_environment.assets_environment = assets_env sg = sendgrid.SendGridClient(app.config['SENDGRID_USERNAME'], app.config['SENDGRID_PASSWORD'], raise_errors=True) babel = Babel(app)
from __future__ import absolute_import import logging import re from ..constants import SUPPORTED_TIMEZONES from os import path, environ from falcon import HTTPNotFound from jinja2 import FileSystemLoader from jinja2.environment import Environment as Jinja2Environment from webassets import Environment as AssetsEnvironment, Bundle from webassets.ext.jinja2 import AssetsExtension from webassets.script import CommandLineEnvironment STATIC_ROOT = environ.get('STATIC_ROOT', path.abspath(path.dirname(__file__))) assets_env = AssetsEnvironment(path.join(STATIC_ROOT, 'static'), url='/static') assets_env.register( 'libs', Bundle('js/jquery-2.1.4.min.js', 'js/handlebars.min.js', 'js/bootstrap.min.js', 'js/moment.js', 'js/moment-timezone.js', 'js/moment-tz-data.js', 'js/typeahead.js', output='bundles/libs.js')) assets_env.register( 'oncall_js', Bundle('js/navigo.js', 'js/incalendar.js',
from flaskext.babel import gettext, ngettext, lazy_gettext from webassets.ext.jinja2 import AssetsExtension from webassets import Environment as AssetsEnvironment if os.environ.has_key('SAGENB_TEMPLATE_PATH'): if not os.path.isdir(os.environ['SAGENB_TEMPLATE_PATH']): raise ValueError("Enviromental variable SAGENB_TEMPLATE_PATH points to\ a non-existant directory") TEMPLATE_PATH = os.environ['SAGENB_TEMPLATE_PATH'] else: TEMPLATE_PATH = os.path.join(DATA, 'sage') env = jinja2.Environment(loader=jinja2.FileSystemLoader(TEMPLATE_PATH), extensions=[AssetsExtension]) env.assets_environment = AssetsEnvironment(DATA, '/data') css_illegal_re = re.compile(r'[^-A-Za-z_0-9]') def css_escape(string): r""" Returns a string with all characters not legal in a css name replaced with hyphens (-). INPUT: - ``string`` -- the string to be escaped. EXAMPLES::
import jinja2 from flask import make_response, jsonify, render_template, Response import flask.ext.assets from webassets.ext.jinja2 import AssetsExtension from webassets import Environment as AssetsEnvironment from database import db_session from models import * from base import * import utilities app = utilities.init_flask(__name__) assets = flask.ext.assets.Environment() assets.init_app(app) assets_env = AssetsEnvironment('./static/', '/static') jinja_environment = jinja2.Environment(autoescape=True, loader=jinja2.FileSystemLoader( os.path.join( os.path.dirname(__file__), "templates")), extensions=[AssetsExtension]) jinja_environment.assets_environment = assets_env MINIMAL_ZOOM = 16 @app.teardown_appcontext def shutdown_session(exception=None): db_session.remove()
import ujson import requests import importlib import logging import re from iris.ui import auth from beaker.middleware import SessionMiddleware logger = logging.getLogger(__name__) _filename_ascii_strip_re = re.compile(r'[^A-Za-z0-9_.-]') ui_root = os.environ.get('STATIC_ROOT', os.path.abspath(os.path.dirname(__file__))) assets_env = AssetsEnvironment(os.path.join(ui_root, 'static'), url='/static') assets_env.register( 'jquery_libs', Bundle('js/jquery-2.1.4.min.js', 'js/jquery.dataTables.min.js', 'js/handlebars.min.js', 'js/hopscotch.min.js', output='bundles/jquery.libs.js')) assets_env.register( 'bootstrap_libs', Bundle('js/bootstrap.min.js', 'js/typeahead.js', 'js/bootstrap-datetimepicker.js', output='bundles/bootstrap.libs.js')) assets_env.register(
from webassets import Environment as AssetsEnvironment from webassets.ext.jinja2 import AssetsExtension from semstr.convert import TO_FORMAT from tupa.parse import Parser matplotlib.use("Agg") import matplotlib.pyplot as plt from matplotlib.backends.backend_agg import FigureCanvasAgg SCRIPT_DIR = os.path.dirname(__file__) app = Flask(__name__) assets = flask_assets.Environment() assets.init_app(app) assets_env = AssetsEnvironment("./static/", "/static") jinja_environment = jinja2.Environment( autoescape=True, loader=jinja2.FileSystemLoader(os.path.join(SCRIPT_DIR, "templates")), extensions=[AssetsExtension]) jinja_environment.assets_environment = assets_env Compress(app) app.parser = None PARSER_MODEL = os.getenv("PARSER_MODEL", os.path.join(SCRIPT_DIR, "..", "models/bilstm")) def get_parser(): if app.parser is None: print("Initializing parser...")
from webassets import Environment as AssetsEnvironment from webassets.ext.jinja2 import AssetsExtension import requests import urllib.parse import os from pprint import pprint from jsx_assets import ReactFilter from reverse_proxied import ReverseProxied app = Flask(__name__) app.wsgi_app = ReverseProxied(app.wsgi_app) assets = Environment() assets.init_app(app) register_filter(ReactFilter) assets_env = AssetsEnvironment('./static/js', '/media') jinja2_env = Jinja2Environment(extensions=[AssetsExtension]) jinja2_env.assets_environment = assets_env client_id = os.environ['CLIENT_ID'] client_secret = os.environ['CLIENT_SECRET'] config = { 'client_id': client_id, 'client_secret': client_secret, 'api_base_uri': 'https://api.sipgate.com', 'check_ssl': False, 'access_token': None, 'listen_host': '0.0.0.0' }
from webassets import Environment as AssetsEnvironment from webassets.bundle import Bundle from jinja2_webpack import Environment as WebpackEnvironment from jinja2_webpack.filter import WebpackFilter import logging from whathappened.config import Config from whathappened.email import mail from .database import init_db, session login_manager = LoginManager() login_manager.login_view = 'auth.login' # type: ignore # Not an error assets_env = AssetsEnvironment(directory=Path(__file__).absolute().parent / 'static') csrf = CSRFProtect() logger = logging.getLogger(__name__) def create_app(test_config=None) -> Flask: logger.info("Creating app") assets_env._named_bundles = {} app = Flask(__name__, instance_relative_config=True) # Default settings from config file app.config.from_object(Config) if test_config is not None: app.config.from_object(test_config)
app.config['OAUTH_CREDENTIALS'] = { 'facebook': { 'id': os.environ.get('FACEBOOK_KEY'), 'secret': os.environ.get('FACEBOOK_SECRET') }, 'google': { 'id': os.environ.get('GOOGLE_LOGIN_CLIENT_ID'), 'secret': os.environ.get('GOOGLE_LOGIN_CLIENT_SECRET') } } app.config['RESTPLUS_MASK_SWAGGER'] = False db = SQLAlchemy(app) assets = Environment() assets.init_app(app) assets_env = AssetsEnvironment(os.path.join(config._PROJECT_ROOT, 'static'), '/static') CORS(app, resources={ r"/location-subscription": { "origins": "*" }, r"/report-problem": { "origins": "*" } }) # sg = SendGridAPIClient(app.config['SENDGRID_API_KEY']) babel = Babel(app)
from bnstats import config from starlette.templating import Jinja2Templates from webassets import Bundle from webassets import Environment as AssetsEnvironment from webassets.ext.jinja2 import AssetsExtension assets_env = AssetsEnvironment("./bnstats/static", "/static") templates = Jinja2Templates(directory="bnstats/templates") templates.env.add_extension(AssetsExtension) templates.env.assets_environment = assets_env # type: ignore templates.env.globals["config"] = config js_bundle = Bundle( Bundle( "js/vendor/jquery.js", "js/vendor/jquery.timeago.js", "js/vendor/semantic.js", "js/vendor/tablesort.js", "js/vendor/chart.js", ), Bundle( "js/global.js", "js/filter.js", "js/profile.js", "js/table.js", "js/leaderboard.js", ), filters="rjsmin", output="bundle.%(version)s.js", ) css_bundle = Bundle("css/*.css", filters="rcssmin", output="bundle.%(version)s.css")