def test_unicode_subject(self): msg = Message(subject=make_lazy_string(lambda a: a, u"sübject"), sender='*****@*****.**', recipients=["*****@*****.**"]) self.assertIn(b'=?utf-8?q?s=C3=BCbject?=', msg.as_bytes()) msg = Message(subject=make_lazy_string(lambda a: a, u"[Foo Bar] Voici vos paramètres d'accès à"), sender='*****@*****.**', recipients=["*****@*****.**"]) self.assertIn(b'=?utf-8?b?W0ZvbyBCYXJdIFZvaWNpIHZvcyBwYXJhbcOodHJlcyBkJ2FjY8OocyDDoA==?=', msg.as_bytes())
def lazy_gettext(string, **variables): if is_lazy_string(string): return string translations = TrytonTranslations(module, 'nereid') return make_lazy_string( translations.lazy_ugettext, string, **variables )
def test_lazy_bundle(): """Test lazy bundle.""" bundle = LazyNpmBundle(make_lazy_string(lambda: 'test{0}.js'.format(1)), 'test2.js') expected = ['test1.js', 'test2.js'] assert expected == bundle.contents
def lazy_gettext(string, **variables): """ Similar to 'gettext' but the string returned is lazy which means it will be translated when it is used as an actual string.""" try: from speaklater import make_lazy_string return make_lazy_string(gettext, string, **variables) except ImportError: return string % variables
def tw2_translation_string(sval): def lookup_provided_translator(_sval): mw = core.request_local().get('middleware') if not mw: return _sval return core.request_local()['middleware'].config.translator(_sval) return make_lazy_string(lambda: lookup_provided_translator(sval))
def lazy_title(text, *args): """Make tranlated string with escaped values from request view args.""" return _( text, **{ key: make_lazy_string(lambda: escape(request.view_args.get(key, ''))) for key in args })
def lazy_pgettext(context, string, **variables): """Like :func:`pgettext` but the string returned is lazy which means it will be translated when it is used as an actual string. .. versionadded:: 0.7 """ from speaklater import make_lazy_string return make_lazy_string(pgettext, context, string, **variables)
def translate(string): def translation_callback(string_in): adapter = TranslationAdapter.get_adapter() if adapter: return adapter(string_in) return string_in return make_lazy_string(translation_callback, string)
def test_lazy_bundle(): """Test lazy bundle.""" bundle = LazyNpmBundle( make_lazy_string(lambda: 'test{0}.js'.format(1)), 'test2.js' ) expected = ['test1.js', 'test2.js'] assert expected == bundle.contents
def test_unicode_subject(self): try: from speaklater import make_lazy_string except ImportError: return msg = Message(subject=make_lazy_string(lambda a: a, u"sübject"), sender='*****@*****.**', recipients=["*****@*****.**"]) self.assertIn('=?utf-8?q?s=C3=BCbject?=', msg.as_string())
def __call__(self, form, field): if self._original_message and (not is_lazy_string(self.message) and not self.message): # Creat on first usage within app context. cv = config_value("MSG_" + self._original_message) if cv: self.message = make_lazy_string(_local_xlate, cv[0]) else: self.message = self._original_message return super(ValidatorMixin, self).__call__(form, field)
def dotslash(self, pth): """Mimic the unix './' behaviour.""" if hasattr(self, "APP_DIR"): return self._get_app_dir(pth=pth) else: try: import speaklater except ImportError: raise RuntimeError("Configure django, or install speaklater.") else: return speaklater.make_lazy_string(self._get_app_dir, pth)
def dotslash(self, pth): if hasattr(self, "APP_DIR"): return self._get_app_dir(pth=pth) else: try: import speaklater except ImportError: raise RuntimeError( "configure django first, or install speaklater") else: return speaklater.make_lazy_string(self._get_app_dir, pth)
def tw2_translation_string(sval): def lookup_provided_translator(_sval): mw = core.request_local().get('middleware') if not mw: return _sval try: return core.request_local()['middleware'].config.translator(_sval) except TypeError as e: log.warn(traceback.format_exc()) return _sval return make_lazy_string(lambda: lookup_provided_translator(sval))
def dotslash(self, pth): if hasattr(self, "APP_DIR"): return os.path.join(self.APP_DIR, pth) else: try: import speaklater except ImportError: raise RuntimeError( "configure django first, or install speaklater" ) else: return speaklater.make_lazy_string( self._get_app_dir, pth )
def lazy_gettext(string, **variables): """Like :func:`gettext` but the string returned is lazy which means it will be translated when it is used as an actual string. Example:: hello = lazy_gettext(u'Hello World') @app.route('/') def index(): return unicode(hello) """ from speaklater import make_lazy_string return make_lazy_string(gettext, string, **variables)
def test_jsonencoder(self): """Test JSON encoder.""" from pybossa.extensions import JSONEncoder from speaklater import make_lazy_string encoder = JSONEncoder() sval = "Hello world" string = make_lazy_string(lambda: sval) encoder = JSONEncoder() data = encoder.encode(dict(foo=string)) data = json.loads(data) err_msg = "The encoder should manage lazystrings" assert data.get('foo') == sval, err_msg
def test_lazystring(self): # Skip this test if speaklater is not installed. try: from speaklater import make_lazy_string, _LazyString except ImportError: return # test_nospeaklater() overrides this import so we have to revert it # otherwise the test may fail because flask_json._LazyString # will be None flask_json._LazyString = _LazyString r = json_response(text=make_lazy_string(lambda: u'Привет')) assert_equals(r.status_code, 200) assert_equals(r.json['text'], u'Привет')
def lazy_gettext(string): ''' Like flask_babel's lazy_gettext, but doesn't interpolate strings. This is required for integration with flask_security, which does its own string interpolation but doesn't support i18n. For more information, see: https://github.com/GovLab/noi2/issues/41 ''' def gettext_no_interpolate(string): t = flask_babel.get_translations() if t is None: return string return t.ugettext(string) return make_lazy_string(gettext_no_interpolate, string)
def test_lazystring(self): # Skip this test if speaklater is not installed. try: from speaklater import make_lazy_string, _LazyString except ImportError: return # test_nospeaklater() overrides this import so we have to revert it # otherwise the test may fail because flask_json._LazyString # will be None flask_json._LazyString = _LazyString r = json_response(text=make_lazy_string(lambda: u'Привет')) assert r.status_code, 200 assert r.json['text'] == u'Привет'
def tw2_translation_string(sval): def lookup_provided_translator(_sval): mw = core.request_local().get('middleware') if not mw: return _sval try: translator = get_translator(mw.config.get_lang()) except AttributeError: try: translator = mw.config.translator except AttributeError: return _sval return translator(_sval) return make_lazy_string(lambda: lookup_provided_translator(sval))
def test_column_label_translation(): app, db, admin = setup() Model1, _ = create_models(db) translated = Translator() label = make_lazy_string(translated, 'Column1') view = CustomModelView(Model1, db.session, column_list=['test1', 'test3'], column_labels=dict(test1=label), column_filters=('test1',)) translated.translate = True non_lazy_groups = view._get_filter_groups() json.dumps(non_lazy_groups) # Filter dict is JSON serializable. ok_(translated('Column1') in non_lazy_groups) # Label was translated.
def test_column_label_translation(): app, db, admin = setup() Model1, _ = create_models(db) translated = Translator() label = make_lazy_string(translated, 'Column1') view = CustomModelView(Model1, db.session, column_list=['test1', 'test3'], column_labels=dict(test1=label), column_filters=('test1',)) admin.add_view(view) translated.translate = True non_lazy_groups = view._get_filter_groups() json.dumps(non_lazy_groups) # Filter dict is JSON serializable. ok_(translated('Column1') in non_lazy_groups) # Label was translated. client = app.test_client() # Render index with active filter. rv = client.get('/admin/model1/?flt1_0=test') eq_(rv.status_code, 200)
def lazy_gettext(string, *args, **kwargs): if is_lazy_string(string): return string return make_lazy_string(lookup_func(), string, *args, **kwargs)
def lazy_gettext(singular, plural, number, **variables): translations = TrytonTranslations(module, 'nereid') return make_lazy_string( translations.lazy_ungettext, singular, plural, number, **variables )
def test_unicode_subject(self): msg = Message(subject=make_lazy_string(lambda a: a, u"sübject"), sender='*****@*****.**', recipients=["*****@*****.**"]) self.assertIn('=?utf-8?q?s=C3=BCbject?=', msg.as_string())
} ) """Default CSS bundle with Bootstrap and Font-Awesome.""" def lazy_skin(): """Generate skin path.""" return 'node_modules/admin-lte/dist/css/skins/{0}.min.css'.format( current_app.config.get('ADMIN_UI_SKIN', 'skin-blue') ) admin_lte_css = LazyNpmBundle( 'node_modules/admin-lte/dist/css/AdminLTE.min.css', 'node_modules/select2/dist/css/select2.min.css', make_lazy_string(lazy_skin), filters='cleancssurl', output='gen/styles.admin-lte.%(version)s.css', npm={ 'admin-lte': '~2.3.6', 'select2': '~4.0.2', } ) """Admin LTE CSS.""" admin_css = NpmBundle( 'scss/invenio_theme/admin.scss', filters='node-scss,cleancssurl', output='gen/styles.admin.%(version)s.css' ) """Default style for admin interface."""
def lazy_pgettext(*args, **kwargs): from speaklater import make_lazy_string return make_lazy_string(pgettext, *args, **kwargs)
def lazy_gettext(*args, **kwargs): """Lazy gettext. https://github.com/mrjoes/flask-babelex/pull/8 """ return make_lazy_string(gettext, *args, **kwargs)
def lazy_gettext(string, plugin_name=None): if is_lazy_string(string): return string return make_lazy_string(gettext_unicode, string, plugin_name=plugin_name)
def ngettext(self, singular, plural, n): return make_lazy_string(_ngettext, singular, plural, n)
def gettext(self, string): return make_lazy_string(_gettext, string)
def lazy_string(func, string, **variables): from speaklater import make_lazy_string return make_lazy_string(func, string, **variables)
def lazy_str_setting(key, default=None): return make_lazy_string(lambda: current_app.config.get(key, default))
def lazy_media_path(suffix=None): return make_lazy_string(lambda: media_path(suffix))
def scaffold_filters(self, name): """ Return list of enabled filters """ attr, joins = tools.get_field_with_path(self.model, name) if attr is None: raise Exception("Failed to find field for filter: %s" % name) # Figure out filters for related column if is_relationship(attr): filters = [] for p in self._get_model_iterator(attr.property.mapper.class_): if hasattr(p, "columns"): # TODO: Check for multiple columns column = p.columns[0] if column.foreign_keys or column.primary_key: continue visible_name = "%s / %s" % (self.get_column_name(attr.prop.table.name), self.get_column_name(p.key)) type_name = type(column.type).__name__ flt = self.filter_converter.convert(type_name, column, visible_name) if flt: table = column.table if joins: self._filter_joins[column] = joins elif tools.need_join(self.model, table): self._filter_joins[column] = [table] filters.extend(flt) return filters else: is_hybrid_property = tools.is_hybrid_property(self.model, name) if is_hybrid_property: column = attr if isinstance(name, string_types): column.key = name.split(".")[-1] else: columns = tools.get_columns_for_field(attr) if len(columns) > 1: raise Exception("Can not filter more than on one column for %s" % name) column = columns[0] # Join not needed for hybrid properties if not is_hybrid_property and tools.need_join(self.model, column.table) and name not in self.column_labels: visible_name = "%s / %s" % (self.get_column_name(column.table.name), self.get_column_name(column.name)) else: if not isinstance(name, string_types): visible_name = self.get_column_name(name.property.key) else: column_name = self.get_column_name(name) def prettify(): return column_name.replace(".", " / ") if is_lazy_string(column_name): visible_name = make_lazy_string(prettify) else: visible_name = prettify() type_name = type(column.type).__name__ flt = self.filter_converter.convert(type_name, column, visible_name, options=self.column_choices.get(name)) if joins: self._filter_joins[column] = joins elif not is_hybrid_property and tools.need_join(self.model, column.table): self._filter_joins[column] = [column.table] return flt
def lazy_pgettext(self, *args, **kwargs): """Like :meth:`pgettext` but the string returned is lazy.""" return make_lazy_string(self.pgettext, *args, **kwargs)
def lazy_setting(key, default=None): from speaklater import make_lazy_string from flask import current_app return make_lazy_string( lambda: current_app.config.get(key, default) )
def get_form_field_label(key): """ This is called during import since form fields are declared as part of class. Thus can't call 'localize_callback' until we need to actually translate/render form. """ return make_lazy_string(_local_xlate, _default_field_labels.get(key, ""))
doc_type=doc_type, body=mapping) else: with open(ANALYSIS_JSON) as analysis: es.indices.create(self.index_name, { 'mappings': dict(mappings), 'settings': {'analysis': json.load(analysis)}, }) es = ElasticSearch() def get_i18n_analyzer(): return '{0}_analyzer'.format(current_app.config['DEFAULT_LANGUAGE']) i18n_analyzer = make_lazy_string(get_i18n_analyzer) @celery.task def reindex(obj): adapter = adapter_catalog.get(obj.__class__) doctype = adapter.doc_type() if adapter.is_indexable(obj): log.info('Indexing %s (%s)', doctype, obj.id) es.index(index=es.index_name, doc_type=doctype, id=obj.id, body=adapter.serialize(obj)) elif es.exists(index=es.index_name, doc_type=doctype, id=obj.id): log.info('Unindexing %s (%s)', doctype, obj.id) es.delete(index=es.index_name, doc_type=doctype, id=obj.id, refresh=True) else:
from invenio_theme.proxies import current_theme_icons from speaklater import make_lazy_string from ..forms import RevokeForm from ..models import SessionActivity from ..sessions import delete_session from .settings import blueprint @login_required @register_menu( blueprint, 'settings.security', # NOTE: Menu item text (icon replaced by a user icon). _('%(icon)s Security', icon=make_lazy_string( lambda: f'<i class="{current_theme_icons.shield}"></i>')), order=2) @register_breadcrumb(blueprint, 'breadcrumbs.settings.security', _('Security')) def security(): """View for security page.""" sessions = SessionActivity.query_by_user( user_id=current_user.get_id()).all() master_session = None for index, session in enumerate(sessions): if SessionActivity.is_current(session.sid_s): master_session = session del sessions[index] return render_template( current_app.config['ACCOUNTS_SETTINGS_SECURITY_TEMPLATE'], formclass=RevokeForm, sessions=[master_session] + sessions,