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