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())