Plotly dash callback order - plotly-dash

Question

I have a dash app, where I query a database.
Some of my queries are quick, some are slow.
I would like to show the results of these queries in a table in a way, that first I would populate the table with the quickly fetchable columns, then add the resulting columns of the slower queries gradually.
My problem is that the rendering callback of the aggragate data only runs after all the queries are done, whereas I would like to see it firing after each query callback result.
Here is a minimal example, where I fetch some quick data, then based on the quick query I fetch a slower one. There is a rendering callback, which is supposed to run after each query callback, but in reality runs only once in the end. (For the sake of simplicity I did not add the table here, just a basic div. I run Dash within a larger django project using django_plotly_dash, but probably it is not key regarding the question here.)
from django_plotly_dash import DjangoDash
import time
from dash import html
from dash.dependencies import Output, Input
app = DjangoDash("Minimal",)
app.layout = html.Div(
id='main-container',
children = [
html.Div(id='user-id'),
html.Div(id='quick-data'),
html.Div(id='slow-data'),
html.Div(id='aggregate-data'),
],
)
#app.callback(
Output('quick-data', 'children'),
Input('user-id', 'children'),
)
def query_quick_data(user_id,):
print("--------- query quick data ----------")
return "quick data"
#app.callback(
Output('slow-data', 'children'),
Input('quick-data', 'children'),
)
def query_slow_data(slow_data,):
print("--------- query slow data ----------")
time.sleep(3)
return "slow data"
#app.callback(
Output('aggregate-data', 'children'),
Input('quick-data', 'children'),
Input('slow-data', 'children'),
)
def render_data(quick_data,slow_data):
print("--------- render aggregate data ----------")
return quick_data + " | " + slow_data
Upon opening the app, the terminal looks as follows, while I would expect therender aggregate data to run twice (once straight after the quick query):
backend_1 | --------- query quick data ----------
backend_1 | --------- query slow data ----------
backend_1 | --------- render aggregate data ----------
My guess is that the query_slow_data callback is called first and the render_data is only fired after. So the question is, how could I force the render_data to be called first.

Answer 1

Your guess is correct, this is related to how Dash actually works. At the initial call, dash-render will recursively look at all the callbacks in your app, and will order them in by the availability of the input (read more from here to prevent unnecessary re-rendering. This is really important when you have a big dashboard. Imagine a dashboard with many callbacks, in which many are related to each other, if dash-render start calling randomly without proper organization, some callbacks might run in a loop, breaking the application or in the best scenario, making the application very heavy.
For your given example, assume that dash-render first saw render_data callback. When it recursively checks the callback inputs with other available callbacks, it will find out that query_quick_data callback's is ready to use (not output from another callback) so it will give it a priority. The query_slow_data has only one input and that input already came from the executed callback, so everything is ready for it can be called, while your render-data callback is asking for two inputs, one is available and the other isn't therefore, the dash-render will run the query_slow_data as you guessed.
I have been reading dash documents for a while and I have not run into any method in which you can custom the callback order to make a callback fire twice during the initial_call.