def __init__(
self,
path,
settings,
package=None,
template_class=None,
):
self.path = path
self.settings = settings
self.package = package
self.template_class = template_class
self.default_domain = self.settings.get('genshi.default_domain')
auto_reload = asbool(self.settings.get('genshi.auto_reload', True))
self.loader = TemplateLoader(
self._load_asset,
callback=self._tmpl_loaded,
auto_reload=auto_reload,
)
# should we enable i18n?
i18n = asbool(self.settings.get('genshi.i18n', True))
if i18n:
self.adaptor = TranslationStringAdaptor(
self.localizer.translate,
self.localizer.pluralize,
default_domain=self.default_domain)
self.translator = Translator(self.adaptor)
# no i18n available, just use translator with NullTranslations
else:
self.translator = Translator()
def process_dir(dirpath, filenames, projects):
'''
Process a directory
'''
translations = GNUTranslations(
open(os.path.join(options.podir, options.lang + '.mo')))
loader = TemplateLoader(['.'],
callback=lambda template: template.filters.insert(
0, Translator(translations.ugettext)))
for fn in filenames:
if fn.endswith('~') or fn.endswith('.swp'):
continue
src_file = os.path.join(dirpath, fn)
dest_file = os.path.join(
options.output,
src_file[len(options.input):]) + '.' + options.lang # Hideous
curpage = src_file[len(options.input):].rstrip('.html')
relpath = '../' * (dest_file.count('/') - 1)
relpath = relpath.rstrip('/')
if relpath == '': relpath = '.'
if not os.path.exists(os.path.dirname(dest_file)):
os.makedirs(os.path.dirname(dest_file))
template = loader.load(src_file)
# Variables made availble to all templates
page = template.generate(
_=lambda text: Markup(translations.ugettext(text)),
lang=options.lang,
path=options.basepath,
relpath=relpath,
curpage=curpage,
projects=projects).render(method='html', doctype='html')
output = open(dest_file, 'w')
output.write(page)
output.close()
def __init__(self,
path,
lookup,
macro=None,
logger=None,
template_class=None):
self.logger = logger or logging.getLogger(__name__)
self.path = path
self.lookup = lookup
self.template_class = template_class
# XXX: This is dirty
self.settings = {}
registry = get_current_registry()
if registry is not None:
self.settings = registry.settings
self.default_domain = self.settings.get('genshi.default_domain')
# the i18n is available
if lookup.translate is not None:
# XXX: This is a very dirty hack, too
# but this is how Pyramid does - getting request from local thread
# IChameleonLookup doesn't provide pluralize there, so we need to
# get by it ourself
pluralize = None
if hasattr(lookup, 'pluralize'):
# pluralize should be added to the lookup, but it is not there
# see will it be there in the future
# this is mainly for test right now
pluralize = lookup.pluralize
else:
request = get_current_request()
if request is not None:
pluralize = get_localizer(request).pluralize
self.adaptor = TranslationStringAdaptor(
lookup.translate,
pluralize,
default_domain=self.default_domain)
self._translator = Translator(self.adaptor)
# no i18n available, just use translator with NullTranslations
else:
self._translator = Translator()
auto_reload = self.settings.get('genshi.auto_reload', True)
self._loader = TemplateLoader(callback=self._tmpl_loaded,
auto_reload=auto_reload)
def template_loaded(template):
"""Plug-in our i18n function to Genshi, once the template is loaded.
This function will be called by genshi TemplateLoader after
loading the template.
"""
template.filters.insert(0, Translator(ugettext))
def _add_translation_hook(cls, relatorio_report, context):
pool = Pool()
Translation = pool.get('ir.translation')
translate = TranslateFactory(cls.__name__,
Transaction().language, Translation)
context['set_lang'] = lambda language: translate.set_language(language)
translator = Translator(lambda text: translate(text))
relatorio_report.filters.insert(0, translator)
def template_loaded(template):
"""Plug-in our i18n function to Genshi, once the template is loaded.
This function will be called by the Genshi TemplateLoader after
loading the template.
"""
translator = Translator(ugettext)
template.filters.insert(0, translator)
if hasattr(template, 'add_directives'):
template.add_directives(Translator.NAMESPACE, translator)
def _callback_loader(cls, report, template):
if report.translatable:
pool = Pool()
Translation = pool.get('ir.translation')
translate = TranslateFactory(cls.__name__, Translation)
translator = Translator(lambda text: translate(text))
# Do not use Translator.setup to add filter at the end
# after set_lang evaluation
template.filters.append(translator)
if hasattr(template, 'add_directives'):
template.add_directives(Translator.NAMESPACE, translator)
def test_filters(self):
"Testing the filters with the Translator filter"
stream = self.oot.generate(**self.data)
translated = stream.filter(Translator(pseudo_gettext))
translated_xml = stream_to_string(
translated.events.render(encoding='utf-8'))
self.assertTrue("Hello," in translated_xml)
self.assertTrue("I am an odt templating test" in translated_xml)
self.assertTrue('Felix da housecat' not in translated_xml)
self.assertTrue(u'Félix le chat de la maison' in translated_xml)
self.assertTrue('We sell stuff' not in translated_xml)
self.assertTrue('On vend des choses' in translated_xml)
def _callback_loader(cls, report, template):
# JCA: We do not use tranlsation in reports, and this does not work for
# now with complex directives. See
# https://support.coopengo.com/issues/20664
return
if report.translatable:
pool = Pool()
Translation = pool.get('ir.translation')
translate = TranslateFactory(cls.__name__, Translation)
translator = Translator(lambda text: translate(text))
# Do not use Translator.setup to add filter at the end
# after set_lang evaluation
template.filters.append(translator)
if hasattr(template, 'add_directives'):
template.add_directives(Translator.NAMESPACE, translator)
def load_template(self, filename, method=None):
"""Retrieve a Template and optionally preset the template data.
Also, if the optional `method` argument is set to `'text'`, a
`NewTextTemplate` instance will be created instead of a
`MarkupTemplate`.
"""
if not self.templates:
self.templates = TemplateLoader(
self.get_all_templates_dirs(),
auto_reload=self.auto_reload,
max_cache_size=self.genshi_cache_size,
default_encoding="utf-8",
variable_lookup='lenient',
callback=lambda template: Translator(
translation.get_translations()).setup(template))
if method == 'text':
cls = NewTextTemplate
else:
cls = MarkupTemplate
return self.templates.load(filename, cls=cls)
def template_loaded(template):
template.filters.insert(0, Translator(ugettext))
def template_loaded(template):
Translator(self.translation).setup(template)
def genshi_loader_callback(template):
template.filters.insert(0, Translator(gettext))
def callback(template):
Translator(translate).setup(template)
def template_loaded(template):
template.filters.insert(0, Translator(i18n))
def callback(template):
Translator(lambda s: s.upper()).setup(template)
def template_loaded(template):
logging.debug('template_loaded: %s', locals())
template.filters.insert(0, Translator(_))
