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 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 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 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 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):
"""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_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 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_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 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 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 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',))
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 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())
def lazy_gettext(string, *args, **kwargs):
if is_lazy_string(string):
return string
return make_lazy_string(lookup_func(), string, *args, **kwargs)
}
)
"""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 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())
def gettext(self, string):
return make_lazy_string(_gettext, string)
def ngettext(self, singular, plural, n):
return make_lazy_string(_ngettext, singular, plural, n)
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(*args, **kwargs):
from speaklater import make_lazy_string
return make_lazy_string(pgettext, *args, **kwargs)
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 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 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,
