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
