An example on how to reload Flask app in runtime

app.py

"""
This is an example on how to reload Flask app in runtime

It can be useful for the use case where you want to enable/disable blueprints/routes dynamically.

To run the app:

> pip install flask & python app.py

Then test it via curl

> curl localhost:5000/
> curl localhost:5000/reload
> curl localhost:5000/ # should see a different start time as the flask app is replaced

"""
from datetime import datetime

from flask import Flask
from werkzeug.serving import run_simple

# set to True to inform that the app needs to be re-created
to_reload = False


def get_app():
    print("create app now")
    app = Flask(__name__)

    # to make sure of the new app instance
    now = datetime.now()

    @app.route("/")
    def index():
        return f"hello, the app started at %s" % now

    @app.route('/reload')
    def reload():
        global to_reload
        to_reload = True
        return "reloaded"

    return app


class AppReloader(object):
    def __init__(self, create_app):
        self.create_app = create_app
        self.app = create_app()

    def get_application(self):
        global to_reload
        if to_reload:
            self.app = self.create_app()
            to_reload = False

        return self.app

    def __call__(self, environ, start_response):
        app = self.get_application()
        return app(environ, start_response)


# This application object can be used in any WSGI server
# for example in gunicorn, you can run "gunicorn app"
application = AppReloader(get_app)

if __name__ == '__main__':
    run_simple('localhost', 5000, application,
               use_reloader=True, use_debugger=True, use_evalex=True)

I was looking some ways to do an actual reload, and as of this writing, i thought, why not run the entire flask app from a subprocess perspective, then kill it and call the subprocess again to start the server again. The key here is to save the PID of the process into a file, and use it to get the PID and execute os.kill from flask's route

lets say main.py

def start():
    process = Popen(['python','run.py'],shell=True)
    with open('PID.file','w+') as pidfile:
        pidfile.write(process.pid)

& app.py

@app.route('reload')
def reload():
    with open('PID;file','r') as pidfile:
        pid = pidfile.read()
    os.kill(pid,, signal.SIGKILL)
    main.start()

I ran into a similar issue where I needed to reload a Flask site theme configuration.
I simply created a method that imported the current Flask application and then manually updated certain configurations.
I later executed the reload method within a Flask controller method.

In my use case, I needed to update the template and assets path but you could add whatever needs to be updated.

def reload():
    from flask import current_application
    current_application.template_folder = "new/path/to/templates"
    current_application.static_folder = "new/path/to/static/folder"
    # Add whatever configuration that needs to be updated