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