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