Streamlit - Async tasks problem

Hi Tibor,

Streamlit's primary mode of operation is based on scripting, meaning it runs from top to bottom each time there's an interaction, updating all the components. In the examples you provided, Streamlit won't wait for things like `time.sleep()` or loop delays in the way that you're expecting.

For your specific examples:

1. The `st.spinner('Wait for it...')` with the `time.sleep(5)` will not display the spinner for 5 seconds before showing "Done!". Instead, Streamlit will finish the entire script execution (including the sleep time) and then update the app interface.

2. In your second example, the loop keeps the script busy until `func_call.status` is no longer "Running". Only after the loop finishes does Streamlit get a chance to update the interface, causing the "Waiting for function..." to appear briefly or not at all, depending on how quickly the subsequent updates occur.

To achieve the desired effect in Streamlit:

1. For the spinner example: There's no direct way to make `st.spinner` wait for a specific time or function. Instead, you'd need to think in terms of breaking the process down into more granular updates, or consider different UI/UX patterns, such as informing users about typical wait times. This is another resource that might help: https://discuss.streamlit.io/t/how-can-i-use-time-sleep-only-for-success-warning-and-info/32788/2

2. For the function call example: One approach is to use Streamlit's caching mechanism. You can cache the function call and let the function be called asynchronously. When the function is being executed (and thus the cache is being populated), you can provide a status message to the user. I have not tested caching with Streamlit running in the browser.

Here's a potential way to implement the second example using Streamlit's `@st.cache`:

import streamlit as st

# Allow_output_mutation lets the object being cached mutate between calls.
# Supposing that example_function.call returns an object that gets updated.
@st.cache(allow_output_mutation=True, show_spinner=True)
def cached_function_call(data):
    return example_function.call(data=input_data)

call_func_button = st.button("Call function with current parameters", key="button_func_call")

if call_func_button:
    func_call = cached_function_call(input_data)

    if func_call.status == "Failed":
        st.error("Function failed to run!")
    elif func_call.status == "Completed":
        runtime = float(func_call.end_time - func_call.start_time) / 1000.0
        st.success(f"Function ran successfully in {runtime} seconds!")

Let me know, if this answers your question and solves the problem.

Best,

Christian