def configure_i18n(app): babel = Babel(app) @babel.localeselector def get_locale(): accept_languages = app.config.get('ACCEPT_LANGUAGES', ['en_US', 'zh_CN', 'zh_TW', 'ja_JP']) return request.accept_languages.best_match(accept_languages)
def configure_i18n(app): babel = Babel(app) @babel.localeselector def get_locale(): accept_languages = app.config.get('ACCEPT_LANGUAGES', ['en_GB']) return request.accept_languages.best_match(accept_languages, default=accept_languages[0])
def init_i18n(app): babel = Babel(app) @babel.localeselector def get_locale(): lan = app.config.get('ACCEPT_LANGUAGES', ['zh']) return request.accept_languages.best_match(lan)
def init_app(extra_config_settings={}): # Initialize app config settings app.config.from_object( 'config.settings') # Read config from 'app/settings.py' file app.config.update(extra_config_settings ) # Overwrite with 'extra_config_settings' parameter if app.testing: app.config[ 'WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing if os.environ['EASE_DEBUG'] == 'true': app.config['DEBUG'] = True app.config['SECRET_KEY'] = app.config['DEV_SECRET_KEY'] else: try: app.config['SECRET_KEY'] = open('/etc/ease_secret/secret', 'rb').read() except IOError: app.config['SECRET_KEY'] = random_string(64) # Setup Flask-Mail mail = Mail(app) babel = Babel(app) # Setup Flask-User to handle user account related forms from postgres.users import User db_adapter = SQLAlchemyAdapter(db, User) # Init Flask-User and bind to app app.user_manager = UserManager(db_adapter, app, password_validator=oe_password_validator) # Load all models.py files to register db.Models with SQLAlchemy from postgres import users from postgres import settings # Automatically create all registered DB tables db.create_all() db.session.commit() for role in USER_ROLES: create_role(role) # Load all views.py files to register @app.routes() with Flask from pages import main from pages import api from pages import neem_discovery from pages import editor from pages import tutorials from pages import oauth add_user(user_manager=app.user_manager, name='admin', mail=os.environ.get('OPENEASE_MAIL_USERNAME', '*****@*****.**'), pw=ADMIN_USER_DEFAULT_PW, roles=['admin']) app.logger.info("Webapp started.") return app
def initialise(self): """ The application needs initialisation to load the database connection etc. In previous versions this was done with the initialisation of the class in the __init__ method. This is now separated into this function. """ #: Check if the secret key is defined, if not raise an #: exception since it is required assert self.secret_key, 'Secret Key is not defined in config' #: Load the cache self.load_cache() #: Initialise the CSRF handling self.csrf_protection = NereidCsrfProtect() self.csrf_protection.init_app(self) self.view_functions['static'] = self.send_static_file # Backend initialisation self.load_backend() #: Initialise the login handler login_manager = LoginManager() login_manager.user_loader(self._pool.get('nereid.user').load_user) login_manager.header_loader( self._pool.get('nereid.user').load_user_from_header) login_manager.token_loader( self._pool.get('nereid.user').load_user_from_token) login_manager.unauthorized_handler( self._pool.get('nereid.user').unauthorized_handler) login_manager.login_view = "nereid.website.login" login_manager.anonymous_user = self._pool.get('nereid.user.anonymous') login_manager.init_app(self) self.login_manager = login_manager # Monkey patch the url_for method from flask-login to use # the nereid specific url_for flask.ext.login.url_for = url_for self.template_context_processors[None].append( self.get_context_processors()) # Add the additional template context processors self.template_context_processors[None].append( nereid_default_template_ctx_processor) # Add template_filters registered using decorator for name, function in self.get_template_filters(): self.jinja_env.filters[name] = function # Initialize Babel Babel(self) # Finally set the initialised attribute self.initialised = True
def configure_extensions(app): # flask-sqlalchemy db.init_app(app) # flask-mail mail.init_app(app) # flask-cache cache.init_app(app) # flask-babel babel = Babel(app) @babel.localeselector def get_locale(): #TODO, first check user config? g.accept_languages = app.config.get('ACCEPT_LANGUAGES') accept_languages = g.accept_languages.keys() browser_default = request.accept_languages.best_match(accept_languages) if 'language' in session: language = session['language'] #current_app.logger.debug('lang from session: %s' % language) if not language in accept_languages: #clear it #current_app.logger.debug('invalid %s, clearing' % language) session['language'] = None language = browser_default else: language = browser_default #current_app.logger.debug('lang from browser: %s' % language) session['language'] = language #save it to session #and to user? return language # flask-login login_manager.login_view = 'frontend.login' login_manager.refresh_view = 'frontend.reauth' @login_manager.user_loader def load_user(id): return User.query.get(id) login_manager.setup_app(app) # flask-openid oid.init_app(app) # csrf for wtforms #from flask.ext.wtf import csrf csrf.init_app(app) # flask-restless rest.init_app(app, flask_sqlalchemy_db=db) restless_routes() #actually setup the routes # flask-admin admin = Admin(app, name='RootIO Backend', index_view=AdminHomeView()) admin_routes(admin) #add flask-admin classes
def configure_i18n(app): babel = Babel(app) @babel.localeselector def get_locale(): language = request.values.get("lan") if not language: language = request.cookies.get("lan", "zh") return language
def create_app(): create_db() Babel(app) Mail(app) db_adapter = SQLAlchemyAdapter(db, models.User) UserManager(db_adapter, app) searcher = Searcher() init_routes(app, db.session, searcher) return app
def create_app(config='dev'): """ Flask application factory :param str config: type of app to build, either "prod" or "dev" """ # Create flask application app = Flask(__name__) app.config.from_object('settings') app.config['ENV'] = config app.jinja_env.trim_blocks = True # Debug toolbar (when debug=true) debug_toolbar = DebugToolbarExtension(app) app.config['DEBUG_TB_PROFILER_ENABLED'] = True app.config['DEBUG_TB_INTERCEPT_REDIRECTS'] = False # Register Blueprints app.register_blueprint(views_base.base) app.register_blueprint(views_blog.blog) # Flask-Assets; bundles all css/js files in minifed file assets = Environment(app) css_all = Bundle('css/bootstrap-flatly.min.css', 'css/highlightjs.min.css', 'css/font-awesome.css', 'css/main.css', filters='cssmin', output='gen/style.css') js_all = Bundle('js/vendor/jquery.min.js', 'js/vendor/bootstrap.min.js', 'js/vendor/showdown-gfm.min.js', 'js/vendor/highlight.min.js', 'js/main.js', filters='jsmin', output='gen/libs.js') assets.register('css_all', css_all) assets.register('js_all', js_all) if app.config['DEBUG']: assets.debug = True app.config['ASSETS_DEBUG'] = True # Set up Flask-User babel = Babel(app) db_adapter = SQLAlchemyAdapter(db, User) user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app # Init the cache cache.init_app(app) Moment(app) # moment.js Misaka(app, autolink=True, # Misaka Markdown fenced_code=True, lax_html=True, strikethrough=True, superscript=True, tables=True, wrap=True) # Init Admin page admin = Admin(app, index_view=AdminMain(endpoint='admin')) admin.add_view(PostAdminView()) admin.add_view(NewPostView()) admin.add_view(ModelView(Comment, db.session)) static_path = os.path.join(BASE_DIR, 'app', 'static') admin.add_view(FileAdminView(static_path, '/static/', name='Static Files')) # Initialize DB db.init_app(app) return app
def init_app(self, app): self.app = app app.config.setdefault('CSRF_ENABLED', True) app.config.setdefault('SENTRY_ENABLED', False) app.config.setdefault('BEHIND_REVERSE_PROXY', False) app.config.setdefault('REDIS_SESSIONS_ENABLED', False) app.config.setdefault('REDIS_SESSIONS_DB', 1) app.config.setdefault('REDIS_SESSIONS_HOST', '127.0.0.1') app.config.setdefault('REDIS_SESSIONS_PORT', 6379) app.config.setdefault('REDIS_SESSIONS_PICKLE_PROTO', 3) app.config.setdefault('BABEL_ENABLED', False) bp = Blueprint('boilerplate', __name__, template_folder='templates') self.app.register_blueprint(bp) # Inject various globals into jinja app.jinja_env.globals['csrf_setup'] = csrf_setup app.jinja_env.globals['render_field'] = render_field app.jinja_env.filters['percent_escape'] = percent_escape app.jinja_env.filters['time_since'] = timesince if app.config.get('CSRF_ENABLED'): from flask_wtf.csrf import CsrfProtect app.csrf = CsrfProtect(app) if app.config.get('BEHIND_REVERSE_PROXY'): from .ReverseProxied import ReverseProxied app.wsgi_app = ReverseProxied(app.wsgi_app) if app.config.get('SENTRY_ENABLED') and not app.debug: from raven.contrib.flask import Sentry app.sentry = Sentry(app) if app.config.get('REDIS_SESSIONS_ENABLED'): from .RedisSessionInterface import RedisSessionInterface from redis import Redis redis = Redis(host=app.config.get('REDIS_SESSIONS_HOST'), port=app.config.get('REDIS_SESSIONS_PORT'), db=app.config.get('REDIS_SESSIONS_DB')) app.session_interface = RedisSessionInterface( redis=redis, pickle_protocol=app.config.get('REDIS_SESSIONS_PICKLE_PROTO')) if app.config.get('BABEL_ENABLED'): from flask.ext.babel import Babel from .filters import local_date, local_date_time app.babel = Babel(app) app.jinja_env.filters['local_date'] = local_date app.jinja_env.filters['local_date_time'] = local_date_time return True
def configure_extensions(app): # flask-sqlalchemy db.init_app(app) # flask-babel babel = Babel(app) @babel.localeselector def get_locale(): accept_languages = app.config.get('ACCEPT_LANGUAGES') return request.accept_languages.best_match(accept_languages)
def create_app(): """Create an application.""" app = Flask(__name__) app.config.from_object('flaskberry.settings') load_modules(app) socketio.init_app(app) babel = Babel(app) babel.locale_selector_func = get_locale return app
def register_babel(app): from flask.ext.babel import Babel babel = Babel(app) @babel.localeselector def get_locale(): app.config.setdefault('BABEL_SUPPORTED_LOCALES', ['en', 'zh']) app.config.setdefault('BABEL_DEFAULT_LOCALE', 'en') match = app.config['BABEL_SUPPORTED_LOCALES'] default = app.config['BABEL_DEFAULT_LOCALE'] return request.accept_languages.best_match(match, default)
def register_extensions(app): """ All extensions used by the application are registered here """ # Register database db.init_app(app) # Flask Babel for translations babel = Babel(app) @babel.localeselector def get_locale(): accept_languages = app.config.get('ACCEPT_LANGUAGES') return request.accept_languages.best_match(accept_languages) # Flask Login login_manager.setup_app(app)
def create_app(config): app = Flask(__name__) app.config.from_object(config) login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = 'website.login' @login_manager.user_loader def load_user(user_id): return User.load(user_id) @app.before_request def on_request(): g.db = database.connect() @app.teardown_request def on_teardown(exception): db = getattr(g, 'db', None) if db is not None: db.close() @app.after_request def after_request_calls(response): for callback in getattr(g, 'after_request_callbacks', ()): callback(response) return response babel = Babel(app) @babel.localeselector def select_locale(): if 'lang' in request.args: lang = request.args.get('lang') @call_after_request def set_cookie(request): request.set_cookie('lang', lang, 60 * 60 * 24 * 31 * 12) return lang return request.cookies.get('lang') or \ request.accept_languages.best_match(app.config.get('LANGUAGES')) from .website import website app.register_blueprint(website) from .api import api app.register_blueprint(api, url_prefix='/api') return app
def init_app(app, db_instance, extra_config_settings={}): # Initialize app config settings app.config.from_object('webrob.config.settings') # Read config from 'app/settings.py' file app.config.update(extra_config_settings) # Overwrite with 'extra_config_settings' parameter if app.testing: app.config['WTF_CSRF_ENABLED'] = False # Disable CSRF checks while testing if os.environ['EASE_DEBUG'] == 'true': app.config['DEBUG'] = True app.config['SECRET_KEY'] = app.config['DEV_SECRET_KEY'] else: try: app.config['SECRET_KEY'] = open('/etc/ease_secret/secret', 'rb').read() except IOError: app.config['SECRET_KEY'] = random_string(64) # Setup Flask-Mail mail = Mail(app) babel = Babel(app) # Setup Flask-User to handle user account related forms from webrob.models.users import User db_adapter = SQLAlchemyAdapter(db_instance, User) user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app # Load all models.py files to register db.Models with SQLAlchemy from webrob.models import users from webrob.models import tutorials from webrob.models import experiments # Load all views.py files to register @app.routes() with Flask from webrob.pages import api from webrob.pages import db from webrob.pages import editor from webrob.pages import experiments from webrob.pages import knowrob from webrob.pages import login from webrob.pages import meshes from webrob.pages import mongo from webrob.pages import tutorials init_db(app, db_instance) init_webapp(app, db_instance) add_user(app,db_instance,user_manager,'admin', os.environ.get('OPENEASE_MAIL_USERNAME', '*****@*****.**'), os.environ.get('OPENEASE_ADMIN_PASSWORD'), ['admin']) app.logger.info("Webapp started.") return app
def configure_babel(app): # Load additional languages into the babel # cache. We do this so we can add Haitian Creole # using french as a model. babel_patched_load('cpf') # flask-babel babel = Babel(app) # Wire Babel into the settings # and the settings code into Babel settings_views.set_babel(babel) babel.localeselector(settings_views.current_locale) return babel
def configure_extensions(app): #from simplekv.memory import DictStore #from flask.ext.kvsession import KVSessionExtension #store = DictStore() ## this will replace the app's session handling #KVSessionExtension(store, app) mongo.init_app(app, "FUNFUNSAY") # cache cache.init_app(app) # babel #print "create babel object" babel = Babel(app) @babel.localeselector def get_locale(): # if a user is logged in, use the locale from the user settings if current_user.is_authenticated(): return current_user.locale # otherwise try to guess the language from the user accept # header the browser transmits. We support de/fr/en in this # example. The best match wins. return request.accept_languages.best_match(['zh_CN', 'en']) @babel.timezoneselector def get_timezone(): if current_user.is_authenticated(): return current_user.timezone return app.config['BABEL_DEFAULT_TIMEZONE'] # login. from flask.ext.login import LoginManager login_manager = LoginManager() login_manager.session_protection = None #@fixme! login_manager.login_view = 'homesite.login' login_manager.refresh_view = 'homesite.reauth' login_manager.login_message = _("Please log in to access this page.") @login_manager.user_loader def load_user(id): #print "####: loaduser ", id return User.load_user(id) login_manager.setup_app(app) from flask.ext.markdown import Markdown Markdown(app, safe_mode="escape")
def init_app(app, db_instance, extra_config_settings={}): _init_app_config_settings(app, extra_config_settings) # Setup Flask-Mail mail = Mail(app) babel = Babel(app) # Setup Flask-User to handle user account related forms from webrob.models.users import User db_adapter = SQLAlchemyAdapter(db_instance, User) app.user_manager = UserManager(db_adapter, app) # Init Flask-User and bind to app # Load all models.py files to register db.Models with SQLAlchemy # Needs to remain in code, even if IDEs might show it's unused, Flask will use them during runtime from webrob.models import users from webrob.models import tutorials from webrob.models import teaching from webrob.models import experiments # Load all views.py files to register @app.routes() with Flask # Needs to remain in code, even if IDEs might show it's unused, Flask will use them during runtime from webrob.pages import api from webrob.pages import db from webrob.pages import editor from webrob.pages import experiments from webrob.pages import knowrob from webrob.pages import login from webrob.pages import meshes from webrob.pages import mongo from webrob.pages import tutorials from webrob.pages import oauth init_db(app, db_instance) init_webapp(app, db_instance) add_user(app=app, db=db_instance, user_manager=app.user_manager, name='admin', mail=evg.get_variable_with_default('OPENEASE_MAIL_USERNAME', '*****@*****.**'), pw=evg.get_required_variable('OPENEASE_ADMIN_PASSWORD'), roles=['admin']) _log_webapp_started(app) return app
def create_app(config_file=None): app = Flask(__name__) app = change_jinja_templates(app) if config_file: app.config.from_pyfile(config_file) else: app.config.from_envvar("CLA_PUBLIC_CONFIG") if app.config.get("SENTRY_DSN"): app.sentry = Sentry(app, dsn=app.config.get("SENTRY_DSN"), logging=True, level=logging.ERROR) app.babel = Babel(app) app.babel.localeselector(get_locale) app.cache = Cache(app) app.mail = Mail(app) for extension in app.config["EXTENSIONS"]: extension.init_app(app) app.session_interface = CheckerSessionInterface() app.json_encoder = CustomJSONEncoder register_error_handlers(app) app.add_template_global(honeypot.FIELD_NAME, name="honeypot_field_name") app.register_blueprint(base) app.register_blueprint(geocoder) app.register_blueprint(contact) app.register_blueprint(scope) if not app.config.get("CONTACT_ONLY"): app.register_blueprint(checker) logging.config.dictConfig(app.config["LOGGING"]) # quiet markdown module logging.getLogger("MARKDOWN").setLevel(logging.WARNING) if app.debug: from werkzeug.debug import DebuggedApplication app.wsgi_app = DebuggedApplication(app.wsgi_app, True) return app
def __init__(self, config, manager=False): from flask.ext.babel import Babel from utils.mysql import FlaskFyMySQL self.prepared = False self.config = config self.app = Flask(__name__, template_folder=self.config.TEMPLATE_FOLDER, static_folder=self.config.STATIC_FOLDER) self.app.config.from_object(config) self.app.wsgi_app = ProxyFix(self.app.wsgi_app) self.babel = Babel(self.app) self.db = FlaskFyMySQL(self.app) if not manager: self.prepare()
def create_app(**config_overrides): app = web.create_app(__name__, __path__, **config_overrides) tmpl_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates') static_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'static') app.template_folder = tmpl_dir app.static_folder = static_dir oauth.init_app(app) assets.init_app(app) babel = Babel(app) # So we can use Jade templates. app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension') return app
def locale_handlers(app): """ Registers application handlers for the localization strategy. """ def get_request_locale(): default_culture = app.config["DEFAULT_CULTURE"] cultures = app.config["CULTURES"].keys() # if the culture is set in the header, then use it (needed to ensure consistency when multiple tabs are open) header_value = request.headers.get("X-Request-Culture") if header_value and header_value in cultures: # set and exit return header_value # if the user identity is known, support user favorite language user = request.user if hasattr(request, "user") else None if user is not None and user.culture: user_culture = user.culture if user_culture and user_culture in cultures: return user_culture culture_cookie = request.cookies.get("culture") if culture_cookie and culture_cookie in cultures: return culture_cookie # set culture by browser setting, or application default best_match = request.accept_languages.best_match(cultures) if best_match: return best_match return default_culture # localization: babel = Babel(app) @babel.localeselector def get_locale(): locale = get_request_locale() request.culture = locale return locale @app.after_request def add_culture_cookie(response): culture = request.culture if hasattr(request, "culture") else None if culture: response.set_cookie("culture", value=culture) return response
def create_app(): app = Flask(__name__) app.config.from_object("config") database.init_database(app) app.toolbar = DebugToolbarExtension(app) app.babel = Babel(app) @app.before_request def before_request(): g.context = {} # elixir.setup_all() return app
def configi18n(app): babel = Babel(app) @babel.localeselector def get_locale(): accept_languages = app.config.get('accept_languages', ['en_us', 'zh_cn']) default_language = app.config.get('babel_default_locale', ['en_us']) lang = request.accept_languages.best_match(default_language) for language in request.accept_languages: lang = language[0].replace('-', '_') if lang in accept_languages: break return lang
def test_i18n_enabled(self): from flask import request from flask.ext.babel import Babel babel = Babel(self.app) @babel.localeselector def get_locale(): return request.accept_languages.best_match(['en', 'zh'], 'en') self.app.config['CSRF_ENABLED'] = False response = self.client.post( "/", headers={'Accept-Language': 'zh-CN,zh;q=0.8'}, data={}) assert '\u8be5\u5b57\u6bb5\u662f' in to_unicode(response.data) response = self.client.post("/", data={}) assert b'This field is required.' in response.data
def configure_i18n(app): """ tanzimate marbot be i18n va systeme tarjome dar in bakhsh emal mishavad """ babel = Babel(app) @babel.localeselector def get_locale(): return request.accept_languages.best_match(['fa']) # return 'fa' # find set lang # TODO: user az inja gerefte mishe?! # aslan to in marhale user darim ma ya ye chize zafeyi hast?! user = getattr(g, 'user', None) if user is not None: pass accept_languages = app.config.get('ACCEPT_LANGUAGES', ['fa', 'en']) return request.accept_languages.best_match(accept_languages)
def init(): """ Sets up flask application object `app` and returns it. """ # Instantiate main app, load configs, register modules, set # url patterns and return the `app` object. app = Flask(__name__) app.config.from_object(settings) config.app = app # Init SQLAlchemy wrapper. config.db = SQLAlchemy(app) if app.debug: DebugToolbarExtension(app) #: Wrap the `app` with `Babel` for i18n. Babel(app) config.cache = Cache(app) app.jinja_env.add_extension(SlimishExtension) app.jinja_env.slim_debug = app.debug config.bcrypt = Bcrypt(app) # Other initializations. for fn, values in [ (set_middlewares, getattr(settings, 'MIDDLEWARES', None)), (set_context_processors, getattr(settings, 'CONTEXT_PROCESSORS', None)), (set_template_filters, getattr(settings, 'TEMPLATE_FILTERS', None)), (set_before_handlers, getattr(settings, 'BEFORE_REQUESTS', None)), (set_after_handlers, getattr(settings, 'AFTER_REQUESTS', None)), (set_log_handlers, getattr(settings, 'LOG_HANDLERS', None)), (set_error_handlers, getattr(settings, 'ERROR_HANDLERS', None)), (set_blueprints, getattr(settings, 'BLUEPRINTS', None)) ]: if values: fn(app, values) # Register all js and css files. assets = Environment(app) register_assets(app, assets) # URL rules. urls.set_urls(app) return app
def setup_app(self): app = flask.Flask(__name__) from flask.ext.report import FlaskReport, utils report_page = flask.Blueprint("report", __name__, static_folder="static", template_folder="templates") db_fd, db_fname = tempfile.mkstemp() os.close(db_fd) app.config["SECRET_KEY"] = "JHdkj1adf;" app.config['BABEL_DEFAULT_LOCALE'] = 'zh_CN' from flask.ext.babel import Babel Babel(app) app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///" + db_fname db.init_app(app) db.app = app import models db.create_all() FlaskReport(db, utils.collect_models(models), app, report_page, table_label_map={'TB_USER': u'角色'}) app.register_blueprint(report_page, url_prefix="/report") self.init_data_set() self.init_notification() return app
def configure_extensions(app): # flask-sqlalchemy db.init_app(app) # flask-cache cache.init_app(app) # flask-babel babel = Babel(app) @babel.localeselector def get_locale(): return request.accept_languages.best_match(DefaultConfig.LANGUAGES) # flask-login login_manager.login_view = 'admin.login' login_manager.refresh_view = 'admin.reauth' @login_manager.user_loader def load_user(id): return User.query.get(id) login_manager.setup_app(app)