def setUp(self) -> None:
self.loader = ChainLoader(loaders=[
DictLoader(templates={
"tmpl1.html": "x1",
}),
DictLoader(templates={"shared/master.html": "x2"}),
])
def setUp(self):
from wheezy.template.loader import ChainLoader
from wheezy.template.loader import DictLoader
self.loader = ChainLoader(loaders=[
DictLoader(templates={
'tmpl1.html': 'x1',
}),
DictLoader(templates={'shared/master.html': 'x2'})
])
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 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 __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 ensure_runtime_engine(self, key: str) -> Engine:
self.lock.acquire(True)
try:
engines = self.runtime_engines
if key in engines: # pragma: nocover
return engines[key]
engine = engines[key] = self.runtime_engine_factory(
ChainLoader([DictLoader({}), self.engine.loader])
)
def render(
name: str,
ctx: typing.Mapping[str, typing.Any],
local_defs: typing.Mapping[str, typing.Any],
super_defs: typing.Mapping[str, typing.Any],
) -> str:
try:
return engine.renders[name](ctx, local_defs, super_defs)
except KeyError:
self.preprocess_template(engine, name, ctx)
return engine.renders[name](ctx, local_defs, super_defs)
engine.global_vars["_r"] = render
return engine
finally:
self.lock.release()
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 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 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')
class DictLoaderTestCase(unittest.TestCase):
"""Test the ``DictLoader``."""
def setUp(self) -> None:
self.loader = DictLoader(templates={
"tmpl1.html": "x",
"shared/master.html": "x"
})
def test_list_names(self) -> None:
"""Tests list_names."""
assert ("shared/master.html", "tmpl1.html") == self.loader.list_names()
def test_load_existing(self) -> None:
"""Tests load."""
assert "x" == self.loader.load("tmpl1.html")
def test_load_not_found(self) -> None:
"""Tests load if the name is not found."""
assert self.loader.load("tmpl-x.html") is None
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 setUp(self):
from wheezy.template.loader import PreprocessLoader
from wheezy.template.loader import DictLoader
class Engine(object):
def render(self, name, ctx, d1, d2):
assert {'x': 1} == ctx
return 'x'
engine = Engine()
engine.loader = DictLoader(templates={
'tmpl1.html': 'x1',
'shared/master.html': 'x2'
})
self.loader = PreprocessLoader(engine, {'x': 1})
class DictLoaderTestCase(unittest.TestCase):
""" Test the ``DictLoader``.
"""
def setUp(self):
from wheezy.template.loader import DictLoader
self.loader = DictLoader(templates={
'tmpl1.html': 'x',
'shared/master.html': 'x'
})
def test_list_names(self):
""" Tests list_names.
"""
assert ('shared/master.html', 'tmpl1.html') == self.loader.list_names()
def test_load_existing(self):
""" Tests load.
"""
assert 'x' == self.loader.load('tmpl1.html')
def test_load_not_found(self):
""" Tests load if the name is not found.
"""
assert self.loader.load('tmpl-x.html') is None
def ensure_runtime_engine(self, key):
self.lock.acquire(1)
try:
engines = self.runtime_engines
if key in engines: # pragma: nocover
return engines[key]
engine = engines[key] = self.runtime_engine_factory(
loader=ChainLoader([DictLoader({}), self.engine.loader]))
def render(name, ctx, local_defs, super_defs):
try:
return engine.renders[name](ctx, local_defs, super_defs)
except KeyError:
self.preprocess_template(engine, name, ctx)
return engine.renders[name](ctx, local_defs, super_defs)
engine.global_vars['_r'] = render
return engine
finally:
self.lock.release()
def setUp(self):
from wheezy.template.engine import Engine
from wheezy.template.preprocessor import Preprocessor
from wheezy.template.loader import DictLoader
from wheezy.template.ext.core import CoreExtension
def runtime_engine_factory(loader):
engine = Engine(loader=loader, extensions=[
CoreExtension(),
])
return engine
self.templates = {}
engine = Engine(loader=DictLoader(templates=self.templates),
extensions=[
CoreExtension('#', line_join=None),
])
self.engine = Preprocessor(runtime_engine_factory,
engine,
key_factory=lambda ctx: '')
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: ""
)
def get_wheezy_tests():
if not wheezy:
return []
from wheezy.template.engine import Engine
from wheezy.template.loader import DictLoader
from wheezy.template.ext.core import CoreExtension
# from wheezy.html.utils import escape_html as escape
engine = Engine(loader=DictLoader({
'x':
"""\
@require(table)
<table>
@for row in table:
<tr>
@for key, value in row.items():
<td>@key!s</td><td>@value!s</td>
@end
</tr>
@end
</table>
"""
}),
extensions=[CoreExtension()])
# engine.global_vars.update({'h': escape})
wheezy_template = engine.get_template('x')
ctx = {'table': TABLE_DATA}
def test_wheezy_template():
"""wheezy template"""
return wheezy_template.render(ctx)
return [
test_wheezy_template,
]
def run(self, handler):
from cherrypy import wsgiserver
from cherrypy.wsgiserver.ssl_pyopenssl import pyOpenSSLAdapter
server = wsgiserver.CherryPyWSGIServer((self.host, self.port), handler)
server.ssl_adapter = pyOpenSSLAdapter('cacert.pem', 'privkey.pem')
try:
server.start()
finally:
server.stop()
template = """\
@require(name)
Hello, @name"""
engine_dict = Engine(loader=DictLoader({'x': template}),
extensions=[CoreExtension()])
template_w = engine_dict.get_template('x')
searchpath = ['./static/templates-wheezy']
#searchpath = ['./views']
engine = Engine(loader=FileLoader(searchpath),
extensions=[CoreExtension(), CodeExtension()])
templateChild = engine.get_template('child.html')
template_famille = engine.get_template('famille.html')
@route("/")
def working():
try:
from wheezy.template.engine import Engine
from wheezy.template.loader import DictLoader
from wheezy.template.ext.core import CoreExtension
except ImportError:
test_wheezy_template = None
else:
engine = Engine(loader=DictLoader({
'x':
s("""\
@require(table)
<table>
@for row in table:
<tr>
@for key, value in row.items():
<td>@key!h</td><td>@value!s</td>
@end
</tr>
@end
</table>
""")
}),
extensions=[CoreExtension()])
engine.global_vars.update({'h': escape})
wheezy_template = engine.get_template('x')
def test_wheezy_template():
return wheezy_template.render(ctx)
def setUp(self) -> None:
self.templates: typing.Dict[str, str] = {}
self.engine = Engine(
loader=DictLoader(templates=self.templates),
extensions=[CoreExtension()],
)
def setUp(self) -> None:
self.engine = Engine(
loader=DictLoader({}), extensions=[CodeExtension()]
)
'page_a': page_a,
'page_b': page_b,
'page_all': page_all
}
def build_include(builder, lineno, token, value):
assert token == 'include'
builder.add(lineno, 'w(_r(' + value + ', ctx, {}, {}))')
return True
class MyExtention(object):
builder_rules = [('include', build_include)]
engine = Engine(loader=DictLoader(pages),
extensions=[MyExtention(), CoreExtension()])
class TestCase(unittest.TestCase):
def test_render(self):
template = engine.get_template('page_all')
r = template.render({})
self.assertEqual(['a', 'b'], r.split())
if __name__ == '__main__':
unittest.main()
def setUp(self) -> None:
self.engine = Engine(loader=DictLoader({}),
extensions=[CoreExtension(line_join="")])
@def content():
b
@end
"""
page_all = """
@_r('page_a', ctx, {}, {})
@_r('page_b', ctx, {}, {})
"""
pages = {
'master': master,
'page_a': page_a,
'page_b': page_b,
'page_all': page_all
}
engine = Engine(loader=DictLoader(pages), extensions=[CoreExtension()])
class TestCase(unittest.TestCase):
def test_render(self):
template = engine.get_template('page_all')
r = template.render({})
self.assertEqual(['a', 'b'], r.split())
if __name__ == '__main__':
unittest.main()
def setUp(self):
from wheezy.template.engine import Engine
from wheezy.template.loader import DictLoader
self.engine = Engine(
loader=DictLoader(templates={}),
extensions=[])
</form>
<script>
window.onload=function()
{
c = document.getElementById('captcha');
c.onclick = function() {
this.src=this.src.replace(/&r=\d+/g,'') + '&r=' + \
Math.floor(Math.random() * 100 + 1);
};
}
</script>
</body></html>"""
}
engine = Engine(
loader=DictLoader(templates),
extensions=[CoreExtension(),
WidgetExtension(),
WhitespaceExtension()])
all_urls = [('', WelcomeHandler),
url('captcha.jpg', captcha_handler, name='captcha')]
options = {'http_cache': cache, 'render_template': WheezyTemplate(engine)}
main = WSGIApplication([
bootstrap_defaults(url_mapping=all_urls), http_cache_middleware_factory,
path_routing_middleware_factory
], options)
if __name__ == '__main__':
from wsgiref.handlers import BaseHandler
class Engine(BaseEngine):
def render(self, name, ctx, local_defs, super_defs):
super_defs['__super__'] = s = {}
return super(Engine, self).render(name, ctx, local_defs, s)
def super_token(m):
i = m.end(1) - m.start(1)
end, name, value = var_token(m)
s = 'super_defs["__super__"]["' + value[:i] + '"]' + value[i:]
return end, 'var', s
core = CoreExtension()
core.lexer_rules[150] = (re.compile(r'@super\.(\w+)'), super_token)
engine = Engine(loader=DictLoader(pages), extensions=[core])
class TestCase(unittest.TestCase):
def test_render(self):
template = engine.get_template('page_b')
r = template.render({})
assert ['b', 'a', 'super'] == r.split()
if __name__ == '__main__':
unittest.main()
def setUp(self):
from wheezy.template.engine import Engine
from wheezy.template.ext.core import CoreExtension
from wheezy.template.loader import DictLoader
self.engine = Engine(loader=DictLoader({}),
extensions=[CoreExtension(line_join=None)])
class EscapeExtension(object):
builder_rules = [("var", build_var)]
# setup
template = """
@require(var)
@def x(s):
<meta name="@s" />
@end
@var @var!e @var!s @x(var)!safe
"""
engine = Engine(
loader=DictLoader({"template": template}),
extensions=[EscapeExtension(), CoreExtension()],
)
engine.global_vars.update({"e": escape})
# test
class TestCase(unittest.TestCase):
def test_render(self) -> None:
template = engine.get_template("template")
r = template.render({"var": "<X>"})
self.assertEqual('<X> <X> <X> <meta name="<X>" />',
r.strip())
r = template.render({"var": "X"})
self.assertEqual('X X X <meta name="X" />', r.strip())
