[4.2] Persistent callbacks

[T4rk1n]

This PR adds support for:

1. Persistent callbacks - Callbacks with persistent=True don't show "Updating..." in the browser title while running
2. No-output callbacks - Callbacks without outputs that fire on initial load, fixes [BUG] no output callbacks doesn't trigger as initial callback. #3770
3. No-input callbacks - Callbacks without inputs (only State) that fire on initial load, resolves [Feature Request] allow for callbacks without Inputs #3411
4. No-input no-output callbacks - Callbacks with neither inputs nor outputs that fire once on initial load

Examples

Persistent callback without inputs/outputs

import asyncio                                                                                                                                                                                                 
from dash import Dash, html, callback, set_props                                                                                                                                                               
                                                                                                                                                                                                               
app = Dash(backend="fastapi", websocket_callbacks=True)                                                                                                                                                        
                                                                                                                                                                                                               
app.layout = html.Div([                                                                                                                                                                                        
    html.Div(id="counter", children="0"),                                                                                                                                                                      
])                                                                                                                                                                                                             
                                                                                                                                                                                                               
@callback(persistent=True)                                                                                                                                                                                     
async def continuous_updates():                                                                                                                                                                                
    # Fires once on load, runs forever without showing "Updating..." title                                                                                                                                     
    n = 0                                                                                                                                                                                                      
    while True:                                                                                                                                                                                                
        set_props("counter", {"children": str(n)})                                                                                                                                                             
        n += 1                                                                                                                                                                                                 
        await asyncio.sleep(1)                                                                                                                                                                                 
                                                                                                                                                                                                               
if __name__ == "__main__":                                                                                                                                                                                     
    app.run() 

No-input callback (fires on initial load)

from dash import Dash, html, Output, State, callback                                                                                                                                                           
                                                                                                                                                                                                               
app = Dash()                                                                                                                                                                                                   
                                                                                                                                                                                                               
app.layout = html.Div([                                                                                                                                                                                        
    dcc.Store(id="config", data={"theme": "dark"}),                                                                                                                                                            
    html.Div(id="output"),                                                                                                                                                                                     
])                                                                                                                                                                                                             
                                                                                                                                                                                                               
@callback(                                                                                                                                                                                                     
    Output("output", "children"),                                                                                                                                                                              
    State("config", "data"),                                                                                                                                                                                   
)                                                                                                                                                                                                              
def initialize_from_config(config):                                                                                                                                                                            
    # Fires once on page load with State values                                                                                                                                                                
    return f"Theme: {config['theme']}"                                                                                                                                                                         
                                                                                                                                                                                                               
if __name__ == "__main__":                                                                                                                                                                                     
    app.run() 

No-input no-output callback (side-effect only)

from dash import Dash, html, callback                                                                                                                                                                          
                                                                                                                                                                                                                 
app = Dash()                                                                                                                                                                                                   
app.layout = html.Div([html.Div(id="output")])                                                                                                                                                                 
                                                                                                                                                                                                               
@callback()                                                                                                                                                                                                    
def log_page_load():                                                                                                                                                                                           
    # Fires once when page loads                                                                                                                                                                               
    print("Page loaded!")                                                                                                                                                                                      
    # Could log to database, initialize connections, etc.                                                                                                                                                      
                                                                                                                                                                                                               
if __name__ == "__main__":                                                                                                                                                                                     
    app.run() 

[camdecoster]

I left a few comments, but this is looking good.

[camdecoster]

You iterate through the callbacks three times. What do you think of switching to a for...of loop that does everything in one pass? In fact, you could use one loop that handles both noOutputCallbacks and noInputCallbacks.

[camdecoster]

Suggested change

	# Fallback to empty hash if no external frame found
	return _hash_inputs()

[camdecoster]

Suggested change

	# (skip internal dash package frames)
	# Fallback to empty hash if no external frame found
	# (skip internal dash package frames)