remove ActiveCallbackRegistry & callback adoption

Author: T4rk1n

.ai/ARCHITECTURE.md

@@ -968,6 +968,7 @@ WebSocket callbacks can stream updates to the client during execution using `set
 ```python
 import asyncio
 from dash import callback, Output, Input, set_props, ctx
+from dash.exceptions import PreventUpdate
 
 @callback(
     Output('result', 'children'),
@@ -981,6 +982,9 @@ async def long_running_task(n_clicks):
 
     # Stream progress updates to the client
     for i in range(100):
+        # IMPORTANT: Check is_shutdown in loops to detect disconnections
+        if ws.is_shutdown:
+            raise PreventUpdate  # Exit gracefully on disconnect
         await asyncio.sleep(0.1)
         set_props('progress-bar', {'value': i + 1})
         set_props('status', {'children': f'Processing step {i + 1}/100...'})
@@ -991,9 +995,19 @@ async def long_running_task(n_clicks):
     return f"Completed! Input was: {current_value}"
 ```
 
+**IMPORTANT - Checking `is_shutdown` in Loops:**
+
+Long-running callbacks that use loops **must** check `ws.is_shutdown` to detect when the WebSocket connection has closed. Without this check:
+- Callbacks continue running after the client disconnects, wasting server resources
+- `set_props` calls go to a closed connection and are lost
+- The callback result is never delivered to the client
+
+Only "persistent callbacks" (callbacks with no Output and no Input that use only `set_props`) are automatically restarted when the WebSocket reconnects. Regular callbacks with outputs are not restarted.
+
 **API:**
 - `set_props(component_id, props_dict)` - Stream prop updates immediately to client
 - `ctx.websocket` - Get WebSocket interface (returns `None` if not in WS context)
+- `ws.is_shutdown` - Check if the WebSocket connection has been closed
 - `await ws.get_prop(component_id, prop_name)` - Read current prop value from client
 - `await ws.set_prop(component_id, prop_name, value)` - Set single prop (async version)
 - `await ws.close(code, reason)` - Close the WebSocket connection

dash/backends/_fastapi.py

@@ -50,7 +50,6 @@
     SHUTDOWN_SIGNAL,
     DISCONNECTED,
 )
-from ._ws_registry import ActiveCallbackRegistry
 from ._utils import format_traceback_html
 
 if TYPE_CHECKING:  # pragma: no cover - typing only
@@ -678,12 +677,6 @@ def serve_websocket_callback(self, dash_app: "Dash"):
             dash_app, "_websocket_allowed_origins", []
         )  # pylint: disable=protected-access
 
-        # Initialize registry on dash_app if not present
-        # pylint: disable=protected-access
-        if not hasattr(dash_app, "_ws_callback_registry"):
-            dash_app._ws_callback_registry = ActiveCallbackRegistry()
-        registry: ActiveCallbackRegistry = dash_app._ws_callback_registry
-
         def validate_origin(origin: str | None, host: str | None) -> str | None:
             """Validate WebSocket origin. Returns error message or None if valid."""
             if not origin:
@@ -730,8 +723,6 @@ async def websocket_handler(websocket: WebSocket):
             executor = self.get_callback_executor()
             # Track pending callback futures
             pending_callbacks: Dict[str, concurrent.futures.Future] = {}
-            # Track current renderer ID for this connection
-            current_renderer_id: str | None = None
 
             # Start sender task to drain outbound queue (sends pre-serialized text)
             # pylint: disable=protected-access
@@ -762,22 +753,6 @@ async def websocket_handler(websocket: WebSocket):
                         renderer_id = message.get("rendererId", "")
                         payload = message.get("payload", {})
 
-                        # Update current renderer ID for cleanup
-                        current_renderer_id = renderer_id
-
-                        # Adopt connection for this renderer (allows reconnection)
-                        # Called for every callback to ensure registry entry exists
-                        # (entry may have been cleaned up after previous callback)
-                        registry.adopt_connection(
-                            renderer_id,
-                            outbound_queue,
-                            pending_get_props,
-                            shutdown_event,
-                        )
-
-                        # Register this callback with the registry
-                        registry.register_callback(renderer_id)
-
                         # Validate that the callback is allowed to use WebSocket transport
                         # pylint: disable=protected-access
                         _validate.validate_websocket_callback_request(
@@ -786,13 +761,12 @@ async def websocket_handler(websocket: WebSocket):
                             dash_app._websocket_callbacks,
                         )
 
-                        # Create WebSocket callback instance with registry
+                        # Create WebSocket callback instance
                         ws_cb = DashWebsocketCallback(
                             pending_get_props,
                             renderer_id,
                             outbound_queue,
                             shutdown_event,
-                            registry=registry,
                         )
 
                         # Submit callback to executor
@@ -812,7 +786,6 @@ async def websocket_handler(websocket: WebSocket):
                                 request_id,
                                 renderer_id,
                                 shutdown_event,
-                                registry=registry,
                             )
                         )
                         pending_callbacks[request_id] = future
@@ -848,9 +821,6 @@ async def websocket_handler(websocket: WebSocket):
                 # Cancel any pending futures
                 for f in pending_callbacks.values():
                     f.cancel()
-                # Cleanup registry entry if no active callbacks
-                if current_renderer_id is not None:
-                    registry.cleanup_renderer(current_renderer_id)
 
         self.server.add_api_websocket_route(ws_path, websocket_handler)
 

dash/backends/_quart.py

@@ -55,7 +55,6 @@
     SHUTDOWN_SIGNAL,
     DISCONNECTED,
 )
-from ._ws_registry import ActiveCallbackRegistry
 from ._utils import format_traceback_html
 
 if TYPE_CHECKING:
@@ -522,12 +521,6 @@ def serve_websocket_callback(self, dash_app: "Dash"):
         # pylint: disable=protected-access
         allowed_origins = getattr(dash_app, "_websocket_allowed_origins", [])
 
-        # Initialize registry on dash_app if not present
-        # pylint: disable=protected-access
-        if not hasattr(dash_app, "_ws_callback_registry"):
-            dash_app._ws_callback_registry = ActiveCallbackRegistry()
-        registry: ActiveCallbackRegistry = dash_app._ws_callback_registry
-
         @self.server.websocket(ws_path)
         async def websocket_handler():  # pylint: disable=too-many-branches
             ws = websocket
@@ -571,8 +564,6 @@ async def websocket_handler():  # pylint: disable=too-many-branches
             executor = self.get_callback_executor()
             # Track pending callback futures
             pending_callbacks: Dict[str, concurrent.futures.Future] = {}
-            # Track current renderer ID for this connection
-            current_renderer_id: str | None = None
 
             # Start sender task to drain outbound queue (sends pre-serialized text)
             # pylint: disable=protected-access
@@ -610,22 +601,6 @@ async def websocket_handler():  # pylint: disable=too-many-branches
                         renderer_id = message.get("rendererId", "")
                         payload = message.get("payload", {})
 
-                        # Update current renderer ID for cleanup
-                        current_renderer_id = renderer_id
-
-                        # Adopt connection for this renderer (allows reconnection)
-                        # Called for every callback to ensure registry entry exists
-                        # (entry may have been cleaned up after previous callback)
-                        registry.adopt_connection(
-                            renderer_id,
-                            outbound_queue,
-                            pending_get_props,
-                            connection_shutdown_event,
-                        )
-
-                        # Register this callback with the registry
-                        registry.register_callback(renderer_id)
-
                         # Validate that the callback is allowed to use WebSocket transport
                         # pylint: disable=protected-access
                         _validate.validate_websocket_callback_request(
@@ -634,13 +609,12 @@ async def websocket_handler():  # pylint: disable=too-many-branches
                             dash_app._websocket_callbacks,
                         )
 
-                        # Create WebSocket callback instance with registry
+                        # Create WebSocket callback instance
                         ws_cb = DashWebsocketCallback(
                             pending_get_props,
                             renderer_id,
                             outbound_queue,
                             connection_shutdown_event,
-                            registry=registry,
                         )
 
                         # Submit callback to executor
@@ -660,7 +634,6 @@ async def websocket_handler():  # pylint: disable=too-many-branches
                                 request_id,
                                 renderer_id,
                                 connection_shutdown_event,
-                                registry=registry,
                             )
                         )
                         pending_callbacks[request_id] = future
@@ -699,9 +672,6 @@ async def websocket_handler():  # pylint: disable=too-many-branches
                 # Cancel any pending futures
                 for f in pending_callbacks.values():
                     f.cancel()
-                # Cleanup registry entry if no active callbacks
-                if current_renderer_id is not None:
-                    registry.cleanup_renderer(current_renderer_id)
 
 
 class QuartRequestAdapter(RequestAdapter):