def nb_renderer(full_path):
directory, base = split(full_path)
cache_file = join(directory, '.%s.html' % base)
if not current_app.config.get('DEBUG'):
try:
if isfile(cache_file) and getmtime(full_path) < getmtime(cache_file):
current_app.logger.debug('Using Cache File %s' % cache_file)
return raw_renderer(cache_file)
except:
current_app.logger.warn('There was an error reading from the cache file %s' % cache_file)
ex = HTMLExporter(extra_loaders=[current_app.jinja_env.loader],
template_file='wakari_notebook.html')
ex.environment.globals.update(current_app.jinja_env.globals)
current_app.update_template_context(ex.environment.globals)
ex.environment.globals.update(dirname=dirname(request.view_args['path']))
output, _ = ex.from_filename(full_path)
try:
with open(cache_file, 'w') as fd:
current_app.logger.debug('Writing Cache File %s' % cache_file)
fd.write(output.encode(errors='replace'))
except (OSError, IOError):
current_app.logger.warn('There was an error writing to the cache file %s' % cache_file)
try:
if isfile(cache_file): os.unlink(cache_file)
except OSError:
current_app.logger.warn('There was an error removing the cache file %s' % cache_file)
pass
return output
def stream_template(template_name, **context):
# http://stackoverflow.com/questions/13386681/streaming-data-with-python-and-flask
# http://flask.pocoo.org/docs/patterns/streaming/#streaming-from-templates
current_app.update_template_context(context)
t = current_app.jinja_env.get_template(template_name)
rv = t.stream(context)
return rv
def get_template_module(template_name, **context):
"""Returns the python module of a template.
This allows you to call e.g. macros inside it from Python code."""
app.update_template_context(context)
tpl = app.jinja_env.get_template(template_name)
return tpl.make_module(context)
def get_template_module(template_name_or_list, **context):
"""Returns the python module of a template.
This allows you to call e.g. macros inside it from Python code."""
current_app.update_template_context(context)
tpl = current_app.jinja_env.get_or_select_template(template_name_or_list)
return tpl.make_module(context)
def get_template_module(template_name_or_list, **context):
"""Returns the python module of a template.
This allows you to call e.g. macros inside it from Python code."""
current_app.update_template_context(context)
tpl = current_app.jinja_env.get_or_select_template(template_name_or_list)
return tpl.make_module(context)
def stream_template(template_name, **context):
# http://stackoverflow.com/questions/13386681/streaming-data-with-python-and-flask
# http://flask.pocoo.org/docs/patterns/streaming/#streaming-from-templates
current_app.update_template_context(context)
t = current_app.jinja_env.get_template(template_name)
rv = t.stream(context)
return rv
def get_template_module(template_name, **context):
"""Returns the python module of a template.
This allows you to call e.g. macros inside it from Python code."""
app.update_template_context(context)
tpl = app.jinja_env.get_template(template_name)
return tpl.make_module(context)
def __call__(self, c, params): """\ Run this template. """ current_app.update_template_context(params) c.content = self.template.render(**params) c.from_mime = self.db_template.adapter.to_mime return c.content
def __call__(self, c, params):
"""\
Run this template.
"""
current_app.update_template_context(params)
c.content = self.template.render(**params)
c.from_mime = self.db_template.adapter.to_mime
return c.content
def stream_template(template_name, **context):
# http://flask.pocoo.org/docs/patterns/streaming/#streaming-from-templates
app.update_template_context(context)
t = app.jinja_env.get_template(template_name)
rv = t.stream(context)
# uncomment if you don't need immediate reaction
##rv.enable_buffering(5)
return rv
def stream_template(template_name, **context):
""" Stream a template
Needs to be used with Response(stream_template(...))
"""
current_app.update_template_context(context)
t = current_app.jinja_env.get_template(template_name)
rv = t.stream(context)
rv.enable_buffering(5)
return rv
def render_square_bracket_template(template_name, context):
env = current_app.jinja_env.overlay(block_start_string = "[%",
block_end_string = "%]",
variable_start_string = "[[",
variable_end_string = "]]",
comment_start_string = "[#",
comment_end_string = "#]")
current_app.update_template_context(context)
template = env.get_template(template_name)
return template.render(**context)
def stream_template(template_name, **context):
"""
The jinja2 template supports rendering templates piece by piece,
however the request context is not kept during whole time of
template rendering process.
@ see: http://flask.pocoo.org/docs/patterns/streaming/
"""
current_app.update_template_context(context)
t = current_app.jinja_env.get_template(template_name)
rv = t.stream(context)
return stream_with_context(rv)
def generate_template(template=None,
context=None,
method=None,
string=None,
filter=None):
"""Creates a Genshi template stream that you can
run filters and transformations on.
"""
genshi = current_app.extensions['genshi']
method = genshi._method_for(template, method)
class_ = genshi.methods[method].get('class', MarkupTemplate)
context = context or {}
for key, value in list(current_app.jinja_env.globals.items()):
context.setdefault(key, value)
context.setdefault('filters', current_app.jinja_env.filters)
context.setdefault('tests', current_app.jinja_env.tests)
for key, value in list(current_app.jinja_env.filters.items()):
context.setdefault(key, value)
for key, value in list(current_app.jinja_env.tests.items()):
context.setdefault('is%s' % key, value)
current_app.update_template_context(context)
if template is not None:
template = genshi.template_loader.load(template, cls=class_)
elif string is not None:
template = class_(string)
else:
raise RuntimeError('Need a template or string')
stream = template.generate(**context)
if signals_available:
template_generated.send(current_app._get_current_object(),
template=template,
context=context)
for func in genshi.filters[method]:
if len(getargspec(func)[0]) == 2: # Filter takes context?
stream = func(stream, context)
else:
stream = func(stream)
if filter:
if len(getargspec(filter)[0]) == 2: # Filter takes context?
stream = list(filter(stream, context))
else:
stream = list(filter(stream))
return stream
def stream_template(template_name, **context):
"""
The jinja2 template supports rendering templates piece by piece,
however the request context is not kept during whole time of
template rendering process.
see::
http://flask.pocoo.org/docs/patterns/streaming/
"""
current_app.update_template_context(context)
t = current_app.jinja_env.get_template(template_name)
rv = t.stream(context)
return stream_with_context(rv)
def render(template_name, request, status_code=None, **template_vars):
template_vars['request'] = request
template_vars['session'] = session
template_vars['config'] = current_app.config
current_app.update_template_context(template_vars)
body = renderer.render(template_name, **template_vars)
if status_code is None:
if request.method == 'POST':
status_code = 201
elif request.method == 'DELETE':
status_code = 204
else:
status_code = 200
return Response(body, status=status_code)
def render(template_name, request, status_code=None, **template_vars):
template_vars["request"] = request
template_vars["session"] = session
template_vars["config"] = current_app.config
current_app.update_template_context(template_vars)
body = renderer.render(template_name, **template_vars)
if status_code is None:
if request.method == "POST":
status_code = 201
elif request.method == "DELETE":
status_code = 204
else:
status_code = 200
return Response(body, status=status_code)
def generate_template(template=None, context=None,
method=None, string=None, filter=None):
"""Creates a Genshi template stream that you can
run filters and transformations on.
"""
genshi = current_app.extensions['genshi']
method = genshi._method_for(template, method)
class_ = genshi.methods[method].get('class', MarkupTemplate)
context = context or {}
for key, value in current_app.jinja_env.globals.iteritems():
context.setdefault(key, value)
context.setdefault('filters', current_app.jinja_env.filters)
context.setdefault('tests', current_app.jinja_env.tests)
for key, value in current_app.jinja_env.filters.iteritems():
context.setdefault(key, value)
for key, value in current_app.jinja_env.tests.iteritems():
context.setdefault('is%s' % key, value)
current_app.update_template_context(context)
if template is not None:
template = genshi.template_loader.load(template, cls=class_)
elif string is not None:
template = class_(string)
else:
raise RuntimeError('Need a template or string')
stream = template.generate(**context)
if signals_available:
template_generated.send(current_app._get_current_object(),
template=template, context=context)
for func in genshi.filters[method]:
if len(getargspec(func)[0]) == 2: # Filter takes context?
stream = func(stream, context)
else:
stream = func(stream)
if filter:
if len(getargspec(filter)[0]) == 2: # Filter takes context?
stream = filter(stream, context)
else:
stream = filter(stream)
return stream
def experiment_dashboard(exp_uid, app_id):
"""
Endpoint that renders the experiment dashboard.
Inputs: ::\n
(string) exp_uid, exp_uid for a current experiment.
"""
simple_flag = int(request.args.get('simple', 0))
force_recompute = int(request.args.get('force_recompute', 1))
if rm.get_experiment(exp_uid) is None:
return render_template('exp_404.html', exp_uid=exp_uid), 404
# Not a particularly good way to do this.
alg_label_list = rm.get_algs_for_exp_uid(exp_uid)
alg_list = [{
'alg_label': alg['alg_label'],
'alg_label_clean': '_'.join(alg['alg_label'].split())
} for alg in alg_label_list]
# -- Directly use Jinja2 to load and render the app-specific dashboard template.
env = Environment(loader=ChoiceLoader([
PackageLoader('apps.{}'.format(app_id), 'dashboard'),
PackageLoader('next.dashboard', 'templates')
]))
template = env.get_template(
'myAppDashboard.html'.format(app_id)
) # looks for /next/apps/{{ app_id }}/dashboard/{{ app_id }}.html
# The context we pass to the dashboard template.
ctx = dict(
app_id=app_id,
exp_uid=exp_uid,
alg_list=alg_list,
exceptions_present=False, #exceptions_present(exp_uid),
url_for=url_for,
simple_flag=int(simple_flag),
force_recompute=int(force_recompute))
# Inject standard Flask context + context processors
current_app.update_template_context(ctx)
# Render the template
return template.render(**ctx)
def generate_template(template=None, context=None, method=None, string=None):
"""Creates a Kajiki template stream that you can
run filters and transformations on.
"""
kajiki = current_app.extensions['kajiki']
method = kajiki._method_for(template, method)
class_ = kajiki.methods[method].get('class', XMLTemplate)
filters = current_app.jinja_env.filters.copy()
for name, f in filters.items():
if getattr(f, 'environmentfilter', False):
filters[name] = (lambda f: lambda *args, **kw: f(
current_app.jinja_env, *args, **kw))(f)
elif getattr(f, 'contextfilter', False):
filters[name] = (lambda f: lambda *args, **kw: f(
FakeJinjaContext(current_app.jinja_env), *args, **kw))(f)
elif getattr(f, 'evalcontextfilter', False):
filters[name] = (lambda f: lambda *args, **kw: f(
FakeJinjaEvalContext(current_app.jinja_env), *args, **kw))(f)
context = context or {}
for key, value in current_app.jinja_env.globals.items():
context.setdefault(key, value)
context.setdefault('filters', filters)
context.setdefault('tests', current_app.jinja_env.tests)
for key, value in filters.items():
context.setdefault(key, value)
for key, value in current_app.jinja_env.tests.items():
context.setdefault('is%s' % key, value)
current_app.update_template_context(context)
if template is not None:
# TODO cls=class_
template = kajiki.template_loader.load(template)
elif string is not None:
template = class_(string)
else:
raise RuntimeError('Need a template or string')
return template(context)
def generate_template(template=None, context=None,
method=None, string=None, filter=None):
"""Creates a Genshi template stream that you can
run filters and transformations on.
"""
genshi = current_app.extensions['genshi']
method = genshi._method_for(template, method)
class_ = genshi.methods[method].get('class', MarkupTemplate)
filters = current_app.jinja_env.filters.copy()
for name, f in filters.items():
if getattr(f, "environmentfilter", False):
filters[name] = (
lambda f: lambda *args, **kw: f(current_app.jinja_env, *args, **kw)
)(f)
elif getattr(f, "contextfilter", False):
filters[name] = (
lambda f: lambda *args, **kw: f(
FakeJinjaContext(current_app.jinja_env), *args, **kw
)
)(f)
elif getattr(f, "evalcontextfilter", False):
filters[name] = (
lambda f: lambda *args, **kw: f(
FakeJinjaEvalContext(current_app.jinja_env), *args, **kw
)
)(f)
context = context or {}
for key, value in current_app.jinja_env.globals.items():
context.setdefault(key, value)
context.setdefault('filters', filters)
context.setdefault('tests', current_app.jinja_env.tests)
current_app.update_template_context(context)
if template is not None:
template = genshi.template_loader.load(template, cls=class_)
elif string is not None:
template = class_(string)
else:
raise RuntimeError('Need a template or string')
stream = template.generate(**context)
if signals_available:
template_generated.send(current_app._get_current_object(),
template=template, context=context)
for func in genshi.filters[method]:
if len(getfullargspec(func)[0]) == 2: # Filter takes context?
stream = func(stream, context)
else:
stream = func(stream)
if filter:
if len(getfullargspec(filter)[0]) == 2: # Filter takes context?
stream = filter(stream, context)
else:
stream = filter(stream)
return stream
def search_to_context(self,
lookup_value,
detailed=False,
**default_context_kwargs):
""" This needs a big redo.
Note however: new-style templates require similar input
across Detail/main page view, so can really refactor and
chop stuff down.
TODO: inclusion of context_processors ?
TODO: And the big mess is:
* do_search_to_obj
* search_context - simplify
"""
current_pair, _ = current_app.config.resolve_original_pair(
g._from, g._to)
async_paradigm = current_pair.get('asynchronous_paradigms', False)
lemma_attrs = default_context_kwargs.get('lemma_attrs', {})
if detailed and not async_paradigm:
generate = True
else:
generate = False
if 'variant_type' in default_context_kwargs:
variant_type = default_context_kwargs.get('variant_type')
search_result_obj = self.do_search_to_obj(
lookup_value,
generate=generate,
lemma_attrs=lemma_attrs,
variant_type=variant_type)
else:
search_result_obj = self.do_search_to_obj(lookup_value,
generate=generate,
lemma_attrs=lemma_attrs)
if detailed:
template = 'detail_entry.template'
else:
template = 'entry.template'
_rendered_entry_templates = []
template_results = [{
'input':
search_result_obj.search_term,
'lookups':
search_result_obj.formatted_results_sorted
}]
logIndexLookups(search_result_obj.search_term, template_results,
g._from, g._to)
show_info = False
def sort_entry(r):
if r[0] is None:
return False
if len(r[0]) > 0:
return False
try:
return ''.join(r[0].xpath('./lg/l/text()'))
except:
return False
# TODO: sorting_problem
for lz, az, paradigm, has_layout in search_result_obj.entries_and_tags_and_paradigms:
if lz is not None:
user_input = search_result_obj.search_term
candidate_word_forms = determine_recording_word_forms(
user_input, paradigm)
tplkwargs = {
'lexicon_entry':
lz,
'analyses':
az,
'recording_word_forms':
candidate_word_forms,
'paradigm':
paradigm,
'layout':
has_layout,
'user_input':
user_input,
'word_searches':
template_results,
'errors':
False,
'show_info':
show_info,
'successful_entry_exists':
search_result_obj.successful_entry_exists
}
tplkwargs.update(**default_context_kwargs)
# Process all the context processors
current_app.update_template_context(tplkwargs)
_rendered_entry_templates.append(
current_app.lexicon_templates.render_template(
g._from, template, **tplkwargs))
all_az = sum([
az for _, az in sorted(search_result_obj.entries_and_tags,
key=sort_entry)
], [])
indiv_template_kwargs = {
'analyses': all_az,
'recordings_endpoint': current_app.config.recordings_endpoint
}
indiv_template_kwargs.update(**default_context_kwargs)
# Process all the context processors
current_app.update_template_context(indiv_template_kwargs)
all_analysis_template = \
current_app.lexicon_templates.render_individual_template(g._from, 'analyses.template', **indiv_template_kwargs)
header_template = \
current_app.lexicon_templates.render_individual_template(g._from, 'includes.template', **indiv_template_kwargs)
if search_result_obj.analyses_without_lex:
leftover_tpl_kwargs = {
'analyses': search_result_obj.analyses_without_lex,
}
leftover_tpl_kwargs.update(**default_context_kwargs)
# Process all the context processors
current_app.update_template_context(leftover_tpl_kwargs)
leftover_analyses_template = \
current_app.lexicon_templates.render_individual_template( g._from
, 'analyses.template'
, **leftover_tpl_kwargs
)
else:
leftover_analyses_template = False
search_context = {
# This is the new style stuff.
'entry_templates':
_rendered_entry_templates,
'entry_template_header_includes':
header_template,
'leftover_analyses_template':
leftover_analyses_template,
'all_analysis_template':
all_analysis_template,
# These variables can be turned into something more general
'successful_entry_exists':
search_result_obj.successful_entry_exists,
'word_searches':
template_results,
'analyses':
search_result_obj.analyses,
'analyses_without_lex':
search_result_obj.analyses_without_lex,
'user_input':
search_result_obj.search_term,
'last_searches':
session.get('last_searches-' + current_app.config.short_name, []),
# ?
'errors':
False, # where should we expect errors?
'language_pairs_other_results':
search_result_obj.other_results,
'debug_text':
search_result_obj.debug_text
}
search_context.update(**default_context_kwargs)
return self.post_search_context_modification(search_result_obj,
search_context)
def stream_template(template_name, **context):
current_app.update_template_context(context)
template = current_app.jinja_env.get_template(template_name)
stream = template.stream(context)
stream.enable_buffering(10)
return stream
def stream_template(template_name, **context):
current_app.update_template_context(context)
t = current_app.jinja_env.get_template(template_name)
rv = t.stream(context)
rv.enable_buffering(5)
return rv
def stream_template(template_name, **context):
current_app.update_template_context(context)
t = current_app.jinja_env.get_template(template_name)
rv = t.stream(context)
rv.enable_buffering(5)
return rv
