def render(results, case): env = Environment(loader=PackageLoader("poirot", "templates")) filters = { "okay": okay, "fail": fail, "style": style, "wrap": wrap, "strip": strip, "highlight": highlight } env.filters = merge_dicts(env.filters, filters) if not case["verbose"]: template = env.get_template("console_thin.html") data_to_render = template.render(data=results, info=case) print(data_to_render) else: template = env.get_template("console.html") data_to_render = template.render(data=results, info=case) try: cmd = ["less", "-F", "-R", "-S", "-X", "-K"] pager = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=sys.stdout) lines = data_to_render.split("\n") for line in lines: pager.stdin.write(line.encode("utf-8") + b"\n") pager.stdin.close() pager.wait() except KeyboardInterrupt: pass except BrokenPipeError: pass
def environment(**options): env = Environment(**options, extensions=[ 'django_tex.extensions.GraphicspathExtension' ]) env.filters = FILTERS return env
def application(self): application = tornado.web.Application( handlers=self.handlers, **self.config ) auto_escape = self.config.get('autoescape', False) env = Environment( autoescape=auto_escape, loader=FileSystemLoader(self.template_paths) ) sentry_dsn = self.config.get('sentry_dsn', None) if sentry_dsn: try: from raven.contrib.tornado import AsyncSentryClient assert AsyncSentryClient except ImportError: import logging logging.warning("Sentry support requires raven." "Run: pip install raven") application.sentry_client = None else: application.sentry_client = AsyncSentryClient(sentry_dsn) env.filters = self.filters application.env = env application._user_loader = self._user_loader return application
def build_j2(src: str, filters: Dict[str, Callable] = {}) -> Environment: j2 = Environment(enable_async=True, trim_blocks=True, lstrip_blocks=True, undefined=StrictUndefined, loader=FileSystemLoader(src)) j2.filters = {**j2.filters, **filters} return j2
def environment(**options): options.update({ "autoescape": None, "extensions": ["django_tex.extensions.GraphicspathExtension"], }) env = Environment(**options) env.filters = FILTERS return env
async def init_jinja2(app, **kw): option = dict(auto_reload=kw.get('auto_reload', True)) path = os.path.join(os.path.abspath('.'), 'templates') env = Environment(loader=FileSystemLoader(path), **option) filters = kw.get('filters') if filters is not None: env.filters = filters app['__template__'] = env
def environment(**options): options.update( { 'autoescape': None, 'extensions': ['django_tex.extensions.GraphicspathExtension'] } ) env = Environment(**options) env.filters = FILTERS return env
def DoTask(self): buildSetup = self.buildSetup menuTabs = (HomePage, DocsPage, WikiPage, ForumPage, DownloadPage) env = Environment(loader=FileSystemLoader(abspath(join(buildSetup.dataDir, "templates"))), trim_blocks=True) env.globals = {"files": GetSetupFiles(join(buildSetup.websiteDir, "downloads")), "MENU_TABS": menuTabs} env.filters = {"rst2html": rst2html} for page in menuTabs: path = os.path.abspath(join(buildSetup.websiteDir, page.outfile)) try: os.makedirs(os.path.dirname(path)) except os.error, exc: if exc.errno != errno.EEXIST: raise env.get_template(page.template).stream(CURRENT=page).dump(path)
def generate_project(program, out_directory): import os module_path = os.path.join(out_directory, f'{program.name}.js') env = Environment( loader=PackageLoader('wick.generators.javascript', 'templates') ) env.filters = {**env.filters, **filters.filters} with open(module_path, 'w') as file: template = env.get_template('main.jinja2') file.write(template.render(program=program))
def render_template(template_file, template_paths, data, filters={}, **kwargs): # Create Jinja environment environment = Environment() environment.loader = FileSystemLoader(template_paths) if filters: environment.filters = dict(environment.filters.items() + filters.items()) # Render template, passing data in as Config dictionary try: template = environment.get_template(template_file) rendered = template.render({'Config': data}) return yaml.load(rendered) except TemplateNotFound as e: raise AnsibleError("Could not locate template %s in the supplied template paths %s" % (template_file,template_paths)) except Exception as e: raise AnsibleError("An error occurred: %s" % e)
def render_template(template_file, template_paths, data, filters={}, **kwargs): # Create Jinja environment environment = Environment() environment.loader = FileSystemLoader(template_paths) if filters: environment.filters = dict(environment.filters.items() + filters.items()) # Render template, passing data in as Config dictionary try: template = environment.get_template(template_file) rendered = template.render({'Config': data}) return yaml.load(rendered) except TemplateNotFound as e: raise AnsibleError( "Could not locate template %s in the supplied template paths %s" % (template_file, template_paths)) except Exception as e: raise AnsibleError("An error occurred: %s" % e)
def parse( self, render_context: Dict[str, Any], loader_paths: List[str], ) -> str: loader_paths = [os.getcwd(), *loader_paths, path_tail(self.source_path)] env = Environment( loader=FileSystemLoader(loader_paths), trim_blocks=True, lstrip_blocks=True, autoescape=True, keep_trailing_newline=True, undefined=StrictUndefined, ) env.filters = merge_dicts(env.filters, self.custom_filters) return env.get_template(path_head(self.source_path)).render(**render_context)
def DoTask(self): buildSetup = self.buildSetup menuTabs = (HomePage, DocsPage, WikiPage, ForumPage, DownloadPage) env = Environment(loader=FileSystemLoader( abspath(join(buildSetup.dataDir, 'templates'))), trim_blocks=True) env.globals = { "files": GetSetupFiles(join(buildSetup.websiteDir, "downloads")), "MENU_TABS": menuTabs, } env.filters = {'rst2html': rst2html} for page in menuTabs: path = os.path.abspath(join(buildSetup.websiteDir, page.outfile)) try: os.makedirs(os.path.dirname(path)) except os.error, exc: if exc.errno != errno.EEXIST: raise env.get_template(page.template).stream(CURRENT=page).dump(path)
def generate_project(program, out_directory): env = Environment() if filters: import importlib module = os.path.basename(filters).split('.')[0] spec = importlib.util.spec_from_file_location(module, filters) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) module_filters = module.filters if hasattr(module, 'filters') else {} env.filters = {**env.filters, **module_filters} file_path = os.path.join(out_directory, program.name) template = env.from_string(template_string) with open(file_path, 'w') as file: file.write(template.render(program=program))
def setUp(self): self.patchers = {p: patch(p) for p in { 'os.path.isfile'}} self.addCleanup(lambda: [p.stop() for p in self.patchers.values()]) for p in self.patchers.values(): p.start() os.path.isfile.side_effect = lambda t: os.path.basename(t) in TEMPLATES self.module = Flow('mymodule', { 'to': 'outdir', 'extension': '.html', 'context': {'modulevar': 'modulevar'}, }) testfile = 'test.markdown' self.init = Initializing( builddir='.build/', sourceroot=self.module.name, sourcepath=os.path.join(self.module.name, testfile), destroot=self.module.destroot, extension=self.module.extension) env = Environment(loader=DictLoader(TEMPLATES)) env.filters = FILTERS env.globals = GLOBALS self.view = Compiling( env=env, modules=MODULES, templatedir='templates', builddir='.build/', sourceroot=self.module.name, sourcepath=os.path.join(self.module.name, testfile), destroot=self.module.destroot, extension=self.module.extension, processes=MagicMock(), dependencies=MagicMock(autospec=Graph), refresher=MagicMock(autospec=Refresher)) self.module.render = MagicMock(side_effect=self.module.render)
formatter = HtmlFormatter() return highlight(text, lexer, formatter) def xmldatetime(value): date = datetime.datetime.fromtimestamp(value) return date.strftime('%Y-%m-%d %H:%M') def lastupdatetime(nodes): try: ret = xmldatetime(nodes[0].timestamp) except IndexError: ret = xmldatetime(0) return ret def markdown(data): renderer = BleepRenderer() md = m.Markdown(renderer, extensions=m.EXT_FENCED_CODE | m.EXT_NO_INTRA_EMPHASIS) return md.render(data) def length(data): return len(data) configs = getconfig() app = configs.get('app') theme = configs.get('theme') env = Environment(loader=FileSystemLoader(os.path.join(app,'themes',theme,'templates'))) dfilter = {'xmldatetime':xmldatetime,'markdown':markdown,'length':length,'lastupdatetime':lastupdatetime} env.filters = dfilter env.globals = configs
def generate_page(self, page_path, page_info={}, pagination=1): """ Generate specified page. """ if pagination == 1: self.logger.info("Generate page: '%s'" % page_path) else: self.logger.info("Generate page: '%s' -- Page %s" % (page_path, pagination)) # get page info if not page_info: page_info = self.load_page(page_path) if not page_info: self.logger.error("Page '%s' was not found." % page_path) return False # find page template page_template = page_info[ '_template'] if '_template' in page_info else ( self.site_conf['default_template'] if 'default_template' in self.site_conf else "default.html.jinja") # get page extension ext = os.path.basename(page_template).split(".") if len(ext) > 2: ext = ext[len(ext) - 2] else: ext = "html" # vars used by extensions self.current_page_info = page_info self.current_page_path = page_path self.current_page_template = page_template self.current_page_extension = ext # make sure page_template exists if not os.path.exists("%s/jinja/%s" % (self.site_template_path, page_template)): self.logger.error("Template '%s' for page '%s' does not exist." % (page_template, page_path)) # get page relative asset dir asset_relative_output_dir = "asset" for subpath in os.path.split(os.path.dirname(page_path)): if subpath: asset_relative_output_dir = "../%s" % asset_relative_output_dir self.asset_relative_output_dir = asset_relative_output_dir # load template environment jinja2 = Environment(loader=FileSystemLoader("%s/jinja" % self.site_template_path), extensions=['jinja2.ext.do']) # load custom filters for extension in self.extensions: # append filters if hasattr(self.extensions[extension], "get_jinja_filters"): jinja2.filters = dict( jinja2.filters.items() + self.extensions[extension].get_jinja_filters().items()) # load template tmpl = jinja2.get_template(page_template) template = tmpl.render(site=self.site_conf, current_page=page_path, asset_path=asset_relative_output_dir, f=self.jinja_functions, pagination=int(pagination)) # output page # create subdirs if not os.path.exists( "output/%s" % os.path.join(self.site, os.path.dirname(page_path))): os.makedirs("output/%s" % os.path.join(self.site, os.path.dirname(page_path))) # append generator notes to page output template_notes = "" if (ext == "html" or ext == "htm"): template_notes += "<!-- Generated by WebChomp. -->\n" template_notes += "<!-- WebChomp <http://chompy.me/projects/webchomp.html> is released under the GPL software license. -->\n" # output page page_fo = open( "%s%s.%s" % (os.path.splitext( "output/%s" % os.path.join(self.site, page_path))[0], "-page%s" % str(pagination) if pagination > 1 else "", ext), "w") page_fo.write(template_notes + template) page_fo.close() return True
def output_model(package: UMLPackage) -> None: """ Loops through model templates in the settings and calls render functions Each template consists of: dest: The filename of the output level: Do we generate a file for each package/class/enumeration/association or root source: Path to the jinja2 template filter: If supplied, If supplied The template must output "True" for a file to be generated E.g.: "{% if package.classes %}True{% else %}False{% endif %}" """ print("Generating model output for package {}".format(package.path)) # Create jinja2 filter dict to pass into templates filters = { 'camelcase': camelcase, 'snakecase': snakecase, 'titlecase': titlecase, 'sentencecase': sentencecase, } # Create jinja2 environmeent with filters source_env = Environment( loader=FileSystemLoader(settings['templates_folder'])) source_env.filters = {**source_env.filters, **filters} # Loop through all template definitions in the config file template_definition: Dict for template_definition in settings['model_templates']: dest_file_template: Template = Template( os.path.join(settings['dest_root'], template_definition['dest'])) dest_file_template.environment.filters = { **dest_file_template.environment.filters, **filters } if template_definition['level'] == 'copy': if package.parent is None: output_level_copy( os.path.join(settings['templates_folder'], template_definition['source']), dest_file_template, package) else: # Create jinja2 teemplates for the source file and dest file name source_template: Template = source_env.get_template( template_definition['source']) # Filter template is optional and used to skip a file generation. filter_template: Optional[Template] = None if 'filter' in template_definition.keys(): filter_template = Template(template_definition['filter']) # Select the output renderer based on the level requested if template_definition['level'] == 'package': if filter_template is None or filter_template.render( package=package) == "True": output_level_package(source_template, dest_file_template, package) elif template_definition['level'] == 'class': output_level_class(source_template, dest_file_template, filter_template, package) elif template_definition['level'] == 'enumeration': output_level_enum(source_template, dest_file_template, filter_template, package) elif template_definition['level'] == 'assocication': output_level_assoc(source_template, dest_file_template, filter_template, package) elif template_definition[ 'level'] == 'root' and package.parent is None: output_level_package(source_template, dest_file_template, package) # Walk through the package hierarchy and recurse output child: UMLPackage for child in package.children: output_model(child)
def environment(**options): env = Environment(**options) env.filters = filters return env
def output_model(package: UMLPackage) -> None: """ Loops through model templates in the settings and calls render functions Each template consists of: dest: The filename of the output level: Do we generate a file for each package/class/enumeration/association or root source: Path to the jinja2 template filter: If supplied, If supplied The template must output "True" for a file to be generated. E.g. "{% if package.classes %}True{% else %}False{% endif %}" """ logger.info("Generating model output for package {}".format(package.path)) # Create jinja2 filter dict to pass into templates filters = get_filters() # Create jinja2 environmeent with filters import os default_templates = os.path.join( os.path.dirname(os.path.abspath(__file__)), 'templates') source_env = Environment(loader=FileSystemLoader( [settings['templates_folder'], default_templates])) source_env.filters = {**source_env.filters, **filters} dest_env = Environment(loader=BaseLoader()) dest_env.filters = {**source_env.filters, **filters} # Loop through all template definitions in the config file template_definition: Dict for template_definition in settings['model_templates']: dest_file_template: Template = dest_env.from_string( os.path.join(settings['dest_root'], template_definition['dest'])) if template_definition['level'] == 'copy': if package.parent is None: source_file = os.path.join(settings['templates_folder'], template_definition['source']) if not os.path.isfile(source_file): source_file = os.path.join(default_templates, template_definition['source']) output_level_copy(source_file, dest_file_template, package) else: # Create jinja2 teemplates for the source file and dest file name source_template: Template = source_env.get_template( template_definition['source']) # Filter template is optional and used to skip a file generation. filter_template: Optional[Template] = None if 'filter' in template_definition.keys(): filter_template = Template(template_definition['filter']) # Select the output renderer based on the level requested if template_definition['level'] == 'package': if filter_template is None or filter_template.render( package=package) == "True": output_level_package(source_template, dest_file_template, package) elif template_definition['level'] == 'class': output_level_class(source_template, dest_file_template, filter_template, package) elif template_definition['level'] == 'enumeration': output_level_enum(source_template, dest_file_template, filter_template, package) elif template_definition['level'] == 'assocication': output_level_assoc(source_template, dest_file_template, filter_template, package) elif template_definition['level'] == 'root': if package.parent is None: output_level_package(source_template, dest_file_template, package) else: raise ValueError("'{}' is not a valid template level".format( template_definition['level'])) # Walk through the package hierarchy and recurse output child: UMLPackage for child in package.children: output_model(child)
def create(cls, config, app_globals): """Setup a renderer and loader for Jinja2 templates.""" if jinja2 is None: # pragma: no cover return None if config.get('use_dotted_templatenames', True): TemplateLoader = DottedTemplateLoader template_loader_args = {'dotted_finder': app_globals.dotted_filename_finder} else: TemplateLoader = FileSystemLoader template_loader_args = {} if not 'jinja_extensions' in config: config['jinja_extensions'] = [] # Add i18n extension by default if not "jinja2.ext.i18n" in config['jinja_extensions']: config['jinja_extensions'].append("jinja2.ext.i18n") if not 'jinja_filters' in config: config['jinja_filters'] = {} loader = ChoiceLoader( [TemplateLoader(path, **template_loader_args) for path in config['paths']['templates']]) jinja2_env = Environment(loader=loader, autoescape=True, auto_reload=config['auto_reload_templates'], extensions=config['jinja_extensions']) # Try to load custom filters module under app_package.lib.templatetools try: if not config['package_name']: raise AttributeError() filter_package = config['package_name'] + ".lib.templatetools" autoload_lib = __import__(filter_package, {}, {}, ['jinja_filters']) try: autoload_filters = dict( map(lambda x: (x, autoload_lib.jinja_filters.__dict__[x]), autoload_lib.jinja_filters.__all__) ) except AttributeError: #pragma: no cover autoload_filters = dict( filter(lambda x: callable(x[1]), autoload_lib.jinja_filters.__dict__.iteritems()) ) except (ImportError, AttributeError): autoload_filters = {} # Add jinja filters filters = dict(FILTERS, **autoload_filters) filters.update(config['jinja_filters']) jinja2_env.filters = filters # Jinja's unable to request c's attributes without strict_c config['tg.strict_tmpl_context'] = True # Add gettext functions to the jinja environment jinja2_env.install_gettext_callables(ugettext, ungettext) return {'jinja': cls(jinja2_env)}
def get_template_environment(paths, filters): env = Environment(loader=FileSystemLoader(paths)) filters.update(env.filters) env.filters = filters return env