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'])
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.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)
