def __init__(self, router: Router, statics: StaticFiles, settings: Settings) -> None: template_settings = settings.get('TEMPLATES', self.DEFAULT_SETTINGS) loaders = [] # type: typing.List[jinja2.BaseLoader] if template_settings.get('PACKAGE_DIRS'): loaders.extend([ jinja2.PrefixLoader({ package_dir: jinja2.PackageLoader(package_dir, 'templates') }) for package_dir in template_settings['PACKAGE_DIRS'] ]) if template_settings.get('ROOT_DIR'): loaders.append( jinja2.FileSystemLoader(template_settings['ROOT_DIR'])) loader = jinja2.ChoiceLoader(loaders) env = jinja2.Environment(loader=loader) env.globals['reverse_url'] = router.reverse_url env.globals['static_url'] = statics.get_url self._env = env
def render_template(loader, template_name, glob_helper=lambda f: [], clock=time.Clock): macros = """ {% macro collect(parts) -%} {% set comma = joiner() %} {% for part in glob(parts) %} {{ comma() }} {% include part %} {% endfor %} {%- endmacro %} """ # place helpers dict loader first to prevent users from overriding our macros. env = jinja2.Environment( loader=jinja2.ChoiceLoader([jinja2.DictLoader({"rally.helpers": macros}), loader]) ) env.globals["now"] = clock.now() env.globals["glob"] = glob_helper env.filters["days_ago"] = time.days_ago template = env.get_template(template_name) return template.render()
def test_optional_nullable(): from openapi_python_client.parser.properties import DateProperty prop = DateProperty( name="a_prop", required=False, nullable=True, default=None, ) here = Path(__file__).parent templates_dir = here.parent.parent.parent.parent / "openapi_python_client" / "templates" env = jinja2.Environment(loader=jinja2.ChoiceLoader([ jinja2.FileSystemLoader(here), jinja2.FileSystemLoader(templates_dir) ])) template = env.get_template("date_property_template.py") content = template.render(property=prop) expected = here / "optional_nullable.py" assert content == expected.read_text()
def __init__(self, csr_data_dir=None): # chain loaders: # 1) csr_data_dir/templates # 2) /etc/ipa/csrgen/templates # 3) ipaclient/csrgen/templates loaders = [] if csr_data_dir is not None: loaders.append(jinja2.FileSystemLoader( os.path.join(csr_data_dir, 'templates')) ) loaders.append(jinja2.FileSystemLoader( os.path.join(api.env.confdir, 'csrgen/templates')) ) loaders.append(jinja2.PackageLoader('ipaclient', 'csrgen/templates')) self.jinja2 = jinja2.sandbox.SandboxedEnvironment( loader=jinja2.ChoiceLoader(loaders), extensions=[jinja2.ext.ExprStmtExtension, IPAExtension], keep_trailing_newline=True, undefined=IndexableUndefined) self.passthrough_globals = {}
def create_app(config=None, environment=None): logger.info(f"config : {config}") logger.info(f"environment: {environment}") app = BlogsleyFlask.create(config, environment) #Configure Jinja2 my_loader = jinja2.ChoiceLoader([ app.jinja_loader, jinja2.FileSystemLoader(['blogsley_flask/templates']), ]) app.jinja_loader = my_loader #Configure Login from blogsley_flask.user import User @__blogsley__.login.user_loader def load_user(id): return User.query.get(int(id)) return app
def test_jinja_templates(network, args, verify=True): primary, _ = network.find_primary() new_user_local_id = "bob" new_user = network.create_user(new_user_local_id, args.participants_curve) with primary.client(new_user_local_id) as c: r = c.post("/app/log/private", {"id": 42, "msg": "New user test"}) assert r.status_code == http.HTTPStatus.UNAUTHORIZED.value template_loader = jinja2.ChoiceLoader( [ jinja2.FileSystemLoader(args.jinja_templates_path), jinja2.FileSystemLoader(os.path.dirname(new_user.cert_path)), ] ) template_env = jinja2.Environment( loader=template_loader, undefined=jinja2.StrictUndefined ) proposal_template = template_env.get_template("set_user_proposal.json.jinja") proposal_body = proposal_template.render(cert=os.path.basename(new_user.cert_path)) proposal = network.consortium.get_any_active_member().propose( primary, proposal_body ) ballot_template = template_env.get_template("ballot.json.jinja") ballot_body = ballot_template.render(**json.loads(proposal_body)) network.consortium.vote_using_majority(primary, proposal, ballot_body) with primary.client(new_user_local_id) as c: r = c.post("/app/log/private", {"id": 42, "msg": "New user test"}) assert r.status_code == http.HTTPStatus.OK.value network.consortium.remove_user(primary, new_user.service_id) with primary.client(new_user_local_id) as c: r = c.get("/app/log/private") assert r.status_code == http.HTTPStatus.UNAUTHORIZED.value return network
def init_app(self, app, socketio=None, **kwargs): app.jinja_env.add_extension(MeldTag) app.jinja_env.add_extension(MeldScriptsTag) # Load templates from template dir or app/meld/templates custom_template_loader = jinja2.ChoiceLoader([ app.jinja_loader, jinja2.FileSystemLoader(os.path.join(app.root_path, 'meld/templates')), ]) app.jinja_loader = custom_template_loader if socketio: app.socketio = socketio else: app.socketio = SocketIO(app, **kwargs) meld_dir = app.config.get("MELD_COMPONENT_DIR", None) if meld_dir: if not os.path.isabs(meld_dir): directory = os.path.abspath(os.path.join(app.root_path, meld_dir)) app.config["MELD_COMPONENT_DIR"] = directory if not app.config.get("SECRET_KEY"): raise RuntimeError( "The Flask-Meld requires the 'SECRET_KEY' config " "variable to be set" ) @app.route("/meld_js_src/<path:filename>") def meld_static_file(filename): return self.send_static_file(filename) @app.socketio.on("meld-message") def meld_message(message): """meldID, action, componentName""" result = process_message(message) app.socketio.emit("meld-response", result) @app.socketio.on("meld-init") def meld_init(message): return process_init(message)
def init_webapp(app, db): print 'Initializing MLN webapp...' mlnApp.app = app # use html templates from mln app mln_loader = jinja2.ChoiceLoader([ mlnApp.app.jinja_loader, jinja2.FileSystemLoader( ['/opt/practools/tools/pracmln/webmln/gui/templates']), ]) mlnApp.app.jinja_loader = mln_loader mlnApp.app.config[ 'MLN_STATIC_PATH'] = '/opt/practools/tools/pracmln/webmln/gui/build' # settings for fileuploads and logging mlnApp.app.config['ALLOWED_EXTENSIONS'] = {'mln', 'db', 'pracmln', 'emln'} mlnApp.app.config['UPLOAD_FOLDER'] = '/home/ros/pracfiles' mlnApp.app.config['MLN_ROOT_PATH'] = '/opt/practools/tools/pracmln' mlnApp.app.config['EXAMPLES_FOLDER'] = os.path.join( mlnApp.app.config['MLN_ROOT_PATH'], 'examples') mlnApp.app.config['LOG_FOLDER'] = os.path.join('/home/ros/pracfiles/mln', 'log') if not os.path.exists(mlnApp.app.config['LOG_FOLDER']): os.mkdir(mlnApp.app.config['LOG_FOLDER']) ulog = logging.getLogger('userstats') ulog.setLevel(logging.INFO) formatter = logging.Formatter("%(message)s,") filelogger = FileHandler( os.path.join(mlnApp.app.config['LOG_FOLDER'], "userstats.json")) filelogger.setFormatter(formatter) ulog.addHandler(filelogger) print 'Registering MLN routes...' from webmln.gui.pages import learning from webmln.gui.pages import inference from webmln.gui.pages import views from webmln.gui.pages import fileupload from webmln.gui.pages import utils
def __init__(self): self.async_mode = 'eventlet' # None self.app = Flask(__name__) self.app.config['SECRET_KEY'] = 'secret!' thread = None self.socketio = SocketIO(self.app, async_mode=self.async_mode, logger=True, engineio_logger=True) template_loader = jinja2.ChoiceLoader([self.app.jinja_loader, jinja2.PackageLoader('mTree', 'development/development_templates'), ]) self.app.jinja_loader = template_loader #self.app.config['BASIC_AUTH_USERNAME'] = '******' #self.app.config['BASIC_AUTH_PASSWORD'] = '******' self.basic_auth = BasicAuth(self.app) self.mTree_configuration = MTreeConfiguration() self.subject_directory = SubjectDirectory() self.add_routes() # self.scheduler = APScheduler() # self.scheduler.init_app(self.app) # self.scheduler.start() #self.scheduler.add_listener(self.my_listener, events.EVENT_ALL) self.app.register_blueprint(development_area, url_prefix='/') self.app.register_blueprint(subject_area, url_prefix='/subjects') self.subject_container = None #SubjectContainer() #self.actor_system = ActorSystemConnector() # attempts at logger adding... self.logger = logging.getLogger() self.logger.setLevel(logging.INFO) handler = RequestsHandler(emit) handler.setLevel(logging.INFO) myfilter = MyFilter() handler.addFilter(myfilter)
async def setup(app): procs = [request_processor] # setup Jinja2 template renderer app_loaders = [ jinja2.FileSystemLoader(os.path.join(settings.BASE_DIR, "app/views_min/")), jinja2.FileSystemLoader(os.path.join(settings.BASE_DIR, "app/views/")), jinja2.PackageLoader("aioweb", "views/") ] for app_name in settings.APPS: try: app_loaders.append(jinja2.PackageLoader(app_name, "app/views")) except ImportError as e: pass env = jinja2.Environment( loader=jinja2.ChoiceLoader(app_loaders), enable_async=True, trim_blocks=True, lstrip_blocks=True, extensions=[ DjangoStatic, DjangoUrl, DjangoNow, DjangoTrans ]) env.globals['settings'] = settings env.globals['app'] = app app[APP_KEY] = env app[APP_CONTEXT_PROCESSORS_KEY] = procs app.middlewares.append(context_processors_middleware) try: mod = importlib.import_module("app") setup = getattr(mod, 'setup_template') await awaitable(setup(env)) except (ImportError, AttributeError) as e: pass
def jinja_choice_loader(loader): return jinja2.ChoiceLoader([loader, jinja2.DictLoader({ 'snippets/per_lab/lab_env/lab.test-kickstart.invalid': ''' cat << EOF > /etc/profile.d/rh-env.sh export LAB_CONTROLLER=lab.test-kickstart.invalid export DUMPSERVER=netdump.test-kickstart.invalid export NFSSERVERS="RHEL3,rhel3-nfs.test-kickstart.invalid:/export/home RHEL4,rhel4-nfs.test-kickstart.invalid:/export/home RHEL5,rhel5-nfs.test-kickstart.invalid:/export/home RHEL6,rhel6-nfs.test-kickstart.invalid:/export/home NETAPP, SOLARIS," export LOOKASIDE=http://download.test-kickstart.invalid/lookaside/ export BUILDURL=http://download.test-kickstart.invalid EOF cat << EOF > /etc/profile.d/rh-env.csh setenv LAB_CONTROLLER lab.test-kickstart.invalid setenv DUMPSERVER netdump.test-kickstart.invalid setenv NFSSERVERS "RHEL3,rhel3-nfs.test-kickstart.invalid:/export/home RHEL4,rhel4-nfs.test-kickstart.invalid:/export/home RHEL5,rhel5-nfs.test-kickstart.invalid:/export/home RHEL6,rhel6-nfs.test-kickstart.invalid:/export/home NETAPP, SOLARIS," setenv LOOKASIDE http://download.test-kickstart.invalid/lookaside/ setenv BUILDURL http://download.test-kickstart.invalid EOF ''', 'snippets/per_system/packages/bz728410-system-with-packages': 'special-weird-driver-package\n', })])
def _setup_jinja(self): self.add_template_filter(datetime_short) self.add_template_filter(datetime_long) self.add_template_filter(date_header) self.add_template_filter(plain_text) self.add_template_filter(time_short) self.add_template_filter(date_short) self.add_template_filter(word_count) self.add_template_filter(char_count) self.add_template_global(get_company_sidenavs, 'sidenavs') self.add_template_global(sidenavs_by_names) self.add_template_global(sidenavs_by_group) self.add_template_global(newsroom_config) self.add_template_global(is_admin) self.add_template_global(get_initial_notifications) self.add_template_global(hash_string, 'hash') self.add_template_global(get_date, 'get_date') self.add_template_global(self.settings_apps, 'settings_apps') self.jinja_loader = jinja2.ChoiceLoader([ jinja2.FileSystemLoader('theme'), jinja2.FileSystemLoader(self.template_folder), ])
def init_app(self, app): """Initializes the App. Args: app (TYPE): Description Returns: TYPE: Description """ config = app.config.copy() self.debug = config.get('PONYWHOOSH_DEBUG', self.debug) self.indexes_path = config.get('PONYWHOOSH_INDEXES_PATH', self.indexes_path) self.search_string_min_len = config.get('PONYWHOOSH_MIN_STRING_LEN', self.search_string_min_len) self.template_path = config.get('PONYWHOOSH_TEMPLATE_PATH', self.template_path) self.url_route = config.get('PONYWHOOSH_URL_ROUTE', self.url_route) self.writer_timeout = config.get('PONYWHOOSH_WRITER_TIMEOUT', self.writer_timeout) if self.debug: print('PONYWHOOSH_DEBUG: ', self.debug) print('PONYWHOOSH_INDEXES_PATH : ', self.indexes_path) print('PONYWHOOSH_MIN_STRING_LEN : ', self.search_string_min_len) print('PONYWHOOSH_TEMPLATE_PATH: ', self.template_path) print('PONYWHOOSH_URL_ROUTE: ', self.url_route) print('PONYWHOOSH_WRITER_TIMEOUT: ', self.writer_timeout) loader = jinja2.ChoiceLoader([ app.jinja_loader , jinja2.FileSystemLoader(self.template_path) ]) app.jinja_loader = loader app.add_url_rule( self.url_route , view_func=IndexView.as_view(self.url_route , pw=self , action_url_form=self.url_route ) )
def _build_loader(self, extra_paths=None): # Paths for resolving template file locations non_prefix_template_paths = [ os.path.normpath( os.path.join(os.path.dirname(monkey.__file__), '../templates')), os.path.normpath( os.path.join(os.path.dirname(monkey.__file__), './templates')) ] prefix_paths = { 'app': os.path.join(os.path.dirname(monkey.__file__), '../templates'), 'framework': os.path.join(os.path.dirname(monkey.__file__), './templates') } # Extra (plugin) paths if extra_paths: for x in extra_paths: if not x[1]: # non prefixed non_prefix_template_paths += x[0] prefix_paths.update({x[1]: x[0] for x in extra_paths if x[1]}) # Theme Paths if self.theme: non_prefix_template_paths = [ os.path.normpath(os.path.join(x, './themes/%s/' % self.theme)) for x in non_prefix_template_paths ] + non_prefix_template_paths loader = jinja2.ChoiceLoader([ jinja2.FileSystemLoader(non_prefix_template_paths), jinja2.PrefixLoader({ k: jinja2.FileSystemLoader(v) for k, v in prefix_paths.iteritems() }) ]) return loader
def __init__(self, app=None): """RERO ILS App module.""" if app: self.init_app(app) # force to load ils template before others # it is require for Flask-Security see: # https://pythonhosted.org/Flask-Security/customizing.html#emails ils_loader = jinja2.ChoiceLoader([ jinja2.PackageLoader('rero_ils', 'templates'), app.jinja_loader ]) app.jinja_loader = ils_loader # register filters app.add_template_filter(format_date_filter, name='format_date') app.add_template_global(node_assets, name='node_assets') app.add_template_filter(to_pretty_json, name='tojson_pretty') app.add_template_filter(text_to_id, name='text_to_id') app.add_template_filter(jsondumps, name='jsondumps') app.add_template_filter(empty_data, name='empty_data') app.jinja_env.add_extension('jinja2.ext.do') self.register_signals(app)
def __init__(self): self._libraries = [] loader = jinja2.ChoiceLoader(self._get_loaders()) options = self._get_options() super(Environment, self).__init__( extensions=options['extensions'], loader=loader, trim_blocks=True, autoescape=True, auto_reload=settings.DEBUG, ) # Note: options already includes Jinja2's own builtins (with # the proper priority), so we want to assign to these attributes. self.filters = options['filters'].copy() self.globals = options['globals'].copy() self.tests = options['tests'].copy() for key, value in options['attrs'].items(): setattr(self, key, value) # Set the environment in all libraries found. for library in self._libraries: library.set_env(self) # Hook Jinja's i18n extension up to Django's translation backend # if i18n is enabled; note that we differ here from Django, in that # Django always has it's i18n functionality available (that is, if # enabled in a template via {% load %}), but uses a null backend if # the USE_I18N setting is disabled. Jinja2 provides something similar # (install_null_translations), but instead we are currently not # enabling the extension at all when USE_I18N=False. # While this is basically an incompatibility with Django, currently # the i18n tags work completely differently anyway, so for now, I # don't think it matters. if settings.USE_I18N: from django.utils import translation self.install_gettext_translations(translation)
def __init__(self, import_name=__package__, config=None, **kwargs): if not getattr(self, 'settings'): self.settings = flask.Config('.') super(NewsroomNewsAPI, self).__init__(import_name=import_name, config=config, **kwargs) template_folder = os.path.abspath( os.path.join(API_DIR, '../../templates')) self.add_template_filter(datetime_short) self.add_template_filter(datetime_long) self.add_template_filter(date_header) self.add_template_filter(plain_text) self.add_template_filter(time_short) self.add_template_filter(date_short) self.add_template_filter(word_count) self.add_template_filter(char_count) self.jinja_loader = jinja2.ChoiceLoader([ jinja2.FileSystemLoader(template_folder), ])
def run(): app = web.Application() setup_aiohttp_session(app) aiohttp_jinja2.setup(app, loader=jinja2.ChoiceLoader( [jinja2.PackageLoader('atgu')])) app.add_routes(routes) app.router.add_get("/metrics", server_stats) app.on_startup.append(on_startup) app.on_cleanup.append(on_cleanup) web.run_app( deploy_config.prefix_application(app, 'atgu'), host='0.0.0.0', port=5000, access_log_class=AccessLogger, ssl_context=internal_server_ssl_context(), )
def setup_jinja2(template_dirs, auto_reload): """Setup a jinja2 env (https://www.starlette.io/templates/)""" @jinja2.contextfunction def url_for(context, name, **path_params): request = context['request'] return request.url_for(name, **path_params) # first check for template overrides on the same level above the modual. # check lamia defaults if nothing is found loader = jinja2.ChoiceLoader([ jinja2.FileSystemLoader(template_dirs), jinja2.PackageLoader('lamia') ]) env = jinja2.Environment( loader=loader, autoescape=True, auto_reload=auto_reload, extensions=['jinja2.ext.i18n'], ) env.install_gettext_translations(EN) # pylint: disable=no-member env.globals['url_for'] = url_for return env
def get_jinja2_loader(template_dir=None): """Inspect the template directory and set up appropriate loader. :param target_dir: Limit template loading to this directory. :type target_dir: str :returns: Jinja2 loader :rtype: jinja2.loaders.BaseLoader """ if template_dir: return jinja2.FileSystemLoader(template_dir) else: template_dir = get_overlay_template_dir() provider_template_dir = os.path.join(template_dir, zaza.controller.get_cloud_type()) if (os.path.exists(provider_template_dir) and os.path.isdir(provider_template_dir)): return jinja2.ChoiceLoader([ jinja2.FileSystemLoader(provider_template_dir), jinja2.FileSystemLoader(template_dir), ]) else: return jinja2.FileSystemLoader(template_dir)
def load_devicetype_template(device_type_name): """ Loads the bare device-type template as a python dictionary object for representation within the device_type templates. No device-specific details are parsed - default values only, so some parts of the dictionary may be unexpectedly empty. Not to be used when rendering device configuration for a testjob. :param device_type_name: DeviceType.name (string) :param path: optional alternative path to templates :return: None or a dictionary of the device type template. """ path = os.path.dirname(Device.CONFIG_PATH) type_loader = jinja2.FileSystemLoader([os.path.join(path, 'device-types')]) env = jinja2.Environment(loader=jinja2.ChoiceLoader([type_loader]), trim_blocks=True) try: template = env.get_template("%s.jinja2" % device_type_name) except jinja2.TemplateNotFound: return None if not template: return None return yaml.load(template.render())
def load_project(self, project): self.project = self._load_project_from_dir(project) if not self.project: self.project = AbstractProject() self.project.directory = project def file_load(name): """ The default FileSystemLoader doesn't load files specified by absolute paths or paths that include '..' - therefore we provide a custom fallback function that handles this. """ name = os.path.abspath(name) try: with open(name, 'rb') as f: return f.read().decode('utf-8') except Exception: raise jinja2.TemplateNotFound(name) def string_load(name): """ Allow specifying a string instead of template to be able to return expanded config/specs/... """ if name.startswith(('{{', '{%')): return name raise jinja2.TemplateNotFound(name) loader = jinja2.ChoiceLoader([ jinja2.FileSystemLoader(self.pm_tpl.get_path()), jinja2.FunctionLoader(string_load), jinja2.FunctionLoader(file_load), ]) self.project.tplgen = jinja2.Environment(loader=loader, **self.jinjaenv_args) self.project.abstract_initialize()
def __init__(self, implementation): Flask.__init__(self, __name__, static_url_path='/common_static') self.jinja_loader = jinja2.ChoiceLoader( [self.jinja_loader, jinja2.PrefixLoader({}, delimiter=".")]) sidebar_links = [] def import_dir(path, prefix): for _, package, _ in pkgutil.walk_packages([path]): if package[:4] == 'mod_' or package == implementation: for _, module, _ in pkgutil.iter_modules([path + package]): if module == 'controller': controller = importlib.import_module(prefix + '.' + package + '.' + module) if hasattr(controller, 'mod'): self.register_blueprint(controller.mod) print('Registering:', prefix + '.' + package + '.' + module) path = os.path.dirname(__file__) + '/' import_dir(path, 'web_apps') import_dir(path + implementation + '/', 'web_apps.' + implementation) @self.errorhandler(404) def not_found(error): return render_template('404.html'), 404 @self.teardown_appcontext def close_db(error): if hasattr(g, 'cursor'): g.cursor.close() if hasattr(g, 'database'): g.database.close() if hasattr(g, 'clientsDB'): g.clientsDB.close()
def _init_templates(self): # load user defined templates if self.config['LOCAL_TEMPLATE_DIR']: if os.path.isdir(self.config['LOCAL_TEMPLATE_DIR']): self.jinja_loader = jinja2.ChoiceLoader([ jinja2.FileSystemLoader(self.config['LOCAL_TEMPLATE_DIR']), self.jinja_loader, ]) self.logger.info( 'site-specific templates will be loaded from: ' + str(self.config['LOCAL_TEMPLATE_DIR'])) else: self.logger.error( 'site-specific templates cannot be loaded because LOCAL_TEMPLATE_DIR is not a directory' ) # check for a local static dir, and set up favicon if self.config['LOCAL_STATIC_DIR']: if os.path.isdir(self.config['LOCAL_STATIC_DIR']): self.logger.info( 'site-specific static files will be served from: ' + str(self.config['LOCAL_STATIC_DIR'])) # override the built in / default favicon if one exists if os.path.isfile( os.path.join(self.config['LOCAL_STATIC_DIR'], 'favicon.ico')): self.logger.info('site-specific favicon found') self.config['LOCAL_FAVICON'] = True else: self.config['LOCAL_STATIC_DIR'] = False self.logger.error( 'site-specific static files cannot be served because LOCAL_STATIC_DIR is not a directory' )
def create_app(package_name='bidding'): """Returns a :class:`Flask` application instance configured with common functionality for the korath platform. :param package_name: application package name :param package_path: application package path :param config_name: can have one of [production, development, testing] """ global app, admin app = Flask(package_name, instance_relative_config=True) config_name = os.environ.get('bidding_CONFIG_NAME', 'Production') app.config.from_object('configurations.%s' % config_name.title()) app.jinja_loader = jinja2.ChoiceLoader([ app.jinja_loader, jinja2.FileSystemLoader('bidding/templates/'), ]) db.init_app(app) admin = Admin(app, 'Our own CMS', base_template='layout.html') from . import views from views import api_blueprint app.register_blueprint(api_blueprint) from views import comment_blueprint app.register_blueprint(comment_blueprint) from views import fb_blueprint app.register_blueprint(fb_blueprint) from views import static_blueprint app.register_blueprint(static_blueprint) from . import models # for admin panel from . import admin_panel return app
def load_jupyter_server_extension(nbapp): # Add our custom templates to the beginning of the search path. templates_dir = pathlib.Path(__file__).parent.absolute().joinpath("templates").as_posix() # NbApp settings have already been propogated so we need to modify the webapp settings directly # nbapp.extra_template_paths.append(templates_dir) env = nbapp.web_app.settings["jinja2_env"] if nbapp.__class__.__name__ == 'SingleUserNotebookApp': # Running in jupyterhub. # jupyterhub-singleuser already extends 'templates/page.html'. Since we # want to extend it as well, we have to do something funky here. # We are patching this logic: # https://github.com/jupyterhub/jupyterhub/blob/9391470e269cf2cbc39520f903ab42900aa991ca/jupyterhub/singleuser.py#L483-L492 # So that # our page.html --extends-> singleuser.page_template --extends-> templates/page.html from jupyterhub import singleuser import jinja2 def get_page(name): if name == 'singleuser.page_template': return singleuser.page_template env.loader = jinja2.ChoiceLoader([ jinja2.FileSystemLoader(os.path.join(templates_dir, 'jupyterhub-singleuser')), jinja2.FileSystemLoader(templates_dir), jinja2.FunctionLoader(get_page), env.loader ]) pass else: env.loader.searchpath.insert(0, templates_dir) nbapp.log.info("Imandra theme enabled!")
def create_app(self, config={}): app = Flask('signac-dashboard') app.config.update({ 'SECRET_KEY': os.urandom(24), 'SEND_FILE_MAX_AGE_DEFAULT': 300, # Cache control for static files }) # Load the provided config app.config.update(config) # Enable profiling if app.config.get('PROFILE'): logger.warning("Application profiling is enabled.") from werkzeug.contrib.profiler import ProfilerMiddleware app.wsgi_app = ProfilerMiddleware(app.wsgi_app, restrictions=[10]) # Set up default signac-dashboard static and template paths signac_dashboard_path = os.path.dirname(__file__) app.static_folder = signac_dashboard_path + '/static' app.template_folder = signac_dashboard_path + '/templates' # Set up custom template paths # The paths in DASHBOARD_PATHS give the preferred order of template # loading loader_list = [] for dashpath in list(app.config.get('DASHBOARD_PATHS', [])): logger.warning("Adding '{}' to dashboard paths.".format(dashpath)) loader_list.append( jinja2.FileSystemLoader(dashpath + '/templates')) # The default loader goes last and is overridden by any custom paths loader_list.append(app.jinja_loader) app.jinja_loader = jinja2.ChoiceLoader(loader_list) turbolinks(app) return app
def load_devicetype_template(device_type_name, raw=False): """ Loads the bare device-type template as a python dictionary object for representation within the device_type templates. No device-specific details are parsed - default values only, so some parts of the dictionary may be unexpectedly empty. Not to be used when rendering device configuration for a testjob. :param device_type_name: DeviceType.name (string) :param raw: if True, return the raw yaml :return: None or a dictionary of the device type template. """ path = os.path.dirname(Device.CONFIG_PATH) type_loader = jinja2.FileSystemLoader([os.path.join(path, 'device-types')]) env = jinja2.Environment(loader=jinja2.ChoiceLoader([type_loader]), trim_blocks=True) try: template = env.get_template("%s.jinja2" % device_type_name) data = template.render() if not data: return None return data if raw else yaml.load(data) except (jinja2.TemplateError, yaml.error.YAMLError): return None
def _init_task_setup_jinja(ctx): jinja_env = ctx.jinja_env = _jinja2.Environment( loader=_jinja2.ChoiceLoader([ _jinja2.DictLoader(class_.yaml.get("templates", {})) for class_ in reversed(ctx.classes) ] + [_jinja2.FileSystemLoader(ctx.inp.path)]), keep_trailing_newline=True) for k, v in ctx.extras["jinjaglobals"].items(): jinja_env.globals[k] = v for k, v in ctx.extras["jinjafilter"].items(): jinja_env.filters[k] = v for k, v in ctx.extras["jinjatest"].items(): jinja_env.tests[k] = v @_yaql.language.specs.name("template") def yaql_template(name, **kw): return TemplateResultStr(jinja_env.get_template(name).render(**kw), name=name) ctx.yaql.ctx.register_function(yaql_template)
def register_loaders(self, application=None): user_path_loaders = [ jinja2.FileSystemLoader(path) for path in self.config.get('paths') ] user_package_loaders = [ jinja2.PackageLoader(*package) for package in self.config.get('packages') ] user_loaders = user_package_loaders + user_path_loaders system_loaders = [ jinja2.PackageLoader(*package) for package in self.config.get('framework_packages') ] if self._debug_mode: loaders = system_loaders + user_loaders else: loaders = user_loaders + system_loaders kwargs = self.config.get('environment', {}) loader = jinja2.ChoiceLoader(loaders) kwargs['loader'] = loader self._choice_loader = loader self._env = jinja2.Environment(**kwargs) self._env.application = application