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):