def create_app(): global application if not application: application = Gthnk() application.facet("configuration") application.facet("logs") application.facet("database") application.facet("marshalling") application.facet("blueprints") application.facet("accounts") application.facet("signals") application.facet("forms") application.facet("error_handlers") application.facet("request_handlers") application.facet("administration") # application.facet("rest", api_map=api_map) # application.facet("webassets") # application.facet("email") # application.facet("debugger") # application.facet("task_queue") application.app.permanent_session_lifetime = timedelta(minutes=30) application.app.logger.info("starting gthnk server") application.app.md = Markdown( application.app, extensions=[LinkifyExtension(), JournalExtension()]) # print(application.app.url_map) return (application.app)
def create_app(config_name): """Flask app creation factory""" app = Flask(__name__) app.config.from_object(config_by_name[config_name]) db.init_app(app) login_manager.init_app(app) Markdown(app) return app
def change_jinja_templates(app): # Change the template loader so it will seek out the MOJ Jinja # base templates. moj_loader = jinja2.ChoiceLoader( [app.jinja_loader, jinja2.PackageLoader("moj_template", "templates")]) app.jinja_env.add_extension("jinja2.ext.do") app.jinja_env.add_extension("jinja2.ext.i18n") Markdown(app, extensions=["fenced_code"]) app.jinja_loader = moj_loader # we need to load a special method called "static" to mimic # Django; ideally we would not rely on Django-isms but the MOJ # template assumes you're using jinja with Django. import moj_template root_template_dir = moj_template.__path__[0] static_dir = os.path.join(root_template_dir, "static") template_dir = os.path.join(root_template_dir, "templates", "moj_template") moj_template_blueprint = Blueprint( "moj_template", "moj_template", static_folder=static_dir, static_url_path="/moj-static", template_folder=template_dir, ) app.register_blueprint(moj_template_blueprint) @app.context_processor def utility_processor(): def static(filename): return url_for("moj_template.static", filename=filename) return {"static": static} # Expose user variables @app.context_processor def moj_variables(): try: return app.config["APP_SETTINGS"] except KeyError: log.critical( "Cannot find APP_SETTINGS group in the configuration file.") sys.exit(1) # get today's date @app.context_processor def covid_availability_times(): show_covid_availability_times = datetime.date( year=2020, month=9, day=30) > datetime.date.today() return {"show_covid_availability_times": show_covid_availability_times} return app
def create_app(config=None): app = Flask(__name__) app.config.from_object(config) configure_extensions(app) Markdown(app) configure_i18n(app) configure_identity(app) configure_errorhandlers(app) configure_before_handlers(app) configure_uploads(app, (photos, )) register_blueprints(app) return app
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 configure_extensions(app): oid.init_app(app) cache.init_app(app, config={'CACHE_TYPE' : 'memcached', 'CACHE_DEFAULT_TIMEOUT' : 86400}) # one day lm.init_app(app) lm.login_view = "account.LoginView:index" lm.refresh_view = "account.LoginView:index" lm.needs_refresh_message = { u"The page you are visiting needs re-authentication." } lm.needs_refresh_message_category = "info" Markdown(app, extensions = ["extra", "sane_lists", "codehilite", "smartypants", "toc"], safe_mode='remove', output_format="html5")
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) moment.init_app(app) pagedown.init_app(app) markdown = Markdown(app) db.init_app(app) login_manager.init_app(app) from .main import main as main_blueprint from .auth import auth as auth_blueprint app.register_blueprint(main_blueprint) app.register_blueprint(auth_blueprint, url_prefix='/auth') return app #app = create_app('production')
def setup(app): db.init_app(app) mail.init_app(app) #login_manager.init_app(app) admin = Admin(app) bootstrap = Bootstrap(app) app.register_plugin("website.security") setup_filters_and_processors(app) app.register_plugin("website.views") #app.register_plugin("website.cfp") app.register_plugin("website.registration") app.register_plugin("website.crm") app.register_plugin("website.sdc") # Students demo cup # Add some extensions whoosh = Whoosh(app) pages = FlatPages(app) app.extensions['pages'] = pages setup_freezer(app) markdown_manager = Markdown(app) asset_manager = AssetManager(app) app.extensions['asset_manager'] = asset_manager # Setup custome babel config (see below) setup_babel(app) # Setup hierarchical Jinja2 template loader # TODO: should be generic setup_template_loader(app) create_db(app) load_tracks(app) if not app.config.get('TESTING'): pass
def create_app(config_mode=None, config_file=None): # Create webapp instance app = Flask(__name__) Bootstrap(app) Markdown(app) if config_mode: app.config.from_object(getattr(config, config_mode)) elif config_file: app.config.from_pyfile(config_file) else: app.config.from_envvar('APP_SETTINGS', silent=True) [app.register_blueprint(bp) for bp in blueprints] # set g variables @app.before_request def before_request(): g.site = app.config['SITE'] g.topnav = app.config['TOPNAV'] g.hero = app.config['HERO'] g.sub_units = app.config['SUB_UNITS'] @app.errorhandler(404) # @app.errorhandler(TypeError) def not_found(error): heading = 'Page not found.' subheading = "Sorry, your page isn't available!" kwargs = { 'id': 404, 'title': '404', 'heading': heading, 'subheading': subheading } return render_template('page.html', **kwargs), 404 @app.context_processor def utility_processor(): def currency(x): try: return '$%.2f' % x except TypeError: return x return dict(currency=currency) # @app.template_filter() # def currency(x): # try: # return '$%.2f' % x # except TypeError: # return x # app.jinja_env.filters['currency'] = currency @app.route('/') def home(): return render_template('home.html') # create markdown views mkd_pages = app.config['MKD_PAGES'] mkd_folder = app.config['MKD_FOLDER'] for page in mkd_pages: func = _get_view_func(page, mkd_folder) app.add_url_rule('/%s/' % page['id'], view_func=func) return app
from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.markdown import Markdown from flask.ext.login import LoginManager from flask.ext.gravatar import Gravatar from flask.ext.migrate import Migrate, MigrateCommand from flask.ext.script import Manager from flask.ext.mail import Mail import pytz app = Flask(__name__) app.config.from_pyfile("../config.py.example", silent=True) app.config.from_pyfile("../config.py", silent=True) app.jinja_env.add_extension('pyjade.ext.jinja.PyJadeExtension') manager = Manager(app) db = SQLAlchemy(app) markdown = Markdown(app, safe_mode="escape") login_manager = LoginManager(app) sentry = Sentry(app) gravatar = Gravatar(app, size=48, rating='g', default='identicon', force_default=False, use_ssl=True, base_url=None) babel = Babel(app) supported_languages = ['en', 'de'] migrate = Migrate(app, db) manager.add_command("db", MigrateCommand) mail = Mail(app) default_timezone = pytz.timezone(app.config["DEFAULT_TIMEZONE"])
def create_app(settings): app = Flask(__name__) # Import settings from file for name in dir(settings): value = getattr(settings, name) if not (name.startswith('_') or isinstance(value, ModuleType) or isinstance(value, FunctionType)): app.config[name] = value # Additional settings app.installed_apps = _get_apps_full_names(settings.INSTALLED_APPS) app.secret_key = app.config.get('SESSION_SECRET') # Markdown md = Markdown(app) # TODO: We might want to expose Markdown extensions to the config # file. md.register_extension(nixheaders.makeExtension) # Flask-Funnel Funnel(app) # SeaSurf csrf.init_app(app) # Register error handlers register_error_handlers(app) # Register template filters register_filters(app) for a in app.installed_apps: # Register blueprints app.register_blueprint( getattr(__import__('%s.views' % a, fromlist=['blueprint']), 'blueprint')) @app.context_processor def inject_page(): return dict(page=int(request.args.get('page', 1))) @app.context_processor def globals(): db = get_session(app) ctx = dict() # Projects, teams and current user ctx['projects'] = db.query(Project).order_by(Project.name) ctx['teams'] = db.query(Team).order_by(Team.name) ctx['weeks'] = get_weeks() ctx['current_user'] = None if session and 'user_id' in session: user = db.query(User).get(session['user_id']) if user: ctx['current_user'] = user # Time stuff ctx['today'] = date.today() ctx['yesterday'] = date.today() - timedelta(1) # CSRF def csrf_field(): return ('<div style="display: none;">' '<input type="hidden" name="_csrf_token" value="%s">' '</div>' % csrf._get_token()) ctx['csrf'] = csrf_field return ctx @app.before_request def validate_user(): db = get_session(app) if session and 'email' in session and not 'user_id' in session: user = db.query(User).filter_by(email=session['email']).first() if not user: if request.endpoint not in ('users.new_profile', 'users.authenticate', 'users.logout', 'static'): return redirect(url_for('users.new_profile')) @app.teardown_request def teardown_request(exception=None): # Remove the database session if it exists if hasattr(app, 'db_session'): app.db_session.close() return app
def add_markdown(self): """Add Markdown capability.""" Markdown(self.flask_app, extensions=['fenced_code'], output_format='html5', safe_mode=False)
from flask import Flask from flask.ext.markdown import Markdown from flask.ext.login import LoginManager from flask.ext.mongoengine import MongoEngine app = Flask(__name__, instance_relative_config=True) app.config.from_object('config') app.config.from_pyfile('config.py', silent=True) db = MongoEngine(app) md = Markdown(app) login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = 'login'
from flask.ext.principal import Principal, Permission, RoleNeed from flask.ext.login import LoginManager, current_user from flask.ext.cache import Cache app = Flask(__name__) if os.environ.get('CONFIG_TYPE') == "production": app.config.from_pyfile('/usr/share/doc/flamejam/flamejam.cfg.default') app.config.from_pyfile('/etc/flamejam/flamejam.cfg', silent=True) else: app.config.from_pyfile('../doc/flamejam.cfg.default') app.config.from_pyfile('../flamejam.cfg', silent=True) mail = Mail(app) db = SQLAlchemy(app) markdown_object = Markdown(app, safe_mode="escape") login_manager = LoginManager() login_manager.init_app(app) login_manager.login_view = "login" principals = Principal(app) admin_permission = Permission(RoleNeed('admin')) cache = Cache(app) from flamejam.utils import * import flamejam.filters import flamejam.views import flamejam.models
from flask.ext.bcrypt import Bcrypt from flask.ext.markdown import Markdown from flask.ext.mail import Mail from itsdangerous import URLSafeTimedSerializer # START THE APPLICATION cwd = os.getcwd() static = cwd + "/static" application = Flask( __name__, instance_relative_config=True, static_folder=static) # AWS expects this to be "application," not "app" application.config.from_pyfile("config.py") bcrypt = Bcrypt(application) md = Markdown(application) mail = Mail(application) ts = URLSafeTimedSerializer(application.config["SECRET_KEY"]) # REQUEST HANDLERS @application.before_request def before_request(): g.db = database g.db.connect() @application.after_request def after_request(response): g.db.close() return response
from flask import Flask from flask.ext.login import LoginManager from flask.ext.markdown import Markdown from flask.ext.migrate import Migrate from flask.ext.sqlalchemy import SQLAlchemy from sqlalchemy import exc, event from sqlalchemy.pool import Pool app = Flask(__name__) app.config.from_object('config') # Load Extensions db = SQLAlchemy(app) lm = LoginManager(app) md = Markdown(app, extensions=['markdown.extensions.fenced_code']) migrate = Migrate(app, db) # Load Blueprints from mine.admin import admin from mine.core import core app.register_blueprint(admin, url_prefix="/admin") app.register_blueprint(core) # We're going to inject a variable called "site" # which contains some global site variables # TODO: Move these to redis, maybe pull values on demand? @app.context_processor def inject_site_variable():
from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.migrate import Migrate from flask.ext.markdown import Markdown from flask_uploads import UploadSet, configure_uploads, IMAGES app = Flask(__name__.split('.')[0]) app.config.from_object('settings') db = SQLAlchemy(app) migrate = Migrate(app, db) Markdown(app) uploaded_images = UploadSet('images', IMAGES) configure_uploads(app, uploaded_images) from blog import views from author import views
import os from flask import Flask from flask.ext.markdown import Markdown from .models import db from .cache import cache app = Flask(__package__) app.config.from_object('overviewer.settings.default') if 'OVERVIEWER_SETTINGS' in os.environ: app.config.from_envvar('OVERVIEWER_SETTINGS') db.init_app(app) cache.init_app(app) Markdown(app, extensions=['extra', 'toc', 'codehilite'])
"""Slymoose website""" from flask import Flask, render_template, url_for, redirect from flask.ext.sqlalchemy import SQLAlchemy from flask.ext.login import LoginManager from flask.ext.markdown import Markdown app = Flask('slymoose') app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///slymoose.db' app.secret_key = 'super_secret' markdown_manager = Markdown(app) login_manager = LoginManager(app) db = SQLAlchemy(app) import views @login_manager.user_loader def load_user(userid): from slymoose.models import User return User.query.get(userid)
# | Storage-Adapter # +--------------------------------------------------------------------+ from .ext.backend import MongoAdapter store = MongoAdapter() # +--------------------------------------------------------------------+ # | Flask-Login # +--------------------------------------------------------------------+ from flask.ext.login import LoginManager login_manager = LoginManager() # +--------------------------------------------------------------------+ # | Flask-Markdown # +--------------------------------------------------------------------+ from flask.ext.markdown import Markdown markdown = lambda app: Markdown(app) # +--------------------------------------------------------------------+ # | Flask-Mail # +--------------------------------------------------------------------+ from flask.ext.mail import Mail mail = Mail() # +--------------------------------------------------------------------+ # | Flask-OAuthlib # +--------------------------------------------------------------------+ from flask_oauthlib.client import OAuth oauth = OAuth() # use Google as remote application # you must configure 3 values from Google APIs console
""" DB_UPDATE_ENTRY = """ UPDATE entries SET title=%s, text=%s WHERE id=%s """ DB_DELETE_ENTRY = """ DELETE FROM entries WHERE id=%s """ app = Flask(__name__) md = Markdown(app, extensions=['fenced_code', 'codehilite']) app.config['DATABASE'] = os.environ.get( 'DATABASE_URL', 'dbname=learning_journal user=jbbrokaw') app.config['ADMIN_USERNAME'] = os.environ.get('ADMIN_USERNAME', 'admin') app.config['ADMIN_PASSWORD'] = os.environ.get('ADMIN_PASSWORD', pbkdf2_sha256.encrypt('admin')) app.config['SECRET_KEY'] = os.environ.get('FLASK_SECRET_KEY', 'sooperseekritvaluenooneshouldknow') def requires_auth(view): @wraps(view) def decorated(*args, **kwargs): if 'logged_in' not in session: return render_template('login.html', error="Login required")
assets = Environment(app) assets.url = '/static' assets.directory = app.config['ASSETS_DEST'] less = Bundle('less/style.less', filters='less', output='gen/style.css') assets.register('all-css', less) # Database db = SQLAlchemy(app) import models # Admin import admin # Markdown Markdown(app, safe_mode='escape') # Debug toolbar if app.config['DEBUG']: from flask.ext.debugtoolbar import DebugToolbarExtension as DTE toolbar = DTE(app) # Security datastore = SQLAlchemyUserDatastore(db, models.User, models.Role) security = Security(app, datastore) # Endpoints @app.route('/') def index(): return render_template('index.html', User=models.User)
# assets.url = '/static' # assets.directory = app.config['ASSETS_DEST'] # less = Bundle('less/style.less', filters='less', output='gen/style.css') # assets.register('all-css', less) import forum.forum.views as forum app.register_blueprint(forum.bp, url_prefix='/forum') # Admin from forum import admin admin.attach_admin(app) from util import urlify from flask.ext.markdown import Markdown Markdown(app, safe_mode='escape', extensions=[urlify.URLifyExtension()]) # ======================================================== from app import views, models from .models import Users, Translators CACHE_SIZE = 5000 userIdCache = {} tlGroupIdCache = {} @app.context_processor def utility_processor(): def getUserId(idNo): if idNo in userIdCache:
#Load the configuration file config.py app.config.from_object('config') #Load default bootstrap templates Bootstrap(app) #Initialize the login system loginManager = LoginManager() loginManager.init_app(app) loginManager.login_view = 'login' #Set the default view for logging in #Initialize the database connection db = MongoEngine(app) #Initialize the markdown engine markdown = Markdown(app) markdown.register_extension(AttrListExtension) #Initialize the celery object celery = make_celery(app) #Before each request we should store our current user (provided by flask-login) #in the global object g (which is accessable inside templates) @app.before_request def beforeRequest(): g.user = current_user #Add the custom converters we have made here from app.helpers.converters import BoolConverter, TimeConverter