def __init__(self, ctx):
# Convert paths and ids to utf-8, otherwise werkzeug will break
self.exports = dict(imap(
lambda x: (x[0].encode('utf-8'), x[1].encode('utf-8')),
self.exports.items()))
IMiddleware.__init__(self, ctx)
SharedDataMiddleware.__init__(self, self.application, self.exports)
def create_app():
instance_path = path(__file__).abspath().parent / 'instance'
app = flask.Flask(__name__,
instance_path=instance_path,
instance_relative_config=True)
app.config.update(default_config)
app.config.from_pyfile("settings.py", silent=True)
sentry.init_app(app)
app.register_blueprint(views.lists)
app.register_blueprint(views.flis)
_my_extensions = app.jinja_options["extensions"] + ["jinja2.ext.do"]
template_loader = jinja2.ChoiceLoader([
frame.FrameTemplateLoader(),
app.create_global_jinja_loader(),
])
app.jinja_options = dict(app.jinja_options,
extensions=_my_extensions,
loader=template_loader)
database.initialize_app(app)
if app.config['DEBUG']:
files_path = path(app.root_path)
files_path = flask.safe_join(files_path, "instance/files")
app.wsgi_app = SharedDataMiddleware(app.wsgi_app, {
"/static/files": files_path,
})
if app.config["HTTP_PROXIED"]:
from revproxy import ReverseProxied
app.wsgi_app = ReverseProxied(app.wsgi_app)
return app
def upload(self, name=None, path=None, folder='upload',\
allowed_extensions=None, max_size=None):
"""
ckeditor upload method
:name: the app name or blueprint name
:path: the upload path
:allowed_extensions: allowed file extensions
:max_size: the max size of uploaded file
"""
error = ''
url = ''
callback = request.args.get("CKEditorFuncNum")
if request.method == 'POST' and 'upload' in request.files:
fileobj = request.files['upload']
fname, fext = os.path.splitext(fileobj.filename)
if allowed_extensions and \
fext not in allowed_extensions:
error = '%s not in the allowed extensions!' % fext
return error
rnd_name = '%s%s' % (self.gen_rnd_filename(), fext)
if not path:
filepath = os.path.join(name.static_folder, 'upload', rnd_name)
else:
filepath = path
app.add_url_rule('/ckupload/<filename>',
'uploaded_file',
build_only=True)
app.wsgi_app = SharedDataMiddleware(app.wsgi_app,
{'/ckupload/': path})
dirname = os.path.dirname(filepath)
if not os.path.exists(dirname):
try:
os.makedirs(dirname)
except:
error = 'path <%s> not exist!' % filepath
elif not os.access(dirname, os.W_OK):
error = 'path <%s> not writable' % filepath
if not error:
fileobj.save(filepath)
url = url_for('.static',
filename='%s/%s' % ('upload', rnd_name))
# if not path:
# url = url_for('.static', filename='%s/%s' % (folder, rnd_name))
# else:
# url = url_for('.uploaded_file', filename='%s/%s' % (folder, rnd_name))
else:
error = 'post error'
res = """
<script type="text/javascript">
window.parent.CKEDITOR.tools.callFunction('%s', '%s', '%s');
</script>
""" % (callback, url, error)
response = make_response(res)
response.headers["Content-Type"] = "text/html"
return response
def prepare(self):
local.fp = self
self.prepared = True
@self.app.before_request
def before_request():
g.start = time.time()
if self.config.DEBUG:
@self.app.after_request
def after_request(response):
diff = time.time() - g.start
if (response.response):
response.headers["Execution-Time"] = str(diff)
return response
self.app.add_url_rule(self.app.config['UPLOAD_DIRECTORY_URL'] +
'<filename>',
'FyPress.uploaded_file',
build_only=True)
self.app.wsgi_app = SharedDataMiddleware(
self.app.wsgi_app, {
self.app.config['UPLOAD_DIRECTORY_URL']:
self.app.config['UPLOAD_DIRECTORY']
})
self.blueprint()
def make_wsgi(profile='Default'):
config.appinit(settingsmod, profile)
app = WSGIApp()
app = ElixirApp(app)
app = SessionMiddleware(app, **dict(settings.beaker))
app = RegistryManager(app)
# serve static files from main app and supporting apps (need to reverse order b/c
# middleware stack is run in bottom up order). This works b/c if a
# static file isn't found, the ShardDataMiddleware just forwards the request
# to the next app.
for appname in config.appslist(reverse=True):
app_py_mod = __import__(appname)
fs_static_path = path.join(path.dirname(app_py_mod.__file__), 'static')
static_map = {routing.add_prefix('/'): fs_static_path}
app = SharedDataMiddleware(app, static_map)
# show nice stack traces and debug output if enabled
if settings.debugger.enabled:
app = DebuggedApplication(app, evalex=settings.debugger.interactive)
return app
def __init__(self, debug):
local.application = self
iptables.reset(config["interface_lan"], config["interface_wan"])
for addr in user.getmacs():
iptables.addmac(addr)
self.debug = debug
self.dispatch = SharedDataMiddleware(self.safedispatch, {"/static": path["static"]})
def setup_static(sender):
'''Setup static file serving in dev environment'''
from werkzeug import SharedDataMiddleware
import os
app.wsgi_app = SharedDataMiddleware(
app.wsgi_app,
{'/': os.path.join(os.path.dirname(__file__), 'static')})
def prepare(self):
self.prepared = True
# Cache
if self.config.CACHE_TYPE == 'redis':
self.cache = RedisCache(host=self.config.CACHE_SERV)
elif self.config.CACHE_TYPE == 'memcached':
self.cache = MemcachedCache(servers=[self.config.CACHE_SERV])
else:
self.cache = FileSystemCache(self.config.CACHE_SERV)
# Options
from .admin import Option
self.options = Option.auto_load()
# Timer
@self.app.before_request
def before_request():
g.start = time.time()
# Medias
self.app.add_url_rule(self.app.config['UPLOAD_DIRECTORY_URL'] +
'<filename>',
'FyPress.uploaded_file',
build_only=True)
self.app.wsgi_app = SharedDataMiddleware(
self.app.wsgi_app, {
self.app.config['UPLOAD_DIRECTORY_URL']:
self.app.config['UPLOAD_DIRECTORY']
})
def make_app(session_store=None):
application = Application(session_store=session_store)
application = SharedDataMiddleware(application, staticLocations)
application = local_manager.make_middleware(application)
if config.getboolean('debugging', 'debug') is True:
application = DebuggedApplication(application, evalex=True)
return application
def make_app(dburi, secret_key, debug=False, shell=False):
"""Apply the used middlewares and create the application."""
static_path = os.path.join(os.path.dirname(__file__), 'static')
app = LodgeIt(dburi, secret_key)
if debug:
app.engine.echo = True
if not shell:
# we don't need access to the shared data middleware in shell mode
app = SharedDataMiddleware(app, {'/static': static_path})
return app
def __init__(self):
local.application = self
storage_class = import_string(settings.SESSION_STORE)
if not os.path.isdir(settings.SESSION_PATH):
os.makedirs(settings.SESSION_PATH)
self.dispatch = SessionMiddleware(
self.dispatch, storage_class(path=settings.SESSION_PATH))
self.dispatch = SharedDataMiddleware(self.dispatch, {
'/media': settings.MEDIA_ROOT,
})
def __init__(self, database_uri):
self.database_engine = create_engine(database_uri)
# apply our middlewares. we apply the middlewars *inside* the
# application and not outside of it so that we never lose the
# reference to the `SimpleWiki` object.
self._dispatch = SharedDataMiddleware(self.dispatch_request,
{'/_shared': SHARED_DATA})
# free the context locals at the end of the request
self._dispatch = local_manager.make_middleware(self._dispatch)
def create_app(name=__name__, config={}):
app = Flask(name)
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DB_URI')
# app.config['SQLALCHEMY_POOL_SIZE'] = 10
app.secret_key = config.get('secret_key', '(secret key is not set)')
app.config.update(config)
from app.analysis.model import db
db.init_app(app)
from app.api import api_module
from app.main import main_module
from app.corpus import corpus_module
app.register_blueprint(api_module, url_prefix='')
app.register_blueprint(main_module, url_prefix='')
app.register_blueprint(corpus_module, url_prefix='/corpus')
from app.utils import register_filters
register_filters(app)
babel.init_app(app)
if app.config['DEBUG']:
from werkzeug import SharedDataMiddleware
app.wsgi_app = SharedDataMiddleware(
app.wsgi_app,
{'/': os.path.join(os.path.dirname(__file__), 'static')})
@app.before_first_request
def init_rollbar():
"""init rollbar module"""
rollbar.init(
# access token
os.environ.get('ROLLBAR_TOKEN', ''),
# environment name
os.environ.get('ROLLBAR_ENV', 'development'),
# server root directory, makes tracebacks prettier
root=os.path.dirname(os.path.realpath(__file__)),
# flask already sets up logging
allow_logging_basic_config=False,
# Use HTTP as GAE does not allow the use of the SSL package
endpoint='http://api.rollbar.com/api/1/')
# send exceptions from `app` to rollbar, using flask's signal system.
got_request_exception.connect(rollbar.contrib.flask.report_exception,
app)
if babel.locale_selector_func is None:
babel.localeselector(get_locale)
return app
def create_app(config_name='development'):
app = Flask(__name__)
app.config.from_object(config[config_name])
app.elasticsearch = Elasticsearch([app.config['ELASTICSEARCH_URL']]) \
if app.config['ELASTICSEARCH_URL'] else None
config[config_name].init_app(app)
db.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
pagedown.init_app(app)
moment.init_app(app)
lesscss(app)
app.add_url_rule('/uploads/<filename>', 'uploads', build_only=True)
app.wsgi_app = SharedDataMiddleware(
app.wsgi_app, {'/uploads': app.config['UPLOAD_FOLDER']})
app.memory = base.Client(('localhost', 11211))
from .errors import errors
app.register_blueprint(errors)
from .main import main
app.register_blueprint(main)
from .auth import auth
app.register_blueprint(auth)
from .admin import admin
app.register_blueprint(admin)
from .moderator import moderator
app.register_blueprint(moderator)
from .user import user
app.register_blueprint(user)
from .post import post
app.register_blueprint(post)
from .comment import comment
app.register_blueprint(comment)
from .notice import notice
app.register_blueprint(notice)
from .api_1_0 import api as api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/api/v1.0')
return app
def _setup_static_handler(self):
from werkzeug import SharedDataMiddleware
self.app.wsgi_app = SharedDataMiddleware(
self.app.wsgi_app, {
'/': os.path.normpath(self.www_path),
},
cache=False)
@self.app.route('/', methods=['GET'])
def index_get():
with open(os.path.join(self.www_path, 'index.html'), 'r') as fd:
return fd.read()
def __init__(self, db_uri):
local.application = self
server = Server(db_uri)
try:
db = server.create('urls')
except:
db = server['urls']
self.dispatch = SharedDataMiddleware(self.dispatch, {
'/static': STATIC_PATH
})
URL.db = db
def __init__(self, hostname, port, database, debug=False):
self.hostname = hostname
self.port = port
self.debug = debug
app.debug = debug
app.secret_key = 'dummy_secret_key' if debug else os.urandom(24)
app.wsgi_app = SharedDataMiddleware(
app.wsgi_app,
{'/': os.path.join(os.path.dirname(__file__), 'static')})
op.open_db(database)
logger.info('crawler setup: hostname {0}, port {1}, db {2}, debug {3}',
hostname, port, database, debug)
def create_app(config_name='development'):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
db.init_app(app)
mail.init_app(app)
login_manager.init_app(app)
app.add_url_rule('/uploads/<filename>', 'uploads', build_only=True)
app.wsgi_app = SharedDataMiddleware(
app.wsgi_app, {'/uploads': app.config['UPLOAD_FOLDER']})
from .ex import ex
app.register_blueprint(ex)
return app
def _configure_uploads(app):
app.config['FILES_PATH'] = files_path = Path(app.instance_path) / 'files'
app.config['PATH_BACKGROUNDS_KEY'] = path_backgrounds_key = 'backgrounds'
app.config['PATH_CROP_KEY'] = path_crop_key = 'crops'
app.config['PATH_CUSTOM_KEY'] = path_custom_key = 'custom_uploads'
app.config['PATH_LOGOS_KEY'] = path_logos_key = 'logos'
app.config['PATH_THUMB_KEY'] = path_thumb_key = 'thumbnails'
app.config['PATH_PRINTOUTS_KEY'] = path_printouts_key = 'printouts'
if 'UPLOADED_BACKGROUNDS_DEST' not in app.config:
app.config['UPLOADED_BACKGROUNDS_DEST'] = (files_path /
path_backgrounds_key)
if 'UPLOADED_CROP_DEST' not in app.config:
app.config['UPLOADED_CROP_DEST'] = files_path / path_crop_key
if 'UPLOADED_CUSTOM_DEST' not in app.config:
app.config['UPLOADED_CUSTOM_DEST'] = files_path / path_custom_key
if 'UPLOADED_LOGOS_DEST' not in app.config:
app.config['UPLOADED_LOGOS_DEST'] = files_path / path_logos_key
if 'UPLOADED_PRINTOUTS_DEST' not in app.config:
app.config['UPLOADED_PRINTOUTS_DEST'] = files_path / path_printouts_key
# ensure logos and printouts folders exist
app.config['UPLOADED_LOGOS_DEST'].makedirs_p()
app.config['UPLOADED_PRINTOUTS_DEST'].makedirs_p()
if 'MEDIA_FOLDER' not in app.config:
app.config['MEDIA_FOLDER'] = files_path
if 'MEDIA_THUMBNAIL_FOLDER' not in app.config:
app.config['MEDIA_THUMBNAIL_FOLDER'] = \
app.config['UPLOADED_THUMBNAIL_DEST'] = files_path / path_thumb_key
app.config['MEDIA_THUMBNAIL_URL'] = '/static/files/thumbnails/'
app.add_url_rule('/static/files/<filename>', 'files', build_only=True)
app.wsgi_app = SharedDataMiddleware(app.wsgi_app, {
'/static/files': files_path,
})
# limit upload size to 1MB
patch_request_class(app, app.config.get(
'MAX_UPLOAD_SIZE', 1 * 1024 * 1024))
configure_uploads(app, (backgrounds, custom_upload, logos_upload))
Thumbnail(app)
def run_server():
from gevent import monkey
monkey.patch_all(subprocess=True)
from gevent.wsgi import WSGIServer
import socket
from geventwebsocket.handler import WebSocketHandler
os.environ['CONFIG'] = CONFIG
from lightop import app
if not DEBUG: # run on NAS
from werkzeug import SharedDataMiddleware
app.wsgi_app = SharedDataMiddleware(
app.wsgi_app,
{'/': os.path.join(os.path.dirname(__file__), 'static')})
# websocket conflict: WebSocketHandler
if DEBUG or STAGING:
# from werkzeug.debug import DebuggedApplication
app.debug = True
# app = DebuggedApplication(app, evalex=True)
print('Fork monitor programs')
pgid = os.getpgid(0)
procs = []
procs.extend([
subprocess.Popen(program, close_fds=True, shell=True)
for program in PROGRAMS
])
signal.signal(signal.SIGTERM, lambda *args: killpg(pgid))
signal.signal(signal.SIGHUP, lambda *args: killpg(pgid))
signal.signal(signal.SIGINT, lambda *args: killpg(pgid))
print('Running on port ' + str(PORT))
try:
http_server = WSGIServer(('', PORT),
app,
handler_class=WebSocketHandler)
http_server.serve_forever()
except socket.error as e:
print(e)
def setup_env():
from werkzeug import SharedDataMiddleware
import os
application.wsgi_app = SharedDataMiddleware(
application.wsgi_app,
{'/': os.path.join(os.path.dirname(__file__), 'static')})
application.config["DEBUG_TB_INTERCEPT_REDIRECTS"] = False
application.config["DEBUG_TB_PROFILER_ENABLED"] = False
application.config['DEBUG_TB_PANELS'] = (
'flask_debugtoolbar.panels.headers.HeaderDebugPanel',
'flask_debugtoolbar.panels.logger.LoggingPanel',
'flask_debugtoolbar.panels.timer.TimerDebugPanel',
'flask_debugtoolbar.panels.profiler.ProfilerDebugPanel',
'flask_debugtoolbar.panels.request_vars.RequestVarsDebugPanel',
# 'flask_debugtoolbar.panels.template.TemplateDebugPanel',
# 'flask_debugtoolbar.panels.versions.VersionDebugPanel',
'flask_mongoengine.panels.MongoDebugPanel')
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension(application)
def make_static_serving_app(application, shared):
"""
wrap application in a static file serving app
@param application: WSGI wiki application that should be wrapped
@param shared: directory where static files are located (then we create the
usual mapping dict we need automatically), or a ready-to-use
mapping dict for SharedDataMiddleware.
If True, use builtin static files from STATIC_FILES_PATH.
@returns: wrapped WSGI application
"""
if not isinstance(shared, dict):
if shared is True:
shared = STATIC_FILES_PATH
if isdir(shared):
shared = {config.url_prefix_static: shared,
# XXX only works / makes sense for root-mounted wikis:
'/favicon.ico': join(shared, 'favicon.ico'),
'/robots.txt': join(shared, 'robots.txt')}
else:
raise ValueError("Invalid path given for shared parameter")
return SharedDataMiddleware(application, shared)
def __call__(self, name, **kwargs):
self.app = Flask(name, **kwargs)
self.app.config.from_object(self.config)
self.bind_extensions(db, mail, celery, csrf, cache, htmlmin, toolbar)
register_connection(DB_TEMP_NAME, DB_TEMP_NAME)
self.app.session_interface = MongoEngineSessionInterface(db)
self.app.permanent_session_lifetime = timedelta(weeks=1)
self.app.user_datastore = MongoEngineUserDatastore(db, User, Role)
self.app.security = Security(self.app,
self.app.user_datastore,
login_form=ExtLoginForm)
@self.app.security.send_mail_task
def delay_security_email(msg):
send_security_mail.delay(msg)
# @self.app.errorhandler(Exception)
# def validation_error(err):
# flash(err.message, 'error')
# return redirect(request.path)
self.register_blueprints(BLUEPRINTS)
self.register_template_filters(time_distance, is_list, smart_round,
pretty_date, phonofize)
self.register_context_processors(categories, cart, visited_offers,
pages)
self.app.jinja_env.globals['get_plural'] = get_plural
self.app.add_url_rule('/media/<filename>', 'media', build_only=True)
self.app.wsgi_app = SharedDataMiddleware(
self.app.wsgi_app, {'/media': self.app.config['MEDIA_DIR']})
return self.app
def create_app(config_name='default'):
'''
factory function creates and initialize app instance
'''
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
# init of plugins
db.init_app(app)
mako.init_app(app)
# blueprints
from app.main import main as main_blueprint
app.register_blueprint(main_blueprint)
# TODO: ?
# http://flask.palletsprojects.com/en/1.1.x/patterns/fileuploads/
# Read source file by SharedDataMiddleware
app.wsgi_app = SharedDataMiddleware(app.wsgi_app,
{'/i/': app.config['UPLOAD_FOLDER']})
return app
modal.endSession()
mydict = {}
foodDetected = foodDetected.replace("'", "")
foodDetected = foodDetected.replace(" ", "")
splitted = foodDetected.split(",")
for v in splitted:
aux = v.split(":")
mydict[aux[0]] = aux[2]
imgUrl = url_for('send_file', filename=filename)
return render_template(
'detection.html',
imgUrl=imgUrl,
foodDetected=mydict,
totalPrice=calculate_item.calculatePrice(mydict))
return render_template('upload.html', filename=filename)
@app.route('/uploads/<filename>')
def send_file(filename):
return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
from werkzeug import SharedDataMiddleware
app.add_url_rule('/uploads/<filename>', 'uploaded_file', build_only=True)
app.wsgi_app = SharedDataMiddleware(app.wsgi_app,
{'/upload': app.config['UPLOAD_FOLDER']})
if __name__ == '__main__':
socketio.run(app)
def create_instance():
"""
Construct a new Flask instance and return it.
"""
import os
app = Flask(__name__)
app.config.from_object('notifico.config')
if app.config.get('NOTIFICO_ROUTE_STATIC'):
# We should handle routing for static assets ourself (handy for
# small and quick deployments).
import os.path
from werkzeug import SharedDataMiddleware
app.wsgi_app = SharedDataMiddleware(
app.wsgi_app,
{'/': os.path.join(os.path.dirname(__file__), 'static')})
if not app.debug:
# If sentry (http://getsentry.com) is configured for
# error collection we should use it.
if app.config.get('SENTRY_DSN'):
sentry.dsn = app.config.get('SENTRY_DSN')
sentry.init_app(app)
# Setup our redis connection (which is already thread safe)
app.redis = Redis(host=app.config['REDIS_HOST'],
port=app.config['REDIS_PORT'],
db=app.config['REDIS_DB'])
# Attach Flask-Cache to our application instance. We override
# the backend configuration settings because we only want one
# Redis instance.
cache.init_app(app,
config={
'CACHE_TYPE': 'redis',
'CACHE_REDIS_HOST': app.redis,
'CACHE_OPTIONS': {
'key_prefix': 'cache_'
}
})
# Attach Flask-Mail to our application instance.
mail.init_app(app)
# Attach Flask-SQLAlchemy to our application instance.
db.init_app(app)
# Update celery's configuration with our application config.
celery.config_from_object(app.config)
# Import and register all of our blueprints.
from notifico.views.account import account
from notifico.views.public import public
from notifico.views.projects import projects
from notifico.views.pimport import pimport
from notifico.views.admin import admin
app.register_blueprint(account, url_prefix='/u')
app.register_blueprint(projects)
app.register_blueprint(public)
app.register_blueprint(pimport, url_prefix='/i')
app.register_blueprint(admin, url_prefix='/_')
# Register our custom error handlers.
from notifico.views import errors
app.register_error_handler(500, errors.error_500)
# cia.vc XML-RPC kludge.
from notifico.services.hooks.cia import handler
handler.connect(app, '/RPC2')
# Setup some custom Jinja2 filters.
app.jinja_env.filters['pretty_date'] = pretty.pretty_date
app.jinja_env.filters['plural'] = pretty.plural
app.jinja_env.filters['fix_link'] = pretty.fix_link
return app
logging.basicConfig(filename=options.logfile, level=log_level)
app.config['SQLALCHEMY_DATABASE_URI'] = options.db
app.config['DEBUG'] = True
app.config['SECRET_KEY'] = 'NOT A SECRET'
app.config.update(cef_config(options.cef_log))
with app.test_request_context():
db.init_app(app)
db.create_all()
def auth(environ, username, password):
return options.username == username and options.password == password
if app.config['DEBUG']:
# Setting up the cron/ directory with some testing data
# In production, this is managed by Apache and the json file is going to be override
# by the cron (see bug 1155935)
from werkzeug import SharedDataMiddleware
app.wsgi_app = SharedDataMiddleware(
app.wsgi_app,
{'/cron/': path.join(path.dirname(__file__), 'cron/')})
# We serve (at least) a stastic json file
from werkzeug import SharedDataMiddleware
app.wsgi_app = SharedDataMiddleware(
app.wsgi_app, {'/json/': path.join(path.dirname(__file__), 'json/')})
app.wsgi_app = AuthBasicHandler(app.wsgi_app, "Release kick-off", auth)
app.run(port=options.port, host=options.host)
if callback:
data = str(func(*args, **kwargs)['data'])
content = str(callback) + '(' + data + ')'
mimetype = 'application/javascript'
return current_app.response_class(content, mimetype=mimetype)
else:
return func(*args, **kwargs)['data']
return decorated_function
def get_4sq_place(location):
places = client.venues.search(params={'near':location})
venues = []
for venue in places['venues']:
venue['_id'] = venue['id'] #maybe create a copy?
venues.append(venue)
#TODO(mbhagat): check if the id already exists and update it
places_collection = db['foursquare_places']
places_collection.insert(venues)
return places;
if __name__ == "__main__":
# Bind to PORT if defined, otherwise default to 5000.
port = int(os.environ.get('PORT', 5000))
from werkzeug import SharedDataMiddleware
app.wsgi_app = SharedDataMiddleware(app.wsgi_app, {
'/': os.path.join(os.path.dirname(__file__), 'client/app')
})
app.debug = True
app.run(host='0.0.0.0', port=port)
def webapp():
static_path = os.path.join(os.path.dirname(__file__), 'static')
return SharedDataMiddleware(WebApp(), {'/javascript': static_path})
def __init__(self, package_name):
#: the debug flag. Set this to `True` to enable debugging of
#: the application. In debug mode the debugger will kick in
#: when an unhandled exception ocurrs and the integrated server
#: will automatically reload the application if changes in the
#: code are detected.
self.debug = False
#: the name of the package or module. Do not change this once
#: it was set by the constructor.
self.package_name = package_name
#: where is the app root located?
# 项目根路径
self.root_path = _get_package_path(self.package_name)
#: a dictionary of all view functions registered. The keys will
#: be function names which are also used to generate URLs and
#: the values are the function objects themselves.
#: to register a view function, use the :meth:`route` decorator.
# 视图函数存储字典
self.view_functions = {}
#: a dictionary of all registered error handlers. The key is
#: be the error code as integer, the value the function that
#: should handle that error.
#: To register a error handler, use the :meth:`errorhandler`
#: decorator.
# 错误处理函数存储字典
self.error_handlers = {}
#: a list of functions that should be called at the beginning
#: of the request before request dispatching kicks in. This
#: can for example be used to open database connections or
#: getting hold of the currently logged in user.
#: To register a function here, use the :meth:`before_request`
#: decorator.
# 预处理函数存储字典, 预处理: 请求处理前执行
self.before_request_funcs = []
#: a list of functions that are called at the end of the
#: request. Tha function is passed the current response
#: object and modify it in place or replace it.
#: To register a function here use the :meth:`after_request`
#: decorator.
# 请求处理后执行函数存储字典
self.after_request_funcs = []
#: a list of functions that are called without arguments
#: to populate the template context. Each returns a dictionary
#: that the template context is updated with.
#: To register a function here, use the :meth:`context_processor`
#: decorator.
self.template_context_processors = [_default_template_ctx_processor]
self.url_map = Map()
if self.static_path is not None:
self.url_map.add(Rule(self.static_path + '/<filename>',
build_only=True, endpoint='static'))
if pkg_resources is not None:
target = (self.package_name, 'static')
else:
target = os.path.join(self.root_path, 'static')
self.wsgi_app = SharedDataMiddleware(self.wsgi_app, {
self.static_path: target
})
#: the Jinja2 environment. It is created from the
#: :attr:`jinja_options` and the loader that is returned
#: by the :meth:`create_jinja_loader` function.
self.jinja_env = Environment(loader=self.create_jinja_loader(),
**self.jinja_options)
# 添加这两个函数到 jinja 中, 然后再模板文件中也可以调用这些函数了
self.jinja_env.globals.update(
url_for=url_for,
get_flashed_messages=get_flashed_messages
)
def __call__(self, *args, **kwargs):
return SharedDataMiddleware.__call__(self, *args, **kwargs)
def __init__(self, app, **kwargs):
exports = {'/' + routing.static_url('/'): ''}
SharedDataMiddleware.__init__(self, app, exports, **kwargs)
