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
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'
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"])
#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 app.url_map.converters['bool'] = BoolConverter
#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
def create_app(name, config_object, override=None): """App factory. The factory pattern makes unit testing much saner. :param name: the name of the app :param config_object: path to config object """ app = Flask(name) app.json_encoder = LSOJSONEncoder try: app.config.from_object(config_object) except ImportError: print 'ImportError with config object:', config_object pass if override: app.config.update(override) # Needed to locate templates and assets in various contexts (runserver, # testing, ...) # TODO: surely there's a way to avoid this? LSO_PATH = os.path.dirname(__file__) app.template_folder = os.path.join(LSO_PATH, 'templates') app.static_folder = os.path.join(LSO_PATH, 'static') # Template filters for _filter in template_filters: app.add_template_filter(_filter) # URL converters add_converters(app) # Extensions lso.admin.admin.init_app(app) assets.init_app(app) assets.app = app # TODO: remove hack assets.url = '/static' assets.directory = app.config['STATIC_DEST'] cache.init_app(app) lso.database.db.init_app(app) mail.init_app(app) md = Markdown(app, extensions=['admonition']) from ext_markdown import SanskritExtension md.register_extension(SanskritExtension) # security.init_app(app) # 'sanskrit' package global ctx, simple_query, simple_analyzer ctx = sanskrit.Context(app.config) ctx.connect() try: simple_query = sanskrit.query.SimpleQuery(ctx) simple_analyzer = sanskrit.analyze.SimpleAnalyzer(ctx) except (sqlalchemy.exc.ProgrammingError, sqlalchemy.exc.OperationalError): simple_query = None simple_analyzer = None # Debug toolbar if app.debug: from flask.ext.debugtoolbar import DebugToolbarExtension toolbar = DebugToolbarExtension(app) # Blueprints if app.debug: import debug app.register_blueprint(debug.debug) else: do_logging(app) import views app.register_blueprint(views.main) register_blueprints(app, 'dicts', 'guide', 'ref', 'site', 'texts', 'tools', #'users' ) return app
""" 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")
"""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)
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
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
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
assets.register('all-js', js) # Admin # ----- import admin # Mail # ---- mail = Mail(app) # Markdown # -------- md = Markdown(app, extensions=['admonition']) from ext_markdown import SanskritExtension md.register_extension(SanskritExtension) # Sanskrit # -------- ctx = Context(app.config) ctx.connect() try: simple_query = query.SimpleQuery(ctx) simple_analyzer = analyze.SimpleAnalyzer(ctx) except sqlalchemy.exc.ProgrammingError: simple_query = None simple_analyzer = None
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__) # dtatbase app.config.from_object('settings') db = SQLAlchemy(app) # Migrate migrate = Migrate(app,db) # Markdown markdown = Markdown(app) #images uploaded_images = UploadSet('images', IMAGES) configure_uploads(app, uploaded_images) from blog import views from author import views
def add_markdown(self): """Add Markdown capability.""" Markdown(self.flask_app, extensions=['fenced_code'], output_format='html5', safe_mode=False)
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'])
# 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:
# | 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
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
def create_app(config_mode=None, config_file=None): """Create webapp instance""" # Flask application app = Flask(__name__) Bootstrap(app) md = Markdown(app, extensions=['toc']) md.register_extension(TableExtension) 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) table = app.config['TABLE'] @app.before_request def before_request(): # set g variables stream = file(app.config['INFO_PATH'], 'r') [setattr(g, k, v) for k, v in yaml.safe_load(stream).items()] g.site = app.config['SITE'] g.valid_until = (d.today() + timedelta(days=g.days_valid)).strftime( "%B %d, %Y") # Views @app.route('/<style>/') @app.route('/<style>/<source>/') def index(style, source=None): source = source or request.args.get('source') if source: parent = p.dirname(p.dirname(__file__)) path = p.join(parent, source) stream = file(path, 'r') items = yaml.safe_load(stream).items() [setattr(g, k, v) for k, v in items] return render_template('%s.html' % style).replace('<table>', table) @app.route('/render/<style>/') @app.route('/render/<style>/<otype>/') def render(style, otype=None): otype = otype or request.args.get('type', 'html') source = request.args.get('source') if source: parent = p.dirname(p.dirname(__file__)) path = p.join(parent, source) stream = file(path, 'r') items = yaml.safe_load(stream).items() [setattr(g, k, v) for k, v in items] if otype.startswith('html'): html = render_template('%s.html' % style).replace('<table>', table) html_doc = HTML(string=html) stylesheets = find_stylesheets( html_doc.root_element, html_doc.media_type, html_doc.url_fetcher, ) urls = [sheet.base_url for sheet in stylesheets] style_urls = filter(lambda x: x.endswith('css'), urls) styles = _get_styles(app, style_urls) kwargs = {'styles': styles} if source: [setattr(g, k, v) for k, v in items] return render_template('%s.html' % style, **kwargs).replace( '<table>', table) elif otype.startswith('md'): h = html2text.HTML2Text() # h.ignore_links = True h.ignore_emphasis = True h.body_width = 65 return h.handle(render_template('%s.html' % style)) elif otype.startswith('pdf'): kwargs = {'to_print': True} return render_pdf(url_for('index', style=style)) elif otype.startswith('png'): kwargs = {'to_print': True} html = render_template('%s.html' % style, **kwargs).replace( '<table>', table) html_doc = HTML(string=html) return Response(html_doc.write_png(), mimetype='image/png') else: pass return app
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)