def load_jupyter_server_extension(server_app):
web_app = server_app.web_app
jenv_opt = {"autoescape": True}
env = Environment(loader=FileSystemLoader(str(TEMPLATE_ROOT)),
extensions=['jinja2.ext.i18n'],
**jenv_opt)
web_app.settings['voila_jinja2_env'] = env
nbui = gettext.translation('nbui',
localedir=str(ROOT / 'i18n'),
fallback=True)
env.install_gettext_translations(nbui, newstyle=False)
host_pattern = '.*$'
base_url = url_path_join(web_app.settings['base_url'])
web_app.add_handlers(
host_pattern,
[
(url_path_join(base_url,
'/voila/render' + path_regex), VoilaHandler),
# (url_path_join(base_url, '/voila/watchdog' + path_regex), WatchDogHandler),
(url_path_join(base_url, '/voila'), VoilaTreeHandler),
(url_path_join(base_url,
'/voila/tree' + path_regex), VoilaTreeHandler),
(url_path_join(base_url, '/voila/static/(.*)'),
tornado.web.StaticFileHandler, {
'path': str(STATIC_ROOT)
})
])
def _web_template(self, config, tpl_names, elems=None, ext='html'):
# FIXME: would be nice to rename html folder to web
theme_path = os.path.join(config.data_directory('html_theme'), 'html')
plugin_path = os.path.join(config.data_directory('html_theme'),
'plugins')
templatepaths = [theme_path, plugin_path]
env = Environment(loader=FileSystemLoader(templatepaths),
autoescape=True,
extensions=[
'jinja2.ext.i18n', 'jinja2.ext.with_',
'jinja2.ext.do',
'mailpile.jinjaextensions.MailpileCommand'
])
env.install_gettext_translations(config.get_i18n_translation(),
newstyle=True)
env.session = Session(config)
env.session.ui = HttpUserInteraction(None, config)
for tpl_name in tpl_names:
try:
fn = '%s.%s' % (tpl_name, ext)
# FIXME(Security): Here we need to sanitize the file name
# very strictly in case it somehow came
# from user data.
return env.get_template(fn)
except (IOError, OSError, AttributeError), e:
pass
def render_j2_template(config, template, data, locale_=None):
"""
render Jinja2 template
:param config: dict of configuration
:param template: template (relative path)
:param data: dict of data
:param locale_: the requested output Locale
:returns: string of rendered template
"""
custom_templates = False
try:
templates_path = config['server']['templates']['path']
env = Environment(loader=FileSystemLoader(templates_path),
extensions=['jinja2.ext.i18n',
'jinja2.ext.autoescape'],
autoescape=select_autoescape(['html', 'xml']))
custom_templates = True
LOGGER.debug('using custom templates: {}'.format(templates_path))
except (KeyError, TypeError):
env = Environment(loader=FileSystemLoader(TEMPLATES),
extensions=['jinja2.ext.i18n',
'jinja2.ext.autoescape'],
autoescape=select_autoescape(['html', 'xml']))
LOGGER.debug('using default templates: {}'.format(TEMPLATES))
env.filters['to_json'] = to_json
env.filters['format_datetime'] = format_datetime
env.filters['format_duration'] = format_duration
env.filters['human_size'] = human_size
env.globals.update(to_json=to_json)
env.filters['get_path_basename'] = get_path_basename
env.globals.update(get_path_basename=get_path_basename)
env.filters['get_breadcrumbs'] = get_breadcrumbs
env.globals.update(get_breadcrumbs=get_breadcrumbs)
env.filters['filter_dict_by_key_value'] = filter_dict_by_key_value
env.globals.update(filter_dict_by_key_value=filter_dict_by_key_value)
translations = Translations.load('locale', [locale_])
env.install_gettext_translations(translations)
try:
template = env.get_template(template)
except TemplateNotFound as err:
if custom_templates:
LOGGER.debug(err)
LOGGER.debug('Custom template not found; using default')
env = Environment(loader=FileSystemLoader(TEMPLATES),
extensions=['jinja2.ext.i18n'])
template = env.get_template(template)
else:
raise
return template.render(config=l10n.translate_struct(config, locale_, True),
data=data, locale=locale_, version=__version__)
def render(template_name , **params ):
"""
Provide a universal method for web page generating.
All the template local parameter should be provided by "**params"
"""
template_dir = webnode.config.get('template_dir')
jinja2_env = Environment(
loader=FileSystemLoader(template_dir),
extensions=['jinja2.ext.i18n'])
locale_dir=webnode.config.get('locale_dir')
lang=params.get('lang','zh_CN')
jinja2_env.install_gettext_translations(
gettext.translation('site', locale_dir, languages=[lang]))
template = jinja2_env.get_template( '%s.jinja2' % template_name )
jinjia2_ext={
"jsondumps":json.dumps
}
return template.render(
params,
ext=jinjia2_ext,
public_root='/public'
)
def render(template_name, extra_environments=None, **kwargs):
"""Render the given template with jinja
:param template_name:
:return:
"""
if extra_environments is None:
extra_environments = {}
default_loader = PackageLoader('dodotable', 'templates')
loader = extra_environments.get(
'template_loader',
default_loader)
if not loader:
loader = default_loader
get_translations = extra_environments.get('get_translations')
env = Environment(loader=loader,
extensions=['jinja2.ext.i18n', 'jinja2.ext.with_'],
autoescape=True)
env.globals.update(extra_environments)
translations = get_translations() if callable(get_translations) else None
if translations is None:
translations = gettext.NullTranslations()
env.install_gettext_translations(translations)
template = env.get_template(template_name)
return template.render(**kwargs)
def _confirm_send_action(self, widget, text, method, params=None):
if params is None:
params = {}
buttons = [{
"name": _("Continue"),
"response": Gtk.ResponseType.OK
}, {
"name": _("Cancel"),
"response": Gtk.ResponseType.CANCEL
}]
try:
env = Environment(extensions=["jinja2.ext.i18n"], autoescape=True)
env.install_gettext_translations(self.lang)
j2_temp = env.from_string(text)
text = j2_temp.render()
except Exception as e:
logging.debug(f"Error parsing jinja for confirm_send_action\n{e}")
label = Gtk.Label()
label.set_markup(text)
label.set_hexpand(True)
label.set_halign(Gtk.Align.CENTER)
label.set_vexpand(True)
label.set_valign(Gtk.Align.CENTER)
label.set_line_wrap(True)
label.set_line_wrap_mode(Pango.WrapMode.WORD_CHAR)
if self.confirm is not None:
self.confirm.destroy()
self.confirm = self.gtk.Dialog(self, buttons, label,
self._confirm_send_action_response,
method, params)
def environment(**options):
"""Get jinja2 environment.
:param options: Options
:return env: return environment instance
"""
env = Environment(**options)
env.globals.update({
'static': staticfiles_storage.url,
'url': reverse,
'LANGUAGES': settings.LANGUAGES,
'translation': translation,
})
# add django filters
env.filters['slugify'] = slugify
# use django-bootstrap-form on jinja
from bootstrapform.templatetags import bootstrap
env.filters['bootstrap'] = bootstrap.bootstrap
env.filters['bootstrap_horizontal'] = bootstrap.bootstrap_horizontal
env.filters['bootstrap_inline'] = bootstrap.bootstrap_inline
# add custom filters
env.filters['fupper'] = fupper
env.install_gettext_translations(translation)
return env
def build_environment(template):
"""Create environment with newstyle gettext and autoescape"""
env = Environment(autoescape=True,
loader=DictLoader({'tmpl.html': template}),
extensions=['puente.ext.i18n', 'jinja2.ext.autoescape'])
env.install_gettext_translations(translation, newstyle=True)
return env
def environment(**options):
env = Environment(**options)
env.install_gettext_translations(translation, newstyle=True)
from .templatetags.borgcube import get_url, field_name, compression_name, summarize_archive, job_outcome, format_timedelta, json, describe_recurrence
from django.utils.html import escapejs
from django.template.defaultfilters import linebreaks, linebreaksbr, yesno
env.filters.update({
'get_url': get_url, # TODO: remove
'field_name': field_name,
'compression_name': compression_name,
'summarize_archive': summarize_archive,
'job_outcome': job_outcome,
'format_timedelta': format_timedelta,
'json': json,
'describe_recurrence': describe_recurrence,
'escapejs': escapejs,
'linebreaks': linebreaks,
'linebreaksbr': linebreaksbr,
'yesno': yesno,
})
hook.borgcube_web_jinja_env(env=env)
return env
def render(template_name , **params ):
"""
Provide a universal method for web page generating.
All the template local parameter should be provided by "**params"
"""
template_dir = params.get('template_dir',webnode.config.get('template_dir'))
jinja2_env = Environment(
loader=FileSystemLoader(template_dir),
extensions=['jinja2.ext.i18n'])
locale_dir=webnode.config.get('locale_dir')
lang=params.get('lang','zh_CN')
jinja2_env.install_gettext_translations(
gettext.translation('site', locale_dir, languages=[lang]))
template = jinja2_env.get_template( '%s.jinja2' % template_name )
jinjia2_ext={
"jsondumps":json.dumps
}
return template.render(
params,
ext=jinjia2_ext,
public_root='/public'
)
def render(template_name, extra_environments=None, **kwargs):
"""주어진 템플릿을 jinja로 렌더링합니다
:param template_name:
:return:
"""
if extra_environments is None:
extra_environments = {}
default_loader = PackageLoader('dodotable', 'templates')
loader = extra_environments.get(
'template_loader',
default_loader)
if not loader:
loader = default_loader
get_translations = extra_environments.get('get_translations')
env = Environment(loader=loader,
extensions=['jinja2.ext.i18n', 'jinja2.ext.with_'],
autoescape=True)
env.globals.update(extra_environments)
translations = get_translations() if callable(get_translations) else None
if translations is None:
translations = gettext.NullTranslations()
env.install_gettext_translations(translations)
template = env.get_template(template_name)
return template.render(**kwargs)
def environment(**options):
options.pop('debug', None)
options.setdefault('trim_blocks', True)
options.setdefault('lstrip_blocks', True)
env = Environment(**options)
env.globals.update(
static=staticfiles_storage.url,
url=reverse,
# Security
salt_attr=salt_attr,
salt_tag=salt_tag,
salt=salt,
# Platform functions
social_icons=social_icons,
footer_data=lambda: fragment('global.footer', raises=False),
service_worker=getattr(settings, 'SERVICE_WORKER', False),
context=context,
# Hyperpython tag functions
render=non_strict_render,
**TAG_MAP,
)
env.filters.update(
markdown=lambda x: Markup(markdown(x)),
pc=format_percent,
salt=salt,
)
env.install_gettext_translations(translation, newstyle=True)
return env
def render(path, params={}, locale=None, html=False):
"""
Render a template with parameters but get the owner from the beagleboy
settings file (can be overwritten)
"""
# Load the template from the emails environment of beagle
env = Environment(loader=PackageLoader('beaglemail', 'templates'),
extensions=['jinja2.ext.i18n'])
# If locale has been provided we install the translation else we provide
# a null translation
if locale:
translation = gettext.translation('beagle', '../locale',
languages=[locale],
fallback=True)
else:
translation = gettext.NullTranslations()
env.install_gettext_translations(translation)
# Get the template from the path
template = env.get_template(path)
# Render the plain content version
plain_content = template.render(params)
# If html is set we add (overwrite) the output parameter with 'html'
# and generate the html version. Return a tuple of both
if html:
params['output'] = 'html'
return (plain_content, template.render(params))
# If we get here we just return the plain content
return plain_content
def environment(**options):
env = Environment(**options)
env.install_gettext_translations(translation)
env.globals.update({
'STATIC_URL': settings.STATIC_URL
})
return env
def environment(**options: Any) -> Environment:
env = Environment(**options)
env.globals.update(
# default_page_params is provided here for responses where
# zulip_default_context is not run, including the 404.html and
# 500.html error pages.
default_page_params=DEFAULT_PAGE_PARAMS,
static=staticfiles_storage.url,
url=reverse,
render_markdown_path=render_markdown_path,
webpack_entry=webpack_entry,
)
env.install_gettext_translations(translation, True) # type: ignore[attr-defined] # Added by jinja2.ext.i18n
env.filters["slugify"] = slugify
env.filters["pluralize"] = pluralize
env.filters["display_list"] = display_list
env.filters["device_action"] = device_action
env.filters["timesince"] = timesince
env.policies["json.dumps_function"] = json_dumps
env.policies["json.dumps_kwargs"] = {}
return env
def create_menu_items(self):
for i in range(len(self.items)):
key = list(self.items[i])[0]
item = self.items[i][key]
env = Environment(extensions=["jinja2.ext.i18n"])
env.install_gettext_translations(self.lang)
j2_temp = env.from_string(item['name'])
parsed_name = j2_temp.render()
b = self._gtk.ButtonImage(item['icon'], parsed_name,
"color" + str((i % 4) + 1))
if item['panel'] is not False:
b.connect("clicked", self.menu_item_clicked, item['panel'],
item)
elif item['method'] is not False:
params = item['params'] if item['params'] is not False else {}
if item['confirm'] is not False:
b.connect("clicked", self._screen._confirm_send_action,
item['confirm'], item['method'], params)
else:
b.connect("clicked", self._screen._send_action,
item['method'], params)
else:
b.connect("clicked", self._screen._go_to_submenu, key)
self.labels[key] = b
def build_environment(self):
if getattr(sys, 'frozen', False):
if sys.platform == "darwin":
print_dir = os.path.join(sys._MEIPASS, "..", 'Resources',
"print")
else:
print_dir = os.path.join(sys._MEIPASS, "print")
else:
print_dir = os.path.realpath(
os.path.join(os.path.dirname(__file__), "..", "..", "print"))
template_dir = os.path.join(print_dir, "templates")
env = Environment(loader=FileSystemLoader(template_dir),
autoescape=select_autoescape(['html', 'xml']),
extensions=['jinja2.ext.i18n'])
env.filters['datetimeformat'] = datetimeformat
env.install_gettext_translations(inkstitch_translation)
languages_with_style = []
languages = get_languages()
for lang in languages:
css_file = "%s.css" % lang
if os.path.isfile(os.path.join(print_dir, "resources", css_file)):
languages_with_style.append(lang)
env.languages = languages_with_style
return env
def _confirm_send_action(self, widget, text, method, params={}):
_ = self.lang.gettext
buttons = [{
"name": _("Continue"),
"response": Gtk.ResponseType.OK
}, {
"name": _("Cancel"),
"response": Gtk.ResponseType.CANCEL
}]
try:
env = Environment(extensions=["jinja2.ext.i18n"])
env.install_gettext_translations(self.lang)
j2_temp = env.from_string(text)
text = j2_temp.render()
except:
logger.debug("Error parsing jinja for confirm_send_action")
label = Gtk.Label()
label.set_markup(text)
label.set_hexpand(True)
label.set_halign(Gtk.Align.CENTER)
label.set_line_wrap(True)
label.set_line_wrap_mode(Pango.WrapMode.WORD_CHAR)
dialog = self.gtk.Dialog(self, buttons, label,
self._confirm_send_action_response, method,
params)
def environment(**options):
env = Environment(**options)
env.install_gettext_translations(translation)
env.globals.update({
'static': staticfiles_storage.url,
'url': reverse,
})
return env
def load_jupyter_server_extension(server_app):
web_app = server_app.web_app
nbconvert_template_paths = []
static_paths = [STATIC_ROOT]
template_paths = []
# common configuration options between the server extension and the application
voila_configuration = VoilaConfiguration(parent=server_app)
collect_template_paths(nbconvert_template_paths, static_paths,
template_paths, voila_configuration.template)
jenv_opt = {"autoescape": True}
env = Environment(loader=FileSystemLoader(template_paths),
extensions=['jinja2.ext.i18n'],
**jenv_opt)
web_app.settings['voila_jinja2_env'] = env
nbui = gettext.translation('nbui',
localedir=os.path.join(ROOT, 'i18n'),
fallback=True)
env.install_gettext_translations(nbui, newstyle=False)
host_pattern = '.*$'
base_url = url_path_join(web_app.settings['base_url'])
# First look into 'nbextensions_path' configuration key (classic notebook)
# and fall back to default path for nbextensions (jupyter server).
if 'nbextensions_path' in web_app.settings:
nbextensions_path = web_app.settings['nbextensions_path']
else:
nbextensions_path = jupyter_path('nbextensions')
web_app.add_handlers(
host_pattern,
[
(url_path_join(
base_url, '/voila/render' + path_regex), VoilaHandler, {
'config': server_app.config,
'nbconvert_template_paths': nbconvert_template_paths,
'voila_configuration': voila_configuration
}),
(url_path_join(base_url, '/voila'), VoilaTreeHandler),
(url_path_join(base_url,
'/voila/tree' + path_regex), VoilaTreeHandler),
(url_path_join(base_url,
'/voila/static/(.*)'), MultiStaticFileHandler, {
'paths': static_paths
}),
# this handler serves the nbextensions similar to the classical notebook
(
url_path_join(base_url, r'/voila/nbextensions/(.*)'),
FileFindHandler,
{
'path': nbextensions_path,
'no_cache_paths':
['/'], # don't cache anything in nbextensions
},
)
])
def build_environment():
env = Environment(loader=FileSystemLoader(template_path),
autoescape=True,
extensions=['jinja2.ext.i18n'])
env.install_gettext_translations(current_translation)
env.globals["locale"] = current_locale
return env
def init_environment(self):
env = Environment(loader=FileSystemLoader(searchpath='web/views/'),
extensions=['pyjade.ext.jinja.PyJadeExtension',
'jinja2.ext.i18n'])
translations = translation(domain='messages',
localedir='./web/i18n/locale',
languages=[self.default_language])
env.install_gettext_translations(translations)
return env
def environment(**options):
env = Environment(**options, extensions=['jinja2.ext.i18n'])
env.autoescape = True
env.install_gettext_translations(translation, newstyle=True)
env.globals.update(context['globals'])
env.filters.update(context['filters'])
return env
def build_environment(template):
"""Create environment with newstyle gettext"""
env = Environment(
autoescape=True,
loader=DictLoader({"tmpl.html": template}),
extensions=["puente.ext.i18n"],
)
env.install_gettext_translations(translation, newstyle=True)
return env
def environment(**options):
env = Environment(extensions=['jinja2.ext.i18n', 'jinja2.ext.with_'],
**options)
env.install_gettext_translations(translation)
env.globals.update({
'static': static,
'url': reverse,
})
return env
def environment(**options):
options["extensions"] += ["jinja2.ext.i18n"]
env = Environment(**options)
env.install_gettext_translations(translation)
env.globals.update({
'static': static,
'url': reverse,
'datetime': datetime
})
return env
def environment(**options):
_load_django_default_filters()
_load_templatetags()
env = Environment(**options)
env.globals.update(_local_env['globals'])
env.filters.update(_local_env['filters'])
env.tests.update(_local_env['tests'])
env.install_gettext_translations(translation)
return env
def set_title(self, title):
try:
env = Environment(extensions=["jinja2.ext.i18n"])
env.install_gettext_translations(self.lang)
j2_temp = env.from_string(title)
title = j2_temp.render()
except Exception:
logging.debug("Error parsing jinja for title: %s" % title)
self.titlelbl.set_label("%s | %s" % (self._screen.connected_printer, title))
def __init__(self, screen, title, back=True):
self._screen = screen
self._config = screen._config
self._files = screen.files
self.lang = self._screen.lang
self._printer = screen.printer
self.labels = {}
self._gtk = screen.gtk
self.layout = Gtk.Layout()
self.layout.set_size(self._screen.width, self._screen.height)
button_scale = self._gtk.get_header_image_scale()
logger.debug("Button scale: %s" % button_scale)
if back == True:
self.control['back'] = self._gtk.ButtonImage(
'back', None, None, button_scale[0], button_scale[1])
self.control['back'].connect("clicked", self._screen._menu_go_back)
self.layout.put(self.control['back'], 0, 0)
self.control['home'] = self._gtk.ButtonImage(
'home', None, None, button_scale[0], button_scale[1])
self.control['home'].connect("clicked", self.menu_return, True)
self.layout.put(
self.control['home'], self._screen.width -
round(self._gtk.get_image_width() * button_scale[0] * 1.45), 0)
self.control['estop'] = self._gtk.ButtonImage('emergency', None, None,
button_scale[0],
button_scale[1])
self.control['estop'].connect("clicked", self.emergency_stop)
self.layout.put(self.control['estop'],
int(self._screen.width / 4 * 3 - button_scale[0] / 2),
0)
try:
env = Environment(extensions=["jinja2.ext.i18n"])
env.install_gettext_translations(self.lang)
j2_temp = env.from_string(title)
title = j2_temp.render()
except:
logger.debug("Error parsing jinja for title: %s" % title)
self.title = Gtk.Label()
self.title.set_size_request(self._screen.width, self.title_spacing)
self.title.set_hexpand(True)
self.title.set_halign(Gtk.Align.CENTER)
self.title.set_valign(Gtk.Align.CENTER)
self.set_title(title)
self.layout.put(self.title, 0, 0)
self.content = Gtk.Box(spacing=0)
self.content.set_size_request(self._screen.width,
self._screen.height - self.title_spacing)
self.layout.put(self.content, 0, self.title_spacing)
def environment(**options):
#env = Environment(**options)
env = Environment(extensions=['jinja2.ext.i18n'], **options)
env.globals.update({
'static': staticfiles_storage.url,
'url': reverse,
})
env.install_gettext_translations(translation)
#env.install_gettext_translations(translation)
#Environment.install_gettext_translations(translation)
return env
def set_title(self, title):
try:
env = Environment(extensions=["jinja2.ext.i18n"], autoescape=True)
env.install_gettext_translations(self.lang)
j2_temp = env.from_string(title)
title = j2_temp.render()
except Exception as e:
logging.debug(f"Error parsing jinja for title: {title}\n{e}")
self.titlelbl.set_label(
f"{self._screen.connecting_to_printer} | {title}")
def build_environment(template):
"""Create environment with newstyle gettext and autoescape"""
env = Environment(
autoescape=True,
loader=DictLoader({'tmpl.html': template}),
extensions=[
'puente.ext.i18n',
'jinja2.ext.autoescape'
]
)
env.install_gettext_translations(translation, newstyle=True)
return env
def create_environment(theme_path, language):
loader = FileSystemLoader(searchpath=theme_path, encoding='utf-8')
environment = Environment(loader=loader, extensions=['jinja2.ext.i18n'])
translations = Translations.load(paths.get_locale_path(), language)
environment.install_gettext_translations(translations)
# global functions available in the templates
environment.globals.update(get_language_name=locale.get_language_name)
return environment
def create_jinja2_environment(language):
env = Environment(loader=FileSystemLoader('layouts'),
extensions=['jinja2.ext.i18n'])
if language == 'ru':
translations = gettext.GNUTranslations(open('messages.mo'))
env.install_gettext_translations(translations, newstyle=True)
elif language == 'en':
env.install_null_translations(newstyle=False)
env.globals.update(url_for=url_for, LANGUAGE=language)
return env
def render(template_name, model, template_dirs=[]): import django_trans_patch as translation from jinja2 import Environment from jinja2 import FileSystemLoader from jinja2 import TemplateNotFound env = Environment( loader = FileSystemLoader(template_dirs), extensions=['jinja2.ext.i18n']) env.install_gettext_translations(translation) try: template = env.get_template(template_name) except TemplateNotFound: raise TemplateNotFound(template_name) result = template.render(model) return result
def render_template2(template, template_vars):
"""convenience function to render template in a non-Flask context"""
loader_dir = os.path.join(os.path.dirname(__file__), 'templates')
loader = FileSystemLoader(loader_dir)
env = Environment(loader=loader, extensions=['jinja2.ext.i18n'])
translations_dir = os.path.join(os.path.dirname(__file__), 'translations')
translations = translation('messages', translations_dir, fallback=True)
env.install_gettext_translations(translations)
template_obj = env.get_template(template)
return template_obj.render(template_vars)
def environment(**options):
options['extensions'] = ['jinja2.ext.i18n', 'jinja2.ext.with_']
env = Environment(**options)
env.globals.update({
'static': staticfiles_storage.url,
'url': reverse,
'LANGUAGES': settings.LANGUAGES,
'CUR_LANGUAGE': translation.get_language(),
})
env.install_gettext_translations(translation, newstyle=True)
return env
def __build_jinja_env(language):
template_path = os.path.join(os.path.dirname(__file__), '..', 'templates')
locale_path = os.path.join(os.path.dirname(__file__), '..', 'locale')
translations = gettext.translation('messages',
locale_path,
languages=[language])
env = Environment(loader=FileSystemLoader(template_path),
extensions=['jinja2.ext.i18n'])
env.install_gettext_translations(translations)
return env
def render_template2(template, template_vars):
"""convenience function to render template in a non-Flask context"""
loader_dir = os.path.join(os.path.dirname(__file__), 'templates')
loader = FileSystemLoader(loader_dir)
env = Environment(loader=loader, extensions=['jinja2.ext.i18n'])
translations_dir = os.path.join(os.path.dirname(__file__), 'translations')
translations = translation('messages', translations_dir, fallback=True)
env.install_gettext_translations(translations)
template_obj = env.get_template(template)
return template_obj.render(template_vars)
def get_lims_environment(cls):
extensions = [
'jinja2.ext.i18n', 'jinja2.ext.autoescape', 'jinja2.ext.with_',
'jinja2.ext.loopcontrols', 'jinja2.ext.do'
]
env = Environment(extensions=extensions,
loader=FunctionLoader(lambda name: ''))
env.filters.update(cls.get_lims_filters())
locale = Transaction().context.get('locale').split('_')[0]
translations = TemplateTranslations(locale)
env.install_gettext_translations(translations)
return env
def environment(**options):
"""
Setup Jinja2 environment:
"""
# Init environment
env = Environment(**options)
# Use template with some common context
env.template_class = ContextTemplate
# Add our custom filters
env.filters.update(
{
"addcss": addcss,
"total_time": total_time,
"convert_speed": convert_speed,
"convert_speed_kmh": convert_speed_kmh,
"total_distance": total_distance,
}
)
# Add constants from settings
keys = [
"DEBUG",
"PIWIK_HOST",
"PIWIK_ID",
"FACEBOOK_ID",
"LANGUAGES",
"PAYMILL_PUBLIC",
"HELP_URL",
"PAYMENTS_ENABLED",
"VERSION",
]
env.globals.update(dict([(k, getattr(settings, k, None)) for k in keys]))
# Setup translations
translation = import_module("django.utils.translation")
env.install_gettext_translations(translation, newstyle=False)
# In Prod, skip auto_reload
# and setup bytecode cache
if not settings.DEBUG:
env.auto_reload = False
cache_dir = os.path.join(settings.HOME, "templates_cached")
if not os.path.exists(cache_dir):
os.mkdir(cache_dir)
env.bytecode_cache = FileSystemBytecodeCache(cache_dir, "rr.%s.cache")
return env
def environment(**options):
env = Environment(**options)
env.globals.update({
'static': staticfiles_storage.url,
'url': reverse,
'minified_js': minified_js,
})
env.install_gettext_translations(translation, True)
env.filters['slugify'] = slugify
env.filters['pluralize'] = pluralize
env.filters['display_list'] = display_list
return env
def environment(**options):
env = Environment(**options)
env.globals.update({
'static': staticfiles_storage.url,
'url': reverse,
'compressed_css': compressed_css,
'minified_js': minified_js,
})
env.install_gettext_translations(translation)
env.filters['slugify'] = slugify
env.filters['pluralize'] = pluralize
return env
def create_jinja2_environment(language):
env = Environment(loader=FileSystemLoader('layouts'),
extensions=['jinja2.ext.i18n'])
if language == 'ru':
translations = gettext.GNUTranslations(open('messages.mo'))
env.install_gettext_translations(translations, newstyle=True)
# Hack:
globals_gettext = env.globals['gettext']
env.globals['gettext'] = contextfunction(
lambda context, s: unicode(globals_gettext(context, s).decode('utf-8')))
elif language == 'en':
env.install_null_translations(newstyle=False)
env.globals.update(url_for=url_for, LANGUAGE=language)
return env
def render(template_name, model): import django_trans_patch as translation from jinja2 import Environment from jinja2 import FileSystemLoader from jinja2 import TemplateNotFound template_dirs = [ os.path.dirname(__file__), os.path.join(os.path.dirname(__file__), 'views'), os.path.join(os.path.dirname(__file__), '..'), os.path.join(os.path.dirname(__file__), '../views')] env = Environment( loader = FileSystemLoader(template_dirs), extensions=['jinja2.ext.i18n']) env.install_gettext_translations(translation) try: template = env.get_template(template_name) except TemplateNotFound: raise TemplateNotFound(template_name) return template.render(model)
def _html_template(self, config, tpl_names, elems=None):
theme_path = os.path.join(config.data_directory('html_theme'), 'html')
env = Environment(loader=FileSystemLoader('%s' % theme_path),
extensions=['jinja2.ext.i18n', 'jinja2.ext.with_',
'mailpile.jinjaextensions.MailpileCommand'])
env.install_gettext_translations(config.get_i18n_translation(), newstyle=True)
env.session = Session(config)
env.session.ui = HttpUserInteraction(None, config)
for tpl_name in tpl_names:
try:
fn = '%s.html' % tpl_name
# FIXME(Security): Here we need to sanitize the file name very
# strictly in case it somehow came from user
# data.
return env.get_template(fn)
except (IOError, OSError, AttributeError), e:
pass
def HTML \
( version = "html/5.jnj"
, load_path = ()
, loader = None
, globals = {}
, encoding = "utf-8"
, i18n = False
, Media_Parameters = None
, GTW = None
, prefixes = {}
, ** kw
) :
jnj_loader = FileSystemLoader (sos.path.dirname (__file__), "utf-8")
loaders = []
if loader :
loaders.append (loader)
if load_path :
loaders.append (FileSystemLoader (load_path, encoding))
loaders.append (jnj_loader)
if prefixes :
sk = lambda x : (- len (x [1]), x [1])
for prefix, lp in sorted (pyk.iteritems (prefixes), key = sk) :
loaders.append \
( PrefixLoader
({prefix : FileSystemLoader (lp, encoding)}, delimiter='::')
)
loaders.append (PrefixLoader (dict (STD = jnj_loader), delimiter='::'))
loader = ChoiceLoader (loaders)
extensions = (kw.pop ("extensions", []) + Default_Extensions)
if i18n :
extensions.append ("jinja2.ext.i18n")
result = Environment \
( extensions = uniq (extensions), loader = loader, ** kw)
if GTW is None :
GTW = JNJ.GTW (result)
result.globals.update \
( globals
, GTW = GTW
, html_version = version
)
result.Media_Parameters = Media_Parameters
result.encoding = encoding
result.static_handler = None
if i18n :
result.install_gettext_translations (TFL.I18N)
return result
def environment(**options: Any) -> Environment:
env = Environment(**options)
env.globals.update({
'static': staticfiles_storage.url,
'url': reverse,
'render_markdown_path': render_markdown_path,
'minified_js': minified_js,
})
env.install_gettext_translations(translation, True)
env.filters['slugify'] = slugify
env.filters['pluralize'] = pluralize
env.filters['display_list'] = display_list
env.filters['device_action'] = device_action
return env
def environment(**options):
# type: (**Any) -> Environment
env = Environment(**options)
env.globals.update({
'static': staticfiles_storage.url,
'url': reverse,
'minified_js': minified_js,
})
env.install_gettext_translations(translation, True) # type: ignore # https://github.com/python/typeshed/issues/927
env.filters['slugify'] = slugify
env.filters['pluralize'] = pluralize
env.filters['display_list'] = display_list
env.filters['render_markdown_path'] = render_markdown_path
return env
class Jinja2I18nHelper():
"""Demonstrates how to use jinja2 i18n engine to internationalize. A class-encapsulated version.
Language files reside under folder lang of the current file location.
"""
def __init__(self):
"""Sets up the i18n environment"""
# The current language, i.e., the default system language
self.current_locale, self.encoding = locale.getdefaultlocale() # tuple, e.g., ('en_US', 'UTF-8')
self.extensions = ['jinja2.ext.i18n', 'jinja2.ext.autoescape', 'jinja2.ext.with_']
# Specifies the language path (the i10n path), ./lang which holds all the translations
self.locale_dir = os.path.join(current_path, "lang")
self.template_dir = "web_ui" # template file root folder
self.loader = FileSystemLoader(self.template_dir)
self.env = Environment(extensions=self.extensions, loader=self.loader) # add any other env options if needed
#print("The current language is %s" % self.current_locale)
#print("The locale dir: %s" % self.locale_dir)
def refresh_env(self, locale_dir, template_dir):
"""Refreshes the locale environment by changing the locale directory and the temple file directory."""
self.locale_dir = locale_dir
self.template_dir = template_dir
self.loader = FileSystemLoader(self.template_dir)
self.env = Environment(extensions=self.extensions, loader=self.loader)
#print("The current path: %s" % current_path)
#print("The locale dir: %s" % self.locale_dir)
#print("The current language is %s" % self.current_locale)
def render(self, template_name, desired_lang):
"""Returns the rendered template with the desired language."""
if not desired_lang:
desired_lang = self.current_locale
# To test simplified Chinese only
#desired_lang = "zh_CN" # Simple Chinese
desired_locales_list = [desired_lang]
#print("Your desired language is %s" % desired_lang)
translations = Translations.load(self.locale_dir, desired_locales_list)
self.env.install_gettext_translations(translations)
template = self.env.get_template(template_name)
return template.render().encode('utf-8') # magic here & avoid error UnicodeEncodeError
def environment(**options):
env = Environment(**options)
env.globals.update({
'dir': dir,
'static': staticfiles_storage.url,
'url': reverse,
'get_providers': get_providers,
'user_display': user_display,
'json': json.dumps,
'int': int,
'escape': escape,
})
env.filters['as_ruby_tags'] = as_ruby_tags
env.install_gettext_translations(translation)
return env
class Renderer:
def __init__(self, content_dir='../../content/', output_dir='../../static/html'):
loader = FileSystemLoader(searchpath='templates')
self.defaults = {'translations': {}, 'sections': {'en': [], 'fr': []}}
self.env = Environment(loader=loader, extensions=['jinja2.ext.i18n'])
self.translations = {
'en': gettext.translation('jvk', 'locales', languages=['en']),
'fr': gettext.translation('jvk', 'locales', languages=['fr']),
}
self.env.install_null_translations()
self.queue = []
self.content_dir = content_dir
self.output_dir = output_dir
def read_content(self, source):
with open(self.content_dir + source) as content_file:
return content_file.read()
def add(self, path, *args, **kwargs):
if 'section' in kwargs and kwargs['section']:
lang = kwargs['lang']
section = {'href': path,
'title': kwargs['title']}
try:
section.update(kwargs['section'])
except:
pass
self.defaults['sections'][lang].append(section)
args = tuple([path]+list(args))
self.queue.append((args, kwargs))
def render_all(self):
for args, kwargs in self.queue:
if 'lang' in kwargs:
translations = self.translations[kwargs['lang']]
self.env.install_gettext_translations(translations)
self.render(*args, **kwargs)
def render(self, path, template, **kwargs):
kwargs = {**self.defaults, **kwargs}
page = self.env.get_template(template).render(path=path, **kwargs)
with open(self.output_dir + path + '.html', 'w') as out:
out.write(page)
def create_env():
"""Create a new Jinja2 environment."""
searchpath = list(settings.TEMPLATE_DIRS)
env = Environment(loader=FileSystemLoader(searchpath),
auto_reload=settings.TEMPLATE_DEBUG,
cache_size=getattr(settings, 'JINJA2_CACHE_SIZE', 50),
extensions=getattr(settings, 'JINJA2_EXTENSIONS', ()))
filters = getattr(settings, 'JINJA2_FILTERS', ())
globals = getattr(settings, 'JINJA2_GLOBALS', ())
env.filters.update(load_filters(filters))
env.globals.update(load_globals(globals))
try:
translations = gettext.translation(getattr(settings, 'GETTEXT_DOMAIN', 'django'),
getattr(settings, 'LOCALE_DIR', './locale/ '))
env.install_gettext_translations(translations)
except:
env.install_null_translations()
return env
def get_env():
"""
:return: A Jinja2 environment singleton.
"""
from django.conf import settings
if JINJA2_COMPILED_TEMPLATES:
if not os.path.exists(JINJA2_COMPILED_TEMPLATES):
os.mkdir(JINJA2_COMPILED_TEMPLATES)
bytecode_cache = FileSystemBytecodeCache(JINJA2_COMPILED_TEMPLATES, '%s.cache')
else:
bytecode_cache = None
auto_reload = JINJA2_CACHE_AUTO_RELOAD
cache_size = 1000 if JINJA2_CACHE_ACTIVE else 0
kwargs = {
'cache_size': cache_size,
'auto_reload': auto_reload,
'bytecode_cache': bytecode_cache,
'autoescape': False, # True
'render_value_in_context': render_value_in_context,
}
kwargs.update(getattr(settings, 'JINJA2_ENVIRONMENT_OPTIONS', {}))
result = Environment(**kwargs)
# Hook Jinja's i18n extension up to Django's translation backend
# if i18n is enabled; note that we differ here from Django, in that
# Django always has it's i18n functionality available (that is, if
# enabled in a template via {% load %}), but uses a null backend if
# the USE_I18N setting is disabled. Jinja2 provides something similar
# (install_null_translations), but instead we are currently not
# enabling the extension at all when USE_I18N=False.
# While this is basically an incompatibility with Django, currently
# the i18n tags work completely differently anyway, so for now, I
# don't think it matters.
if settings.USE_I18N:
from django.utils import translation
result.install_gettext_translations(translation)
return result
class Redirect():
"""Class to create the index.html to redirect to the preferred language"""
def __init__(self, app, locale_langcode):
print " - render redirect page to %s" % locale_langcode
htmlFile = "redirect.html"
self.app = app
self.locale_langcode = locale_langcode
self.env = Environment(extensions=['jinja2.ext.i18n',
'jinja2.ext.autoescape'],
loader=FileSystemLoader("templates"),
trim_blocks=True,
lstrip_blocks=True)
self.env.install_gettext_translations(self.app.translations)
indexTemplate = self.env.get_template(htmlFile)
code = indexTemplate.render(lang=locale_langcode)
fileOut = open(os.path.join(self.app.HTMLDIR, 'index.html'), "w")
if isinstance(code, unicode):
code = code.encode("utf-8")
fileOut.write(code)
fileOut.close()
def configure_env(self):
"""Configure template env
"""
searchpath = list(self.config.get("TEMPLATES_PATH", 'templates'))
env = Environment(loader=FileSystemLoader(searchpath),
auto_reload=self.config.get('TEMPLATE_DEBUG_RELOAD', False),
cache_size=self.config.get('JINJA2_CACHE_SIZE', 50),
extensions=self.config.get('JINJA2_EXTENSIONS', ()))
filters = self.config.get('JINJA2_FILTERS', ())
globals = self.config.get('JINJA2_GLOBALS', ())
env.filters.update(load_filters(filters))
env.globals.update(load_globals(globals))
try:
env.install_gettext_translations()
except Exception:
env.install_null_translations()
return env
def get_env():
"""Returns the Jinja2 environment, a singleton.
:return:
A ``jinja2.Environment`` instance.
"""
global _environment
if _environment is None:
templates_compiled_target = get_config(__name__,
'templates_compiled_target')
use_compiled = not get_config('tipfy', 'dev') or get_config(__name__,
'force_use_compiled')
if templates_compiled_target is not None and use_compiled:
# Use precompiled templates loaded from a module.
loader = ModuleLoader(templates_compiled_target)
else:
# Parse templates on every request.
loader = FileSystemLoader(get_config(__name__, 'templates_dir'))
# Initialize the environment.
_environment = Environment(loader=loader,
extensions=['jinja2.ext.i18n'])
# Add url_for() by default.
_environment.globals['url_for'] =url_for
try:
from tipfy.ext import i18n
# Install i18n, first forcing it to be loaded if not yet.
i18n.get_translations()
_environment.install_gettext_translations(i18n.translations)
_environment.globals.update({
'format_date': i18n.format_date,
'format_time': i18n.format_time,
'format_datetime': i18n.format_datetime,
})
except (ImportError, AttributeError), e:
pass
def _web_template(self, config, tpl_names, elems=None, ext='html'):
# FIXME: would be nice to rename html folder to web
theme_path = os.path.join(config.data_directory('html_theme'), 'html')
plugin_path = os.path.join(config.data_directory('html_theme'), 'plugins')
templatepaths = [theme_path, plugin_path]
env = Environment(loader=FileSystemLoader(templatepaths),
autoescape=True,
extensions=[
'jinja2.ext.i18n', 'jinja2.ext.with_',
'jinja2.ext.do',
'mailpile.jinjaextensions.MailpileCommand'])
env.install_gettext_translations(config.get_i18n_translation(),
newstyle=True)
env.session = Session(config)
env.session.ui = HttpUserInteraction(None, config)
for tpl_name in tpl_names:
try:
fn = '%s.%s' % (tpl_name, ext)
# FIXME(Security): Here we need to sanitize the file name
# very strictly in case it somehow came
# from user data.
return env.get_template(fn)
except (IOError, OSError, AttributeError), e:
pass
env.filters['path_make_relative'] = path_make_relative
env.filters['path_make_absolute'] = path_make_absolute
env.filters['decode'] = decode
env.filters['type'] = lambda x: str(type(x))
env.filters['formatsize'] = formatSize
env.filters['getitem'] = lambda x, y: x.__getitem__(y)
if PREFIX:
env.filters['url'] = lambda x: x
else:
env.filters['url'] = lambda x: PREFIX + x if x.startswith("/") else x
gettext.setpaths([join(os.sep, "usr", "share", "pyload", "locale"), None])
translation = gettext.translation("django", join(PYLOAD_DIR, "locale"),
languages=[config.get("general", "language"), "en"],fallback=True)
translation.install(True)
env.install_gettext_translations(translation)
from beaker.middleware import SessionMiddleware
session_opts = {
'session.type': 'file',
'session.cookie_expires': False,
'session.data_dir': './tmp',
'session.auto': False
}
web = StripPathMiddleware(SessionMiddleware(app(), session_opts))
web = GZipMiddleWare(web)
if PREFIX:
web = PrefixMiddleware(web, prefix=PREFIX)
class ChangeWithin(object):
"""
Class that process the OSC files
"""
def __init__(self, host=None, db=None, user=None, password=None):
"""
Initiliazes the class
:param host: Database host
:param db: Database name
:param user: Database user
:param password: Databse password
"""
self.conf = {}
self.env_vars = {}
self.handler = ChangeHandler()
self.osc_file = None
self.changesets = []
self.stats = {}
if host is not None and db is not None and user is not None and password is not None:
self.has_cache = True
self.handler.set_cache(host, db, user, password)
else:
self.has_cache = False
self.cache = None
self.jinja_env = Environment(extensions=['jinja2.ext.i18n'])
pkg_dir, this_filename = os.path.split(__file__)
self.text_tmpl = self.get_template(os.path.join(pkg_dir, 'templates', 'text_template.txt'))
self.html_tmpl = self.get_template(os.path.join(pkg_dir, 'templates', 'html_template.html'))
def initialize_db(self):
"""
Initializes the databse cache
:return:
"""
if self.has_cache:
self.cache.initialize()
def get_template(self, template_name):
"""
Returns the template
:param template_name: Template name as a string
:return: Template
"""
url = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'templates', template_name)
with open(url) as f:
template_text = f.read()
return self.jinja_env.from_string(template_text)
def load_config(self, config=None):
"""
Loads the configuration from the file
:config_file: Configuration as a dict
:return: None
"""
if not config:
self.env_vars = config_from_environment('bard', ['config'])
self.conf = ConfigObj(self.env_vars["config"])
else:
self.conf = config
languages = ['en']
if 'email' in self.conf and 'language' in self.conf['email']:
tmp = languages
tmp.append(self.conf['email']['language'])
languages = tmp
if "email" not in self.conf or "url_locales" not in self.conf["email"] :
dir_path = os.path.dirname(os.path.realpath(__file__))
url_locales = os.path.join(dir_path, '../locales')
else:
url_locales = self.conf["email"]["url_locales"]
lang = gettext.translation(
'messages',
localedir=url_locales,
languages=languages)
lang.install()
translations = gettext.translation(
'messages',
localedir=url_locales,
languages=languages)
self.jinja_env.install_gettext_translations(translations)
self.handler.set_bbox(*self.conf["area"]["bbox"])
for name in self.conf["tags"]:
key, value = self.conf["tags"][name]["tags"].split("=")
types = self.conf["tags"][name]["tags"].split(",")
self.stats["name"] = 0
self.handler.set_tags(name, key, value, types)
def process_file(self, filename=None):
"""
:param filename:
:return:
"""
if filename is None:
self.osc_file = get_osc()
self.handler.apply_file(self.osc_file,
osmium.osm.osm_entity_bits.CHANGESET)
else:
self.handler.apply_file(filename,
osmium.osm.osm_entity_bits.CHANGESET)
self.changesets = self.handler.changeset
self.stats = self.handler.stats
self.stats["total"] = len(self.changesets)
def report(self):
"""
Generates the report and sends it
:return: None
"""
from datetime import datetime
print ("self.changesets:{}".format(self.changesets))
if len(self.changesets) > 1000:
self.changesets = self.changesets[:999]
self.stats[
'limit_exceed'] = 'Note: For performance reasons only the first 1000 changesets are displayed.'
now = datetime.now()
for state in self.stats:
if state != "total":
self.stats[state] = len(set(self.stats[state]))
template_data = {
'changesets': self.changesets,
'stats': self.stats,
'date': now.strftime("%B %d, %Y"),
'tags': self.conf['tags'].keys()
}
html_version = self.html_tmpl.render(**template_data)
text_version = self.text_tmpl.render(**template_data)
if 'domain' in self.conf['mailgun'] and 'api_key' in self.conf['mailgun']:
if "api_url" in self.conf["mailgun"]:
url = self.conf["mailgun"]["api_url"]
else:
url = 'https://api.mailgun.net/v3/{0}/messages'.format(
self.conf['mailgun']['domain'])
resp = requests.post(
url,
auth=("api", self.conf['mailgun']['api_key']),
data={"from": "OSM Changes <mailgun@{}>".format(
self.conf['mailgun']['domain']),
"to": self.conf["email"]["recipients"].split(),
"subject": 'OSM building and address changes {0}'.format(
now.strftime("%B %d, %Y")),
"text": text_version,
"html": html_version})
print("response:{}".format(resp.status_code))
print("mailgun response:{}".format(resp.content))
file_name = 'osm_change_report_{0}.html'.format(
now.strftime('%m-%d-%y'))
f_out = open(file_name, 'w')
f_out.write(html_version.encode('utf-8'))
f_out.close()
print('Wrote {0}'.format(file_name))
