def __init__(self, *args, **kwds):
self.startup_token = kwds.pop('startup_token', None)
Flask.__init__(self, *args, **kwds)
self.session_interface = OldSecureCookieSessionInterface()
self.config['SESSION_COOKIE_HTTPONLY'] = False
self.root_path = SAGENB_ROOT
self.add_static_path('/css', os.path.join(DATA, "sage", "css"))
self.add_static_path('/images', os.path.join(DATA, "sage", "images"))
self.add_static_path('/javascript', DATA)
self.add_static_path('/static', DATA)
self.add_static_path('/java', DATA)
self.add_static_path('/java/jmol', os.path.join(os.environ["SAGE_ROOT"],"local","share","jmol"))
self.add_static_path('/jsmol', os.path.join(os.environ["SAGE_ROOT"],"local","share","jsmol"))
self.add_static_path('/jsmol/js', os.path.join(os.environ["SAGE_ROOT"],"local","share","jsmol","js"))
self.add_static_path('/j2s', os.path.join(os.environ["SAGE_ROOT"],"local","share","jsmol","j2s"))
self.add_static_path('/jsmol/j2s', os.path.join(os.environ["SAGE_ROOT"],"local","share","jsmol","j2s"))
self.add_static_path('/j2s/core', os.path.join(os.environ["SAGE_ROOT"],"local","share","jsmol","j2s","core"))
import mimetypes
mimetypes.add_type('text/plain','.jmol')
#######
# Doc #
#######
#These "should" be in doc.py
DOC = os.path.join(SAGE_DOC, 'output', 'html', 'en')
self.add_static_path('/pdf', os.path.join(SAGE_DOC, 'output', 'pdf'))
self.add_static_path('/doc/static', DOC)
def __init__(self, *args, **kwds):
self.startup_token = kwds.pop('startup_token', None)
Flask.__init__(self, *args, **kwds)
self.session_interface = OldSecureCookieSessionInterface()
self.config['SESSION_COOKIE_HTTPONLY'] = False
self.root_path = SAGENB_ROOT
self.add_static_path('/css', os.path.join(DATA, "sage", "css"))
self.add_static_path('/images', os.path.join(DATA, "sage", "images"))
self.add_static_path('/javascript', DATA)
self.add_static_path('/static', DATA)
self.add_static_path('/java', DATA)
self.add_static_path(
'/java/jmol',
os.path.join(os.environ["SAGE_ROOT"], "local", "share", "jmol"))
self.add_static_path(
'/jsmol',
os.path.join(os.environ["SAGE_ROOT"], "local", "share", "jsmol"))
self.add_static_path(
'/jsmol/js',
os.path.join(os.environ["SAGE_ROOT"], "local", "share", "jsmol",
"js"))
self.add_static_path(
'/j2s',
os.path.join(os.environ["SAGE_ROOT"], "local", "share", "jsmol",
"j2s"))
self.add_static_path(
'/jsmol/j2s',
os.path.join(os.environ["SAGE_ROOT"], "local", "share", "jsmol",
"j2s"))
self.add_static_path(
'/j2s/core',
os.path.join(os.environ["SAGE_ROOT"], "local", "share", "jsmol",
"j2s", "core"))
import mimetypes
mimetypes.add_type('text/plain', '.jmol')
#######
# Doc #
#######
#These "should" be in doc.py
DOC = os.path.join(SAGE_DOC, 'html', 'en')
self.add_static_path('/pdf', os.path.join(SAGE_DOC, 'pdf'))
self.add_static_path('/doc/static', DOC)
# Template globals
self.add_template_global(url_for)
# Template filters
self.add_template_filter(css_escape)
self.add_template_filter(number_of_rows)
self.add_template_filter(clean_name)
self.add_template_filter(prettify_time_ago)
self.add_template_filter(max)
self.add_template_filter(lambda x: repr(unicode_str(x))[1:],
name='repr_str')
self.add_template_filter(dumps, 'tojson')
def create_app_ext(flask_config_file=None,
flask_config_dict=None,
moin_config_class=None,
warn_default=True,
**kwargs):
"""
Factory for moin wsgi apps
:param flask_config_file: a flask config file name (may have a MOINCFG class),
if not given, a config pointed to by MOINCFG env var
will be loaded (if possible).
:param flask_config_dict: a dict used to update flask config (applied after
flask_config_file was loaded [if given])
:param moin_config_class: if you give this, it'll be instantiated as app.cfg,
otherwise it'll use MOINCFG from flask config. If that
also is not there, it'll use the DefaultConfig built
into MoinMoin.
:param warn_default: emit a warning if moin falls back to its builtin default
config (maybe user forgot to specify MOINCFG?)
:param kwargs: if you give additional keyword args, the keys/values will get patched
into the moin configuration class (before its instance is created)
"""
clock = Clock()
clock.start('create_app total')
app = Flask('moin')
if OldSecureCookieSessionInterface:
app.session_interface = OldSecureCookieSessionInterface()
clock.start('create_app load config')
if flask_config_file:
app.config.from_pyfile(flask_config_file)
else:
if not app.config.from_envvar('MOINCFG', silent=True):
# no MOINCFG env variable set, try stuff in cwd:
from os import path
flask_config_file = path.abspath('wikiconfig_local.py')
if not path.exists(flask_config_file):
flask_config_file = path.abspath('wikiconfig.py')
if not path.exists(flask_config_file):
flask_config_file = None
if flask_config_file:
app.config.from_pyfile(flask_config_file)
if flask_config_dict:
app.config.update(flask_config_dict)
Config = moin_config_class
if not Config:
Config = app.config.get('MOINCFG')
if not Config:
if warn_default:
logging.warning("using builtin default configuration")
from moin.config.default import DefaultConfig as Config
for key, value in kwargs.iteritems():
setattr(Config, key, value)
if Config.secrets is None:
# reuse the secret configured for flask (which is required for sessions)
Config.secrets = app.config.get('SECRET_KEY')
app.cfg = Config()
clock.stop('create_app load config')
clock.start('create_app register')
# register converters
from werkzeug.routing import BaseConverter
class ItemNameConverter(BaseConverter):
"""Like the default :class:`UnicodeConverter`, but it also matches
slashes (except at the beginning AND end).
This is useful for wikis and similar applications::
Rule('/<itemname:wikipage>')
Rule('/<itemname:wikipage>/edit')
"""
regex = '[^/]+?(/[^/]+?)*'
weight = 200
app.url_map.converters['itemname'] = ItemNameConverter
# register modules, before/after request functions
from moin.apps.frontend import frontend
frontend.before_request(before_wiki)
frontend.teardown_request(teardown_wiki)
app.register_blueprint(frontend)
from moin.apps.admin import admin
admin.before_request(before_wiki)
admin.teardown_request(teardown_wiki)
app.register_blueprint(admin, url_prefix='/+admin')
from moin.apps.feed import feed
feed.before_request(before_wiki)
feed.teardown_request(teardown_wiki)
app.register_blueprint(feed, url_prefix='/+feed')
from moin.apps.misc import misc
misc.before_request(before_wiki)
misc.teardown_request(teardown_wiki)
app.register_blueprint(misc, url_prefix='/+misc')
from moin.apps.serve import serve
app.register_blueprint(serve, url_prefix='/+serve')
clock.stop('create_app register')
clock.start('create_app flask-cache')
cache = Cache()
cache.init_app(app)
app.cache = cache
clock.stop('create_app flask-cache')
# init storage
clock.start('create_app init backends')
init_backends(app)
clock.stop('create_app init backends')
clock.start('create_app flask-babel')
i18n_init(app)
clock.stop('create_app flask-babel')
# configure templates
clock.start('create_app flask-theme')
setup_themes(app)
if app.cfg.template_dirs:
app.jinja_env.loader = ChoiceLoader([
FileSystemLoader(app.cfg.template_dirs),
app.jinja_env.loader,
])
app.register_error_handler(403, themed_error)
clock.stop('create_app flask-theme')
clock.stop('create_app total')
del clock
return app
app.register_blueprint(accounting.purchase.app, url_prefix='/purchase')
app.register_blueprint(accounting.invoicing.app, url_prefix='/invoicing')
try:
pagedomain = flaskext.babel.Domain(dirname=os.path.join(top, 'locale'),
domain='accounting')
babel = flaskext.babel.Babel(app, default_domain=pagedomain)
except NameError:
app.config['BABEL_TRANSLATION_DIRECTORIES'] = os.path.join(top, 'locale')
babel = flask_babel.Babel(app)
babel.localeselector(lambda: accounting.lang.get_language(request))
try:
from flask_oldsessions import OldSecureCookieSessionInterface
app.session_interface = OldSecureCookieSessionInterface()
except ImportError:
pass
def _set_secret_key(app):
if getattr(app, 'secret_key', None) is not None:
return
accounting.db.connect() # xxx is this necessary?
app.secret_key = b'min hemliga nyckel!'
debug = __name__ == '__main__'
USER_ACCESS_RESOLUTION = 12 * 60 * 60 # 12 hours