def text(self): filename = self.module.replace( '__init__.pyc', 'text.html' ).replace( '__init__.py', 'text.html' ) f = open(filename) template = PageTemplate(f.read().replace('#{','${').replace("condition=","tal:condition=")) dictionary = dict(self.__dict__, **globals()) dictionary['answer'] = self.answer() return template.render(**dictionary)
def SayHello(self, request, context): tmpl = PageTemplate(BIGTABLE_ZPT) data = {} num_of_cols = 15 num_of_rows = 10 if request.name == "record": msg = 'Hello, %s!' % responses[0] num_of_cols = 15 num_of_rows = 10 elif request.name == "replay": msg = 'Hello, %s!' % responses[1] num_of_cols = 10 num_of_rows = 15 else: msg = 'Hello, %s!' % request.name for i in range(num_of_cols): data[str(i)] = i table = [data for x in range(num_of_rows)] options = {'table': table} data = tmpl.render(options=options) return helloworld_pb2.HelloReply(message=msg)
def hints(self): filename = self.module.replace( '__init__.pyc', self.__class__.hint_filename ).replace( '__init__.py', self.__class__.hint_filename ) f = open(filename) template = PageTemplate(f.read().replace('#{','${').replace("condition=","tal:condition=")) dictionary = dict(self.__dict__, **globals()) dictionary['answer'] = self.answer() return [x.replace('<p>','').replace('</p>','') for x in re.sub("\n+","\n",template.render(**dictionary)).split( "</p>\n<p>" )]
def text(self): filename = self.module.replace('__init__.pyc', 'text.html').replace( '__init__.py', 'text.html') f = open(filename) template = PageTemplate(f.read().replace('#{', '${').replace( "condition=", "tal:condition=")) dictionary = dict(self.__dict__, **globals()) dictionary['answer'] = self.answer() return template.render(**dictionary)
def render_logo(locale, default_src=None): request = self.mk_request(locale_name=locale) self.views = CmsViews(request) if default_src: define = 'tal:define="img_attrs view.get_logo_attributes' \ '(default_image_src=\'%s\')"' % default_src else: define = '' template = '<div metal:use-macro="view.logo_template" %s></div>' template = PageTemplate(template % define) return template.render(view=self.views, request=request)
def __call__(self, field, **kwargs): params = html_params(name=field.name, **kwargs) request = field.meta.request registry = request.app.config.template_engine_registry macros = registry._template_loaders['.pt'].macros template = PageTemplate(f""" <div {params}> <div metal:use-macro="macros['{field.macro}']"/> </div> """, macros=macros) translate = request.get_translate(for_chameleon=True) return HTMLString(template.render(translate=translate))
def hints(self): filename = self.module.replace('__init__.pyc', self.__class__.hint_filename).replace( '__init__.py', self.__class__.hint_filename) f = open(filename) template = PageTemplate(f.read().replace('#{', '${').replace( "condition=", "tal:condition=")) dictionary = dict(self.__dict__, **globals()) dictionary['answer'] = self.answer() return [ x.replace('<p>', '').replace('</p>', '') for x in re.sub("\n+", "\n", template.render( **dictionary)).split("</p>\n<p>") ]
def main(req: func.HttpRequest) -> func.HttpResponse: num_of_rows = req.params.get('num_of_rows') num_of_cols = req.params.get('num_of_cols') start = time() tmpl = PageTemplate(BIGTABLE_ZPT) data = {} for i in range(num_of_cols): data[str(i)] = i table = [data for x in range(num_of_rows)] options = {'table': table} data = tmpl.render(options=options) latency = time() - start return func.HttpResponse(str(latency))
def lambda_handler(event, context): num_of_rows = event['num_of_rows'] num_of_cols = event['num_of_cols'] start = time() tmpl = PageTemplate(BIGTABLE_ZPT) data = {} for i in range(num_of_cols): data[str(i)] = i table = [data for x in range(num_of_rows)] options = {'table': table} data = tmpl.render(options=options) latency = time() - start result = json.dumps({'latency': latency, 'data': data}) return result
def main(n, timer): tmpl = PageTemplate(BIGTABLE_ZPT) options = {'table': [dict(a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10) for x in range(1000)]} l = [] for k in range(n): t0 = timer() tmpl(options=options) l.append(timer() - t0) return l
def main(): runner = pyperf.Runner() runner.metadata['description'] = "Chameleon template" tmpl = PageTemplate(BIGTABLE_ZPT) table = [dict(a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10) for x in range(500)] options = {'table': table} func = functools.partial(tmpl, options=options) runner.bench_func('chameleon', func)
def render(self, project): """Gera a aplicação a partir do arquivo XML exportado de um modelo UML.""" # Instancia o logger. logger = logging.getLogger('render') logger.info(u'Renderizando "%s"' % short_dir(self.__template, basepath)) with open(self.__template) as tf: template_code = tf.read() template = PageTemplate(template_code) rendered = template(project=project) return rendered
def main(args): global cold was_cold = cold cold = False num_of_rows = int(args.get("num_of_rows", 10)) num_of_cols = int(args.get("num_of_cols", 10)) start = time() tmpl = PageTemplate(BIGTABLE_ZPT) data = {} for i in range(num_of_cols): data[str(i)] = i table = [data for x in range(num_of_rows)] options = {'table': table} data = tmpl.render(options=options) latency = time() - start return {"body": {'latency': latency, 'data': data, "cold": was_cold}}
def main(loops): tmpl = PageTemplate(BIGTABLE_ZPT) table = [ dict(a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10) for x in range(500) ] options = {'table': table} start = perf.perf_counter() for _ in range(loops): tmpl(options=options) return perf.perf_counter() - start
def test_mako(count): template = PageTemplate(CONTENT_TEMPLATE) base = PageTemplate(BASE_TEMPLATE) page = PageTemplate(PAGE_TEMPLATE) table = [range(150) for i in range(150)] paragraphs = range(50) title = 'Hello world!' times = [] for i in range(count): t0 = time.time() data = template.render( table=table, paragraphs=paragraphs, lorem=LOREM_IPSUM, title=title, img_count=50, base=base, page=page, ) t1 = time.time() times.append(t1-t0) return times
def test_mako(count): template = PageTemplate(CONTENT_TEMPLATE) base = PageTemplate(BASE_TEMPLATE) page = PageTemplate(PAGE_TEMPLATE) table = [xrange(150) for i in xrange(150)] paragraphs = xrange(50) title = 'Hello world!' times = [] for i in range(count): t0 = time.time() data = template.render( table=table, paragraphs=paragraphs, lorem=LOREM_IPSUM, title=title, img_count=50, base=base, page=page, ) t1 = time.time() times.append(t1 - t0) return times
def function_handler(request): request_json = request.get_json(silent=True) num_of_rows = request_json['num_of_rows'] num_of_cols = request_json['num_of_cols'] message = generate(length_of_message) # 128-bit key (16 bytes) KEY = b'\xa1\xf6%\x8c\x87}_\xcd\x89dHE8\xbf\xc9,' start = time() tmpl = PageTemplate(BIGTABLE_ZPT) data = {} for i in range(num_of_cols): data[str(i)] = i table = [data for x in range(num_of_rows)] options = {'table': table} data = tmpl.render(options=options) latency = time() - start return "latency : " + str(latency)
def functionWorker(tname, allocate_pkey): if allocate_pkey: pkey_thread_mapper(tname) runner = pyperf.Runner(loops=1) runner.metadata['description'] = "Chameleon template" tmpl = PageTemplate(BIGTABLE_ZPT) table = [dict(a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10) for x in range(500)] options = {'table': table} func = functools.partial(tmpl, options=options) runner.bench_func('chameleon', func) del runner pymem_reset()
def load(self, filename, backup='index.html'): """Load and return a template file. The format parameter determines will parse the file. Valid options are `xml` and `text`. """ if filename in self.template_cache: return self.template_cache[filename] try: data = self.read_file(filename) except: data = None if not data: filename = backup if filename in self.template_cache: return self.template_cache[filename] data = self.read_file(filename) template = PageTemplate(data) self.template_cache[filename] = template return template
except Exception: period = 0 if period > 5.0: logger.warn('SLOW REQUEST(%i): %s' % (int(period), req.ACTUAL_URL)) log_request(req) _impersonator_template = PageTemplate(""" <div id="impersonator"> <a href="${stop_url}" class="stop"><span class="glyphicon glyphicon-remove"></span></a> <span>This is what the website looks like to: <span class="anonymous" tal:condition="python: user_id == 'ANONYMOUS'"> <span class="glyphicon glyphicon-globe"></span> Public </span> <span class="anonymous" tal:condition="python: user_id != 'ANONYMOUS'"> <span class="glyphicon glyphicon-user"></span> ${user_name} </span> </div>""" # noqa ) class TransformInpersonatorOutput(object): implements(ITransform) order = 10000 def __init__(self, published, request): self.published = published
def load_raw(self, raw): return PageTemplate(raw)
def parse(template, qs): return PageTemplate(template)(request=qs)
import pandas import smtplib from chameleon import PageTemplate from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart # read csv file, containing the emails, name, passwords file = pandas.read_csv("email_list.csv") # read from template file template_file = open('email-templates.html') template = PageTemplate(template_file.read().encode('utf-8')) template_file.close() # extraction emails, sent emails = file['Email'].values sents = file['Sent'].values usernames = file['Name'].values passwords = file['Password'].values server = smtplib.SMTP('smtp.gmail.com', 587) # starting the server server.starttls() server.login('email', '*******') done = False # very poor time complexity, not optimized for data rows larger than 10^6 while not done:
def chameleon(request): template = request.GET['template'] tmpl = PageTemplate(template) return HttpResponse(tmpl)
data = zlib.decompress(request.body) if request.content_type in ('application/json', 'application/octet-stream'): data = loads(data) session = request.dbsession event_id = data.pop('event_id') _project = int(data.pop('project', project)) assert _project == project session.add(Event(event_id=event_id, project=project, data=data)) session.flush() return Response('OK') exceptions_info_template = PageTemplate(''' <dl tal:repeat="exception exceptions"> <dt>${exception.get('module', '')} ${exception.get('type', '')}</dt> <dd>${exception.get('value', '')}</dd> </dl>''') frame_template = PageTemplate(''' <dl class="frame"> <dt>File <code title="${frame.abs_path}">${frame.filename}</code>, line ${frame.lineno}, in <code title="${frame.module}">${frame.function}</code></dt> <dd> <pre class="context">${'\\n'.join(frame.pre_context)}\n<strong>${frame.context_line}</strong>\n${'\\n'.join(frame.post_context)}</pre> <input type="checkbox" id="frametoggle${id(frame)}" class="togglecontrol"> <label for="frametoggle${id(frame)}" tal:condition="'vars' in frame">Variables<span class="toggler"></span></label> <table class="vars toggleable" tal:condition="'vars' in frame"> <tbody> <tr tal:repeat="(k, v) frame.vars.items()"> <th>${k}</th> <td><pre>${pformat(v)}</pre></td> </tr>
def chameleon(): template = PageTemplate("sink")
def indexgen(index): template = PageTemplate( resource_string('sherwoodwang_github_io', os.path.join('templates', 'index.pt'))) yield template(index=index)