def main(name):
searchpath = [name]
engine = Engine(loader=FileLoader(searchpath),
extensions=[CoreExtension(token_start='#')])
engine = Engine(loader=PreprocessLoader(engine),
extensions=[CoreExtension()])
engine.global_vars.update({'h': escape})
template = engine.get_template('welcome.html')
return template.render
def tohtml(self):
# TODO temporary
path = os.path.join(os.path.dirname(__file__), 'reader.html.template')
loader = DictLoader({'reader': open(path).read()})
engine = Engine(loader=loader, extensions=[CoreExtension()])
template = engine.get_template('reader')
return template.render({'feed': self}).encode('utf-8')
def winrate_app(environ, start_response):
status = '200 OK'
response_headers = [('Content-type', 'text/html'),
('Cache-Control', 'no-cache'),
('Cache-Control', 'must-revalidate')]
start_response(status, response_headers)
engine = Engine(loader=FileLoader(['']), extensions=[CoreExtension()])
template = engine.get_template('winrate_template.html')
player_wins = winrate.download_current_player_wins()
leaderboard = winrate.compute_win_rate_leaderboard(player_wins)
ranked_leaderboard = [
(str(index + 1), name, "{:.2f}%".format(probability * 100))
for index, (name, probability) in enumerate(leaderboard)
]
preview_leaderboard = ""
for rank, name, percentile in ranked_leaderboard[:3]:
preview_leaderboard += "{}. {} {} ".format(rank, name, percentile)
response_body = template.render({
"preview_leaderboard": preview_leaderboard,
"leaderboard": ranked_leaderboard
})
yield response_body.encode()
def post_setup(self, path=None, name=None): # Post setup hook
if path:
self.path = path
else:
self.path = os.path.dirname(inspect.getfile(self.__class__))
if name:
self.name = name
else:
self.name = "%s %s " % (self.default_workspace_category, "Plugin")
self.name = name
# Plugin personal template engine
self.templateEngine = Engine(
loader=FileLoader([self.path, os.path.join(utils.scriptdir, 'html')]),
extensions=[CoreExtension(), CodeExtension()]
)
help_path = os.path.join(self.path, 'readme.html')
if os.path.exists(help_path):
self.help_tab_html_filename = 'readme.html'
else:
self.help_tab_html_filename = None
def setUp(self):
from wheezy.template.engine import Engine
from wheezy.template.ext.core import CoreExtension
from wheezy.template.loader import DictLoader
self.templates = {}
self.engine = Engine(loader=DictLoader(templates=self.templates),
extensions=[CoreExtension()])
def __init__(self,
output_filename,
mz_dtype=np.float64,
intensity_dtype=np.float32):
self.mz_dtype = mz_dtype
self.intensity_dtype = intensity_dtype
self.run_id = os.path.splitext(output_filename)[0]
self.filename = self.run_id + ".imzML"
self.ibd_filename = self.run_id + ".ibd"
self.xml = open(self.filename, 'w')
self.ibd = open(self.ibd_filename, 'w')
self.sha1 = hashlib.sha1()
self.ibd_offset = 0
self.uuid = uuid.uuid4()
self._write_ibd(self.uuid.bytes_le)
self.wheezy_engine = Engine(loader=DictLoader(
{'imzml': IMZML_TEMPLATE}),
extensions=[CoreExtension()])
self.imzml_template = self.wheezy_engine.get_template('imzml')
self.spectra = []
from collections import namedtuple
self.Spectrum = namedtuple('Spectrum', [
'coords', 'mz_len', 'mz_offset', 'mz_enc_len', 'int_len',
'int_offset', 'int_enc_len'
])
def setUp(self) -> None:
templates = {"tmpl1.html": "x1", "shared/master.html": "x2"}
engine = Engine(
loader=DictLoader(templates=templates),
extensions=[CoreExtension()],
)
self.loader = PreprocessLoader(engine, {"x": 1})
def runtime_engine_factory(loader: Loader) -> Engine:
engine = Engine(
loader=loader,
extensions=[
CoreExtension(),
],
)
return engine
def render(self, source, ctx=None):
from wheezy.template.engine import Engine
from wheezy.template.ext.core import CoreExtension
from wheezy.template.loader import DictLoader
loader = DictLoader({'test.html': source})
engine = Engine(loader=loader, extensions=[CoreExtension()])
template = engine.get_template('test.html')
return template.render(ctx or {})
def parse_toplevel_config(self, config):
super().parse_toplevel_config(config)
if GIFormatter.engine is None:
module_path = os.path.dirname(__file__)
searchpath = [os.path.join(module_path, "html_templates")] + Formatter.engine.loader.searchpath
GIFormatter.engine = Engine(
loader=FileLoader(searchpath, encoding='UTF-8'),
extensions=[CoreExtension(), CodeExtension()])
GIFormatter.engine.global_vars.update({'e': html.escape})
def render(
self,
source: str,
ctx: typing.Optional[typing.Mapping[str, typing.Any]] = None,
) -> str:
loader = DictLoader({"test.html": source})
engine = Engine(loader=loader, extensions=[CoreExtension()])
template = engine.get_template("test.html")
return template.render(ctx or {})
def content(self, source, filename):
engine = Engine(
loader=Loader(source),
extensions=[
CoreExtension(token_start='\\$'),
CodeExtension(token_start='\\$'),
])
engine.global_vars.update({'warn': warn})
return engine.get_template(filename).render({})
def tohtml(self):
if DictLoader is None:
raise ImportError('dep wheezy.template needed')
path = os.path.join(os.path.dirname(__file__), 'reader.html.template')
loader = DictLoader({'reader': open(path).read()})
engine = Engine(loader=loader, extensions=[CoreExtension()])
template = engine.get_template('reader')
return template.render({'feed': self}).encode('utf-8')
def generate_source(argsstring, options, version, enums, functions_by_category,
passthru, extensions, types, raw_enums):
template_pattern = re.compile("(.*).template")
# Sort by categories and sort the functions inside the categories
functions_by_category = sorted(functions_by_category, key=lambda x: x[0])
functions_by_category = list(
map(lambda c: (c[0], sorted(c[1], key=lambda x: x.name)),
functions_by_category))
template_namespace = {
'passthru': passthru,
'functions': functions_by_category,
'enums': enums,
'options': options,
'version': version,
'extensions': extensions,
'types': types,
'raw_enums': raw_enums,
'args': argsstring
}
if not os.path.isdir(options.template_dir):
print('%s is not a directory' % options.template_dir)
exit(1)
if os.path.exists(options.outdir) and not os.path.isdir(options.outdir):
print('%s is not a directory' % options.outdir)
exit(1)
if not os.path.exists(options.outdir):
os.mkdir(options.outdir)
engine = Engine(loader=FileLoader([options.template_dir]),
extensions=[CoreExtension(),
CodeExtension()])
generatedFiles = 0
allFiles = 0
for template_path in glob('%s/*.template' %
os.path.abspath(options.template_dir)):
infile = os.path.basename(template_path)
outfile = '%s/%s' % (options.outdir,
template_pattern.match(infile).group(1))
template = engine.get_template(infile)
allFiles += 1
with open(outfile, 'w') as out:
out.write(template.render(template_namespace))
print("Successfully generated %s" % outfile)
generatedFiles += 1
print("Generated %d of %d files" % (generatedFiles, allFiles))
def build_modo_preview_render_command(pathaliases=None, scenes={}):
searchpath = [TEMPLATES]
engine = Engine(loader=FileLoader(searchpath),
extensions=[CoreExtension()])
template = engine.get_template('modo_preview_render_commands.txt')
if pathaliases:
for key in pathaliases:
'{} "{}"'.format(key, os.path.normpath(pathaliases[key]))
return template.render({'pathaliases': pathaliases, 'scenes': scenes})
def build_modo_bash(commands=[], headless="", render_range={}):
searchpath = [TEMPLATES]
engine = Engine(loader=FileLoader(searchpath),
extensions=[CoreExtension()])
template = engine.get_template('modo_batch.sh')
return template.render({
'modo_cl': headless,
'commands': commands,
'render_range': render_range
})
def main(argv: typing.Optional[typing.List[str]] = None) -> int:
args = parse_args(argv or sys.argv[1:])
if not args:
return 2
ts = args.token_start
extensions = [CoreExtension(ts), CodeExtension(ts)]
extensions.extend(args.extensions)
engine = Engine(FileLoader(args.searchpath), extensions)
engine.global_vars.update({"h": escape})
t = engine.get_template(args.template)
sys.stdout.write(t.render(load_context(args.context)))
return 0
def parse_toplevel_config(self, config):
super().parse_toplevel_config(config)
if GstFormatter.engine is None:
gi_extension_path = gi.__path__[0]
searchpath = [
os.path.join(gi_extension_path, "html_templates"),
self.__tmpdir.name
] + Formatter.engine.loader.searchpath
GstFormatter.engine = Engine(
loader=FileLoader(searchpath, encoding='UTF-8'),
extensions=[CoreExtension(), CodeExtension()])
GstFormatter.engine.global_vars.update({'e': html.escape})
def __init__(self, path):
self.path = path
template_dct = {
'docker': templates.docker,
}
engine = Engine(loader=DictLoader(template_dct),
extensions=[CoreExtension(),
CodeExtension()])
self.templates = {
name: engine.get_template(name)
for name in template_dct
}
def get(self):
fortunes = db_session.query(Fortune).all()
fortunes.append(Fortune(id=0, message="Additional fortune added at request time."))
fortunes.sort(key=attrgetter("message"))
engine = Engine(loader=FileLoader(["views"]), extensions=[CoreExtension()])
template = engine.get_template("fortune.html")
for f in fortunes:
f.message = bleach.clean(f.message)
template_html = template.render({"fortunes": fortunes})
response = HTTPResponse()
response.write(template_html)
return response
def to_autopkg(self, outfile):
searchpath = [
os.path.join(os.path.dirname(os.path.abspath(__file__)),
'templates')
]
engine = Engine(loader=FileLoader(searchpath),
extensions=[CoreExtension()])
template = engine.get_template('redist-packages.autopkg')
autopkg = template.render({'package': self})
with open(outfile, 'w') as f:
f.write(autopkg)
return autopkg
def generate(filename, serial_no, settings, data):
path = Path(__file__).parent / 'views'
searchpath = [str(path)]
engine = Engine(loader=FileLoader(searchpath),
extensions=[CoreExtension()])
engine.global_vars.update({'format_value': format_value})
template = engine.get_template('template.html')
with open(filename, 'w') as f:
f.write(
template.render({
'data': data,
'serial_no': serial_no,
'noun': settings['dut']
}))
def build_modo_render_command_win(pathaliases=None, scenes={}):
searchpath = [TEMPLATES]
engine = Engine(loader=FileLoader(searchpath),
extensions=[CoreExtension()])
template = engine.get_template('modo_render_commands_win.txt')
if pathaliases:
for key in pathaliases:
'{} "{}"'.format(key, os.path.normpath(pathaliases[key]))
for scene in scenes:
scenes[scene]['path'] = format_filename(scenes[scene]['path'], 'win32')
return template.render({'pathaliases': pathaliases, 'scenes': scenes})
def main(args=None):
if not json: # pragma: nocover
print('error: json module is not available')
return 1
args = parse_args(args or sys.argv[1:])
if not args:
return 2
ts = args.token_start
extensions = [CoreExtension(ts), CodeExtension(ts)]
extensions.extend(args.extensions)
engine = Engine(FileLoader(args.searchpath), extensions)
engine.global_vars.update({'h': escape})
t = engine.get_template(args.template)
sys.stdout.write(t.render(load_context(args.context)))
return 0
def build_modo_batch(commands=[], headless=""):
import ntpath
searchpath = [TEMPLATES]
engine = Engine(loader=FileLoader(searchpath),
extensions=[CoreExtension()])
template = engine.get_template('modo_batch.bat')
win_commands = []
for command in commands:
win_commands.append(ntpath.normpath(format_filename(command, 'win32')))
headless = ntpath.normpath(
r"C:\Program Files\Luxology\modo\11.0v1\modo_cl.exe")
return template.render({
'modo_cl': ntpath.normpath(headless),
'commands': win_commands
})
def __init__(self, searchpath):
Formatter.__init__(self)
self._symbol_formatters = {
FunctionSymbol: self._format_function,
FunctionMacroSymbol: self._format_function_macro,
CallbackSymbol: self._format_callback,
ConstantSymbol: self._format_constant,
ExportedVariableSymbol: self._format_constant,
AliasSymbol: self._format_alias,
StructSymbol: self._format_struct,
EnumSymbol: self._format_enum,
ParameterSymbol: self._format_parameter_symbol,
ReturnItemSymbol: self._format_return_item_symbol,
FieldSymbol: self._format_field_symbol,
SignalSymbol: self._format_signal_symbol,
VFunctionSymbol: self._format_vfunction_symbol,
PropertySymbol: self._format_property_symbol,
ClassSymbol: self._format_class_symbol,
InterfaceSymbol: self._format_interface_symbol,
}
self._ordering = [InterfaceSymbol, ClassSymbol, FunctionSymbol,
FunctionMacroSymbol, SignalSymbol,
PropertySymbol, StructSymbol,
VFunctionSymbol, EnumSymbol, ConstantSymbol,
ExportedVariableSymbol, AliasSymbol, CallbackSymbol]
if HtmlFormatter.theme_path:
self.__load_theme_templates(searchpath,
HtmlFormatter.theme_path)
if HtmlFormatter.extra_theme_path:
self.__load_theme_templates(searchpath,
HtmlFormatter.extra_theme_path)
searchpath.append(os.path.join(HERE, "html_templates"))
self.engine = Engine(
loader=FileLoader(searchpath, encoding='UTF-8'),
extensions=[CoreExtension(), CodeExtension()]
)
self.all_scripts = set()
self.all_stylesheets = set()
self._docstring_formatter = GtkDocStringFormatter()
def parse_toplevel_config(self, config):
"""Parse @config to setup @self state."""
if not Formatter.initialized:
html_theme = config.get('html_theme', 'default')
if html_theme != 'default':
uri = urllib.parse.urlparse(html_theme)
if not uri.scheme:
html_theme = config.get_path('html_theme')
debug("Using theme located at %s" % html_theme)
elif uri.scheme.startswith('http'):
html_theme = self.__download_theme(uri)
if html_theme == 'default':
default_theme = os.path.join(HERE, os.pardir,
'hotdoc_bootstrap_theme', 'dist')
html_theme = os.path.abspath(default_theme)
debug("Using default theme")
theme_meta_path = os.path.join(html_theme, 'theme.json')
if os.path.exists(theme_meta_path):
with open(theme_meta_path, 'r') as _:
Formatter.theme_meta = json.loads(_.read())
searchpath = []
self.__load_theme_templates(searchpath, HERE)
Formatter.theme_path = html_theme
if html_theme:
self.__load_theme_templates(searchpath, html_theme)
Formatter.extra_theme_path = config.get_path('html_extra_theme')
if Formatter.extra_theme_path:
self.__load_theme_templates(searchpath,
Formatter.extra_theme_path)
Formatter.engine = Engine(
loader=FileLoader(searchpath, encoding='UTF-8'),
extensions=[CoreExtension(), CodeExtension()])
Formatter.engine.global_vars.update({'e': html.escape})
Formatter.initialized = True
def parse_config(self, config):
"""Banana banana
"""
self.add_anchors = bool(config.get("html_add_anchors"))
self.number_headings = bool(config.get("html_number_headings"))
if self.theme_path:
self.__load_theme_templates(self.searchpath, self.theme_path)
if self.extra_theme_path:
self.__load_theme_templates(self.searchpath, self.extra_theme_path)
self.searchpath.append(os.path.join(HERE, "templates"))
self.engine = Engine(loader=FileLoader(self.searchpath,
encoding='UTF-8'),
extensions=[CoreExtension(),
CodeExtension()])
self.engine.global_vars.update({'e': html.escape})
self._docstring_formatter.parse_config(config)
def __init__(self, params):
params = params.copy()
options = params.pop('OPTIONS').copy()
super().__init__(params)
self.template_context_processors = options.pop('context_processors',
[])
if 'loader' not in options:
options['loader'] = FileLoader(self.template_dirs)
options.setdefault('autoescape', True)
options.setdefault('auto_reload', settings.DEBUG)
self.engine = Engine(loader=options['loader'],
extensions=[CoreExtension()])
self.engine.global_vars.update({
'e': escape,
'escape': escape,
'static': static
})
def setUp(self) -> None:
def runtime_engine_factory(loader: Loader) -> Engine:
engine = Engine(
loader=loader,
extensions=[
CoreExtension(),
],
)
return engine
self.templates: typing.Dict[str, str] = {}
engine = Engine(
loader=DictLoader(templates=self.templates),
extensions=[
CoreExtension("#", line_join=""),
],
)
self.engine = Preprocessor(
runtime_engine_factory, engine, key_factory=lambda ctx: ""
)
