Running deferred initialization code and gracefully blocking on requests until initialization is complete

I would like to set up Flask so that it first sets up the listening socket, then runs some initialization code, then holds all incoming request processing until the initialization is complete. How do I set that up?

My Flask app takes about 30s of initialization (loading AI models, etc.). These are required for all real endpoints. However, during development, it is frustrating having to wait and watch for this to complete, before beginning with frontend interactions.

I remember old Tomcats (~15 years ago, haven't used it since) having this exact behavior: you could already send a request from an early stage of initialization, and then it would keep the connection open and process and send the response as soon as the webapp was fully loaded.

I guess the initialization could be deferred to a new thread and the request blocking could be accomplished with some middleware? Is there a library for this somewhere, so I don't have to start from scratch?

See if the below code helps.

@app.route('/')
def index():

    # Start the initialization in a separate thread

    executor.submit(init_func)

    # Wait for the initialization to complete

    while not executor.futures.done:
        threading.Event().wait(0.1)

    # Return the response

    return 'Hello, World!'

we're using the Flask-Executor extension to execute the initialization function in a separate thread. We're also using the threading module to block the main thread until the initialization is complete.

Looking further into @manish-dixit's answer, Flash-Executor didn't quite work for me, but it seemed that the executor pattern is the simplest approach here. So here's my solution to the problem, using plain Python executors:

def long_running_initialization():
    # Long running initialization code goes here

app = Flask(__name__)

# create executor -- we only need a single worker, because we only want to run a single task on it ever
executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)

# the initialization will take a long time, so kick it off asap, whether there's incoming requests or not!
initialization_future = executor.submit(long_running_initialization)

@app.route('/')
def access_data():
    concurrent.futures.wait([initialization_future])
    # now we can access the fully initialized data set
    return f'Data: {data}'

Here's a more complete example, including a decorator, that can also be run for demonstration purposes:
flask_concurrent_blocking_initialization_example.py