def translations():
"""Return a js file that will handle translations so Flask interpolation
can be isolated
"""
domain = Domain()
translations = domain.get_translations()
template = render_template("js/translations.js",
translations=translations._catalog)
return Response(response=template, status=200, mimetype=MIMETYPE_APP_JS)
def translations():
"""Return a js file that will handle translations so Flask interpolation
can be isolated
"""
domain = Domain()
translations = domain.get_translations()
template = render_template(
"js/translations.js",
translations=translations._catalog
)
return Response(
response=template,
status=200,
mimetype="application/javascript"
)
def register_babel(app):
translations = os.path.abspath(
os.path.join(os.path.dirname(__file__), os.pardir, 'translations'))
domain = Domain(translations)
babel = Babel(default_domain=domain)
babel.init_app(app)
class CustomJSONEncoder(JSONEncoder):
"""This class adds support for lazy translation texts to Flask's
JSON encoder. This is necessary when flashing translated texts."""
def default(self, obj):
from speaklater import is_lazy_string
if is_lazy_string(obj):
try:
return unicode(obj) # python 2
except NameError:
return str(obj) # python 3
return super(CustomJSONEncoder, self).default(obj)
app.json_encoder = CustomJSONEncoder
@babel.localeselector
def get_locale():
return request.accept_languages.best_match(['zh', 'en'])
@babel.timezoneselector
def get_timezone():
return 'UTC'
def register_babel():
translations = os.path.abspath(
os.path.join(os.path.dirname(__file__), os.pardir, 'translations'))
domain = Domain(translations)
babel = Babel(default_domain=domain)
@babel.localeselector
def get_locale():
user = getattr(g, 'user', None)
if user is not None:
if request.path.startswith('/admin'):
return 'zh_Hans_CN'
if g.user.is_authenticated:
return user.setting.locale or 'zh'
return request.accept_languages.best_match(
current_app.config['LANGUAGES'].keys())
@babel.timezoneselector
def get_timezone():
user = getattr(g, 'user', None)
if user is not None:
if g.user.is_authenticated:
return user.setting.timezone or 'UTC'
return 'UTC'
return babel
def _get_domain(match):
domain_name = match.groupdict()['domain']
try:
domain_resources = pkg_resources.resource_filename(domain_name, 'translations')
except ImportError:
return current_app.extensions['babel']._default_domain
return Domain(domain_resources, domain=domain_name)
def register_babel(app):
"""Configure Babel for internationality."""
from flask_babelex import Babel, Domain
babel = Babel(app, default_locale='zh')
# 使用本地的domain，因为flask_security等库没有默认提供中文的支持
local_domain = Domain(domain='security')
security = app.extensions['security']
security.i18n_domain = local_domain
@babel.localeselector
def get_locale():
session['lang'] = 'zh'
return session.get('lang', 'zh')
def register_babel():
translations = os.path.abspath(
os.path.join(os.path.dirname(__file__), os.pardir, 'translations'))
domain = Domain(translations)
babel = Babel(default_domain=domain)
@babel.localeselector
def get_locale():
return request.accept_languages.best_match(['zh', 'en'])
@babel.timezoneselector
def get_timezone():
return 'UTC'
return babel
class Config(BundleConfig):
"""
Default configuration options for the Babel Bundle.
"""
LANGUAGES = ['en']
"""
The language codes supported by the app.
"""
BABEL_DEFAULT_LOCALE = 'en'
"""
The default language to use if none is specified by the client's browser.
"""
BABEL_DEFAULT_TIMEZONE = 'UTC'
"""
The default timezone to use.
"""
DEFAULT_DOMAIN = Domain()
"""
The default :class:`~flask_babelex.Domain` to use.
"""
DATE_FORMATS = ImmutableDict({
'time': 'medium',
'date': 'medium',
'datetime': 'medium',
'time.short': None,
'time.medium': None,
'time.full': None,
'time.long': None,
'date.short': None,
'date.medium': None,
'date.full': None,
'date.long': None,
'datetime.short': None,
'datetime.medium': None,
'datetime.full': None,
'datetime.long': None,
})
"""
A dictionary of date formats.
"""
ENABLE_URL_LANG_CODE_PREFIX = False
"""
def index():
"""
Displays the main overview page
"""
Domain(domain="messages")
try:
security.datastore.commit()
except Exception:
pass
user_id = get_user_id()
user = get_person(user_id)
active_events: List[ShufflingEvent] = []
inactive_events: List[ShufflingEvent] = []
has_groups = False
for user_family in user.families:
for family_group in user_family.groups:
has_groups = True
for group_event in family_group.events:
group_event.group_name = family_group.name
if datetime.now(
) < group_event.event_at: # If event has not taken place
active_events.append(group_event)
else:
inactive_events.append(group_event)
try:
# user.last_activity_at = datetime.datetime.now()
# user.last_activity_ip = request.headers.getlist("X-Forwarded-For")[0].rpartition(" ")[-1]
# db.session.commit()
pass
except Exception as e:
sentry_sdk.capture_exception(e)
return render_template("index.html",
auth=user.first_name,
events=active_events,
uid=user_id,
has_groups=has_groups,
title=_("Home"))
def register_babel(app):
translations = os.path.abspath(
os.path.join(os.path.dirname(__file__), os.pardir, 'translations'))
domain = Domain(translations)
babel = Babel(default_domain=domain)
babel.init_app(app)
# class CustomJSONEncoder(JSONEncoder):
# """This class adds support for lazy translation texts to Flask's
# JSON encoder. This is necessary when flashing translated texts."""
# def default(self, obj):
# from speaklater import is_lazy_string
# if is_lazy_string(obj):
# try:
# return unicode(obj) # python 2
# except NameError:
# return str(obj) # python 3
# return super(CustomJSONEncoder, self).default(obj)
# app.json_encoder = CustomJSONEncoder
@babel.localeselector
def get_locale():
user = getattr(g, 'user', None)
if user is not None:
if request.path.startswith('/admin'):
return 'zh_Hans_CN'
if g.user.is_authenticated:
return user.setting.locale or 'zh'
return request.accept_languages.best_match(
app.config['LANGUAGES'].keys())
@babel.timezoneselector
def get_timezone():
user = getattr(g, 'user', None)
if user is not None:
if g.user.is_authenticated:
return user.setting.timezone or 'UTC'
return 'UTC'
def _configure_i18n(app):
import os
from flask_babelex import Domain
from flask_babelex import Babel
from .. import translations
TRANSLATIONS_DIR = os.path.abspath(os.path.dirname(translations.__file__))
domain = Domain(dirname=TRANSLATIONS_DIR) #, domain="mongrey")
babel = Babel(app,
default_domain=domain,
default_locale=app.config.get('BABEL_DEFAULT_LOCALE'))
@app.before_request
def set_locales():
current_lang = session.get(constants.SESSION_LANG_KEY, None)
if not current_lang:
session[constants.SESSION_LANG_KEY] = app.config.get(
'BABEL_DEFAULT_LOCALE')
current_tz = session.get(constants.SESSION_TIMEZONE_KEY, None)
if not current_tz:
session[constants.SESSION_TIMEZONE_KEY] = app.config.get(
'BABEL_DEFAULT_TIMEZONE')
if not babel.locale_selector_func:
@babel.localeselector
def get_locale():
default_lang = request.accept_languages.best_match(
dict(app.config.get('ACCEPT_LANGUAGES_CHOICES')).keys())
return session.get(constants.SESSION_LANG_KEY, default_lang)
if babel.timezone_selector_func is None:
@babel.timezoneselector
def get_timezone():
return session.get(constants.SESSION_TIMEZONE_KEY,
app.config.get('BABEL_DEFAULT_TIMEZONE'))
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__, instance_relative_config=True)
app.config.from_mapping(
SECRET_KEY='dev',
WIKI_CURRENT_LANGUAGE=lambda: session.get('ln', 'fr'),
WIKI_LANGUAGES=['en', 'fr', 'de', 'it'],
# BABEL_TRANSLATION_DIRECTORIES = resource_filename('flask_wiki', 'translations'),
BABEL_DEFAULT_LOCALE='en',
DEBUG=True)
if test_config is None:
# load the instance config, if it exists, when not testing
app.config.from_pyfile('config.py', silent=True)
else:
# load the test config if passed in
app.config.from_mapping(test_config)
Bootstrap(app)
Wiki(app)
# use the flask-wiki translations
domain = Domain(resource_filename('flask_wiki', 'translations'))
babel = Babel(app, default_domain=domain)
@babel.localeselector
def get_locale():
if 'ln' in session:
return session['ln']
ln = request.accept_languages.best_match(
app.config.get('WIKI_LANGUAGES'))
return ln
@app.route('/language/<ln>')
def change_language(ln):
session['ln'] = ln
return redirect(url_for('wiki.index'))
return app
app.jinja_env.add_extension('jinja2_time.TimeExtension')
# Login Manager
login_manager = LoginManager()
login_manager.init_app(app)
# Bcrypt
bcrypt = Bcrypt()
bcrypt.init_app(app)
# QRCode
qrcode = QRcode()
qrcode.init_app(app)
# Babel
domain = Domain(dirname='translations')
babel = Babel(default_domain=domain)
babel.init_app(app)
# Flask-Assets
from .assets import bundles
assets = Environment(app)
assets.append_path(os.path.join(os.path.dirname(__file__), './static'))
assets.append_path(
os.path.join(os.path.dirname(__file__), './static/bower_components'))
assets.register(bundles)
# Flask-Admin
admin = Admin(app,
name='Interface Admin',
index_view=StatisticsView(url='/admin', name='Vue générale'))
def _get_i18n_domain(app):
return Domain(dirname=cv("I18N_DIRNAME", app=app),
domain=cv("I18N_DOMAIN", app=app))
app = Flask(__name__)
app.config.from_object(Config)
db.init_app(app)
mig = Migrate(app=app,
db=db,
directory=app.config.get('MIGRATE_DIRECTORY', 'data/migrations'))
Bootstrap(app)
security.init_app(app,
data_store,
login_form=LoginUserForm,
register_form=RegisterUserForm)
admin.admin.init_app(app)
domain = Domain(app.config.get("BABEL_TRANSLATIONS")[0], "messages")
babel = Babel(app, default_domain=domain)
babel.domain = "messages"
babel.translation_directories = app.config.get("BABEL_TRANSLATIONS")
@babel.localeselector
def get_locale():
if current_user.is_authenticated:
return current_user.language or 'hu'
return request.accept_languages.best_match(app.config.get('LANGUAGES'))
@babel.timezoneselector
def get_timezone():
if current_user.is_authenticated:
# Author: Ling Thio <*****@*****.**>
# Copyright (c) 2013 Ling Thio
import os
from flask import request
_translations_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'translations')
# Load Flask-User translations, if Flask-BabelEx has been installed
try:
from flask_babelex import Domain
# Retrieve Flask-User translations from the flask_user/translations directory
domain_translations = Domain(_translations_dir, domain='flask_user')
except ImportError:
domain_translations = None
def gettext(string, **variables):
return domain_translations.gettext(
string, **variables) if domain_translations else string % variables
def lazy_gettext(string, **variables):
return domain_translations.lazy_gettext(
string, **variables) if domain_translations else string % variables
def get_language_codes():
"""
flask_security.babel
~~~~~~~~~~~~~~~~~~~~
I18N support for Flask-Security.
"""
from flask_babelex import Domain
from wtforms.i18n import messages_path
wtforms_domain = Domain(messages_path(), domain="wtforms")
class Translations:
"""Fixes WTForms translation support and uses wtforms translations."""
def gettext(self, string):
return wtforms_domain.gettext(string)
def ngettext(self, singular, plural, n):
return wtforms_domain.ngettext(singular, plural, n)
# File Name: babel.py # Author: jianglin # Email: [email protected] # Created: 2018-02-11 14:52:25 (CST) # Last Update: 星期日 2018-02-11 15:31:25 (CST) # By: # Description: # ******************************************************************************** from flask import request, g, current_app from flask_babelex import Babel, Domain import os translations = os.path.abspath( os.path.join( os.path.dirname(__file__), os.pardir, os.pardir, 'translations')) domain = Domain(translations) babel = Babel(default_domain=domain) @babel.localeselector def locale(): user = getattr(g, 'user', None) if user is not None: if request.path.startswith('/admin'): return 'zh_Hans_CN' if g.user.is_authenticated: return user.setting.locale or 'zh' return request.accept_languages.best_match(current_app.config['LANGUAGES'] .keys())
# -*- coding: utf-8 -*-
from flask import Flask, request, session
from flask_sqlalchemy import SQLAlchemy
from flask_babelex import Babel, Domain, lazy_gettext
from wtforms import validators
from plumbum import Plumbum, ModelView
sqla_domain = Domain(domain='sqla-babel', dirname='locales')
# Create application
app = Flask(__name__)
babel = Babel(app, default_domain=sqla_domain)
app.config['SECRET_KEY'] = '1234'
app.config['DEBUG'] = True
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///sample_data.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['PLUMBUM_DEBUG_TEMPLATE'] = False
db = SQLAlchemy(app)
@babel.localeselector
def get_locale():
override = request.args.get('lang')
if override:
def translation_domain(self):
"""Return the domain for this plugin's translation_path"""
path = self.translation_path
return Domain(path) if path else NullDomain()
import os
from flask import render_template
_translations_dir = os.path.join(
os.path.dirname(os.path.dirname(os.path.realpath(__file__))),
'translations')
# Load BanYG360 translations, if Flask-BabelEx has been installed
try:
from flask_babelex import Domain
# Retrieve Flask-User translations from the flask_user/translations directory
domain_translations = Domain(_translations_dir, domain='messages')
except ImportError:
domain_translations = None
def gettext(string, **variables):
return domain_translations.gettext(
string, **variables) if domain_translations else string % variables
def lazy_gettext(string, **variables):
return domain_translations.lazy_gettext(
string, **variables) if domain_translations else string % variables
def get_language_codes():
language_codes = []
for folder in os.listdir(_translations_dir):
locale_dir = os.path.join(_translations_dir, folder, 'LC_MESSAGES')
# Utilities
from logging import getLogger
from datetime import timedelta
# App specific config
from config import Config
# Flask
from flask import request, render_template, redirect, Blueprint
from flask_security import login_required
from flask_login import current_user
from flask_babelex import Domain, gettext as _
from main import babel
domain = Domain(domain="messages")
getLogger().setLevel(Config.LOGLEVEL)
logger = getLogger()
@babel.localeselector
def get_locale():
"""
Deals with displaying the correct localization with possible override
:return: user locale
"""
if current_user.is_authenticated:
user_id = session["user_id"]
else:
return request.accept_languages.best_match(["et", "en"])
def _get_i18n_domain(app):
return Domain(pkg_resources.resource_filename('flask_security',
'translations'),
domain=cv('I18N_DOMAIN', app=app))
def init_app(
self,
app,
db_adapter=None,
# Forms
add_email_form=forms.AddEmailForm,
change_password_form=forms.ChangePasswordForm,
change_username_form=forms.ChangeUsernameForm,
forgot_password_form=forms.ForgotPasswordForm,
login_form=forms.LoginForm,
register_form=forms.RegisterForm,
resend_confirm_email_form=forms.ResendConfirmEmailForm,
reset_password_form=forms.ResetPasswordForm,
invite_form=forms.InviteForm,
# Validators
username_validator=forms.username_validator,
password_validator=forms.password_validator,
# View functions
render_function=render_template,
change_password_view_function=views.change_password,
change_username_view_function=views.change_username,
confirm_email_view_function=views.confirm_email,
email_action_view_function=views.email_action,
forgot_password_view_function=views.forgot_password,
login_view_function=views.login,
logout_view_function=views.logout,
manage_emails_view_function=views.manage_emails,
register_view_function=views.register,
resend_confirm_email_view_function=views.resend_confirm_email,
reset_password_view_function=views.reset_password,
unconfirmed_email_view_function=views.unconfirmed,
unauthenticated_view_function=views.unauthenticated,
unauthorized_view_function=views.unauthorized,
user_profile_view_function=views.user_profile,
invite_view_function=views.invite,
# Misc
login_manager=LoginManager(),
password_crypt_context=None,
send_email_function=emails.send_email,
token_manager=tokens.TokenManager(),
legacy_check_password_hash=None):
""" Initialize the UserManager object """
self.app = app
if db_adapter is not None:
self.db_adapter = db_adapter
# Forms
self.add_email_form = add_email_form
self.change_password_form = change_password_form
self.change_username_form = change_username_form
self.forgot_password_form = forgot_password_form
self.login_form = login_form
self.register_form = register_form
self.resend_confirm_email_form = resend_confirm_email_form
self.reset_password_form = reset_password_form
self.invite_form = invite_form
# Validators
self.username_validator = username_validator
self.password_validator = password_validator
# View functions
self.render_function = render_function
self.change_password_view_function = change_password_view_function
self.change_username_view_function = change_username_view_function
self.confirm_email_view_function = confirm_email_view_function
self.email_action_view_function = email_action_view_function
self.forgot_password_view_function = forgot_password_view_function
self.login_view_function = login_view_function
self.logout_view_function = logout_view_function
self.manage_emails_view_function = manage_emails_view_function
self.register_view_function = register_view_function
self.resend_confirm_email_view_function = resend_confirm_email_view_function
self.reset_password_view_function = reset_password_view_function
self.unconfirmed_email_view_function = unconfirmed_email_view_function
self.unauthenticated_view_function = unauthenticated_view_function
self.unauthorized_view_function = unauthorized_view_function
self.user_profile_view_function = user_profile_view_function
self.invite_view_function = invite_view_function
# Misc
self.login_manager = login_manager
self.token_manager = token_manager
self.password_crypt_context = password_crypt_context
self.send_email_function = send_email_function
self.legacy_check_password_hash = legacy_check_password_hash
""" Initialize app.user_manager."""
# Bind Flask-USER to app
app.user_manager = self
# Flask seems to also support the current_app.extensions[] list
if not hasattr(app, 'extensions'):
app.extensions = {}
app.extensions['user'] = self
# Set defaults for undefined settings
settings.set_default_settings(self, app.config)
# Make sure the settings are valid -- raise ConfigurationError if not
settings.check_settings(self)
# Initialize Translations -- Only if Flask-Babel has been installed
try:
from flask_babelex import Domain
except ImportError:
from .translations import get_translations
if hasattr(app.jinja_env, 'install_gettext_callables'):
app.jinja_env.install_gettext_callables(
lambda x: get_translations().ugettext(x),
lambda s, p, n: get_translations().ungettext(s, p, n),
newstyle=True)
else:
app.jinja_env.add_extension('jinja2.ext.i18n')
app.jinja_env.install_null_translations()
else:
trans_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), "translations")
flask_user_domain = Domain(trans_path, domain='flask_user')
@app.before_first_request
def merge_translations():
from flask_babelex import get_domain
get_domain().get_translations().merge(
flask_user_domain.get_translations())
# Create password_crypt_context if needed
if not self.password_crypt_context:
self.password_crypt_context = CryptContext(
schemes=[app.config['USER_PASSWORD_HASH']])
# Setup Flask-Login
self.setup_login_manager(app)
# Setup TokenManager
self.token_manager.setup(app.config.get('SECRET_KEY'))
# Add flask_user/templates directory using a Blueprint
blueprint = Blueprint('flask_user',
'flask_user',
template_folder='templates')
app.register_blueprint(blueprint)
# Add URL routes
self.add_url_routes(app)
# Add context processor
app.context_processor(_flask_user_context_processor)
from flask_babelex import Domain from os import environ,listdir from flask import safe_join from os.path import split import backends trans_dir = safe_join(split(split(backends.__file__)[0])[0], "translations") messages_domain = Domain(trans_dir,domain="messages") parts_domain = Domain(trans_dir,domain="parts") docs_domain = Domain(trans_dir,domain="docs") languages = listdir(trans_dir) + ['en'] def gettext_parts(msgid): return parts_domain.gettext(msgid) def gettext_docs(msgid): return docs_domain.gettext(msgid)
return dirname
return super(CustomDomain, self).get_translations_path(ctx)
domain = CustomDomain()
gettext = domain.gettext
ngettext = domain.ngettext
lazy_gettext = domain.lazy_gettext
try:
from wtforms.i18n import messages_path
except ImportError:
from wtforms.ext.i18n.utils import messages_path
wtforms_domain = Domain(messages_path(), domain='wtforms')
class Translations(object):
''' Fixes WTForms translation support and uses wtforms translations '''
def gettext(self, string):
t = wtforms_domain.get_translations()
return t.ugettext(string)
def ngettext(self, singular, plural, n):
t = wtforms_domain.get_translations()
return t.ungettext(singular, plural, n)
# lazy imports
from .helpers import get_current_view
# coding=utf-8 from __future__ import absolute_import from flask_sqlalchemy import SQLAlchemy from flask_restful import Api from flask_login import LoginManager from flask_session import Session from flask_principal import Principal from flask_babelex import Babel, Domain from flask_caching import Cache import os db = SQLAlchemy() api = Api() login_manager = LoginManager() session = Session() principal = Principal() domain = Domain(os.path.join(os.getcwd(), 'translations/')) babel = Babel(default_domain=domain) cache = Cache()
import pycountry
from flask_babelex import Domain
domain = Domain(pycountry.LOCALES_DIR, domain='iso3166')
country_codes = [(c.alpha_2, domain.lazy_gettext(c.name))
for c in pycountry.countries]
country_codes.insert(0, ('--', '--'))
"""
Kerko: A Flask blueprint that provides faceted search for bibliographies based
on Zotero.
"""
# pylint: disable=invalid-name
import pathlib
from environs import Env
from flask import Blueprint
from flask_babelex import Domain
__version__ = '0.3alpha1'
babel_domain = Domain(pathlib.Path(__file__).parent / 'translations',
domain='kerko')
env = Env()
def init_default_config(state):
"""
Initialize default KERKO settings in the app's config object.
The following settings must be set in the app's config and have no defaults:
- `KERKO_ZOTERO_LIBRARY_ID`
- `KERKO_ZOTERO_LIBRARY_TYPE`
- `KERKO_ZOTERO_API_KEY`
The following settings are used with Bootstrap-Flask to load CDN-based
resources. Alternatively, one may set `BOOTSTRAP_SERVE_LOCAL=True` to use
# Author: Alejandro Alvarez <*****@*****.**>
# Copyright (c) 2019 Alejandro Alvarez
import os
from flask import request
from flask_login import current_user
_translations_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'translations')
# Load Flask-Auth translations, if Flask-BabelEx has been installed
try:
from flask_babelex import Domain
# Retrieve Flask-Auth translations from the flask_auth/translations directory
domain_translations = Domain(_translations_dir, domain='flask_auth')
except ImportError:
domain_translations = None
def gettext(string, **variables):
return domain_translations.gettext(
string, **variables) if domain_translations else string % variables
def lazy_gettext(string, **variables):
return domain_translations.lazy_gettext(
string, **variables) if domain_translations else string % variables
def get_language_codes():
'ajaxform.html.jinja2': 'baseframe/bootstrap3/ajaxform.html.jinja2',
'autoform.html.jinja2': 'baseframe/bootstrap3/autoform.html.jinja2',
'delete.html.jinja2': 'baseframe/bootstrap3/delete.html.jinja2',
'message.html.jinja2': 'baseframe/bootstrap3/message.html.jinja2',
'redirect.html.jinja2': 'baseframe/bootstrap3/redirect.html.jinja2'
},
'mui': {
'ajaxform.html.jinja2': 'baseframe/mui/ajaxform.html.jinja2',
'autoform.html.jinja2': 'baseframe/mui/autoform.html.jinja2',
'delete.html.jinja2': 'baseframe/mui/delete.html.jinja2',
'message.html.jinja2': 'baseframe/mui/message.html.jinja2',
'redirect.html.jinja2': 'baseframe/mui/redirect.html.jinja2'
}
}
baseframe_translations = Domain(translations.__path__[0], domain='baseframe')
_ = baseframe_translations.gettext
__ = baseframe_translations.lazy_gettext
class JSONEncoder(JSONEncoderBase):
"""
Custom JSON encoder that adds support to types that are not supported
by Flask's JSON encoder. Eg: lazy_gettext
"""
def default(self, o):
if is_lazy_string(o):
return six.text_type(o)
if isinstance(o, BaseTzInfo):
return o.zone
if isinstance(o, RoleAccessProxy):
