rename most long -> background callback

Author: T4rk1n

dash/__init__.py

@@ -26,7 +26,7 @@
     get_relative_path,
     strip_relative_path,
 )
-from .long_callback import (  # noqa: F401,E402
+from .background_callback import (  # noqa: F401,E402
     CeleryManager,
     DiskcacheManager,
 )

dash/_callback.py

@@ -20,7 +20,7 @@
     PreventUpdate,
     WildcardInLongCallback,
     MissingLongCallbackManagerError,
-    LongCallbackError,
+    BackgroundCallbackError,
     ImportedInsideCallbackError,
 )
 
@@ -39,7 +39,7 @@
 )
 
 from . import _validate
-from .long_callback.managers import BaseLongCallbackManager
+from .background_callback.managers import BaseBackgroundCallbackManager
 from ._callback_context import context_value
 
 
@@ -72,7 +72,7 @@ def callback(
     progress_default: Any = None,
     running: Optional[List[Tuple[Output, Any, Any]]] = None,
     cancel: Optional[List[Input]] = None,
-    manager: Optional[BaseLongCallbackManager] = None,
+    manager: Optional[BaseBackgroundCallbackManager] = None,
     cache_args_to_ignore: Optional[list] = None,
     on_error: Optional[Callable[[Exception], Any]] = None,
     **_kwargs,
@@ -96,11 +96,11 @@ def callback(
 
     :Keyword Arguments:
         :param background:
-            Mark the callback as a long callback to execute in a manager for
+            Mark the callback as a background callback to execute in a manager for
             callbacks that take a long time without locking up the Dash app
             or timing out.
         :param manager:
-            A long callback manager instance. Currently, an instance of one of
+            A background callback manager instance. Currently, an instance of one of
             `DiskcacheManager` or `CeleryManager`.
             Defaults to the `background_callback_manager` instance provided to the
             `dash.Dash constructor`.
@@ -144,14 +144,14 @@ def callback(
             this should be a list of argument names as strings. Otherwise,
             this should be a list of argument indices as integers.
         :param interval:
-            Time to wait between the long callback update requests.
+            Time to wait between the background callback update requests.
         :param on_error:
             Function to call when the callback raises an exception. Receives the
             exception object as first argument. The callback_context can be used
             to access the original callback inputs, states and output.
     """
 
-    long_spec = None
+    background_spec = None
 
     config_prevent_initial_callbacks = _kwargs.pop(
         "config_prevent_initial_callbacks", False
@@ -160,54 +160,56 @@ def callback(
     callback_list = _kwargs.pop("callback_list", GLOBAL_CALLBACK_LIST)
 
     if background:
-        long_spec: Any = {
+        background_spec: Any = {
             "interval": interval,
         }
 
         if manager:
-            long_spec["manager"] = manager
+            background_spec["manager"] = manager
 
         if progress:
-            long_spec["progress"] = coerce_to_list(progress)
-            validate_long_inputs(long_spec["progress"])
+            background_spec["progress"] = coerce_to_list(progress)
+            validate_background_inputs(background_spec["progress"])
 
         if progress_default:
-            long_spec["progressDefault"] = coerce_to_list(progress_default)
+            background_spec["progressDefault"] = coerce_to_list(progress_default)
 
-            if not len(long_spec["progress"]) == len(long_spec["progressDefault"]):
+            if not len(background_spec["progress"]) == len(
+                background_spec["progressDefault"]
+            ):
                 raise Exception(
                     "Progress and progress default needs to be of same length"
                 )
 
         if cancel:
             cancel_inputs = coerce_to_list(cancel)
-            validate_long_inputs(cancel_inputs)
+            validate_background_inputs(cancel_inputs)
 
-            long_spec["cancel"] = [c.to_dict() for c in cancel_inputs]
-            long_spec["cancel_inputs"] = cancel_inputs
+            background_spec["cancel"] = [c.to_dict() for c in cancel_inputs]
+            background_spec["cancel_inputs"] = cancel_inputs
 
         if cache_args_to_ignore:
-            long_spec["cache_args_to_ignore"] = cache_args_to_ignore
+            background_spec["cache_args_to_ignore"] = cache_args_to_ignore
 
     return register_callback(
         callback_list,
         callback_map,
         config_prevent_initial_callbacks,
         *_args,
         **_kwargs,
-        long=long_spec,
+        long=background_spec,
         manager=manager,
         running=running,
         on_error=on_error,
     )
 
 
-def validate_long_inputs(deps):
+def validate_background_inputs(deps):
     for dep in deps:
         if dep.has_wildcard():
             raise WildcardInLongCallback(
                 f"""
-                long callbacks does not support dependencies with
+                background callbacks does not support dependencies with
                 pattern-matching ids
                     Received: {repr(dep)}\n"""
             )
@@ -318,7 +320,7 @@ def register_callback(
         multi = True
         has_output = len(output) > 0
 
-    long = _kwargs.get("long")
+    background = _kwargs.get("long")
     manager = _kwargs.get("manager")
     running = _kwargs.get("running")
     on_error = _kwargs.get("on_error")
@@ -342,7 +344,7 @@ def register_callback(
         flat_state,
         inputs_state_indices,
         prevent_initial_call,
-        long=long,
+        long=background,
         manager=manager,
         dynamic_creator=allow_dynamic_callbacks,
         running=running,
@@ -352,23 +354,25 @@ def register_callback(
     # pylint: disable=too-many-locals
     def wrap_func(func):
 
-        if long is not None:
-            long_key = BaseLongCallbackManager.register_func(
+        if background is not None:
+            background_key = BaseBackgroundCallbackManager.register_func(
                 func,
-                long.get("progress") is not None,
+                background.get("progress") is not None,
                 callback_id,
             )
 
         @wraps(func)
         def add_context(*args, **kwargs):
             output_spec = kwargs.pop("outputs_list")
-            app_callback_manager = kwargs.pop("long_callback_manager", None)
+            app_callback_manager = kwargs.pop("background_callback_manager", None)
 
             callback_ctx = kwargs.pop(
                 "callback_context", AttributeDict({"updated_props": {}})
             )
             app = kwargs.pop("app", None)
-            callback_manager = long and long.get("manager", app_callback_manager)
+            callback_manager = background and background.get(
+                "manager", app_callback_manager
+            )
             error_handler = on_error or kwargs.pop("app_on_error", None)
             original_packages = set(ComponentRegistry.registry)
 
@@ -384,18 +388,18 @@ def add_context(*args, **kwargs):
             response: dict = {"multi": True}
             has_update = False
 
-            if long is not None:
+            if background is not None:
                 if not callback_manager:
                     raise MissingLongCallbackManagerError(
-                        "Running `long` callbacks requires a manager to be installed.\n"
+                        "Running `background` callbacks requires a manager to be installed.\n"
                         "Available managers:\n"
                         "- Diskcache (`pip install dash[diskcache]`) to run callbacks in a separate Process"
                         " and store results on the local filesystem.\n"
                         "- Celery (`pip install dash[celery]`) to run callbacks in a celery worker"
                         " and store results on redis.\n"
                     )
 
-                progress_outputs = long.get("progress")
+                progress_outputs = background.get("progress")
                 cache_key = flask.request.args.get("cacheKey")
                 job_id = flask.request.args.get("job")
                 old_job = flask.request.args.getlist("oldJob")
@@ -404,7 +408,7 @@ def add_context(*args, **kwargs):
                     func,
                     # Inputs provided as dict is kwargs.
                     func_args if func_args else func_kwargs,
-                    long.get("cache_args_to_ignore", []),
+                    background.get("cache_args_to_ignore", []),
                 )
 
                 if old_job:
@@ -414,7 +418,7 @@ def add_context(*args, **kwargs):
                 if not cache_key:
                     cache_key = current_key
 
-                    job_fn = callback_manager.func_registry.get(long_key)
+                    job_fn = callback_manager.func_registry.get(background_key)
 
                     ctx_value = AttributeDict(**context_value.get())
                     ctx_value.ignore_register_page = True
@@ -433,11 +437,11 @@ def add_context(*args, **kwargs):
                         "job": job,
                     }
 
-                    cancel = long.get("cancel")
+                    cancel = background.get("cancel")
                     if cancel:
                         data["cancel"] = cancel
 
-                    progress_default = long.get("progressDefault")
+                    progress_default = background.get("progressDefault")
                     if progress_default:
                         data["progressDefault"] = {
                             str(o): x
@@ -461,11 +465,11 @@ def add_context(*args, **kwargs):
 
                 elif (
                     isinstance(output_value, dict)
-                    and "long_callback_error" in output_value
+                    and "background_callback_error" in output_value
                 ):
-                    error = output_value.get("long_callback_error", {})
-                    exc = LongCallbackError(
-                        f"An error occurred inside a long callback: {error['msg']}\n{error['tb']}"
+                    error = output_value.get("background_callback_error", {})
+                    exc = BackgroundCallbackError(
+                        f"An error occurred inside a background callback: {error['msg']}\n{error['tb']}"
                     )
                     if error_handler:
                         output_value = error_handler(exc)
@@ -555,7 +559,7 @@ def add_context(*args, **kwargs):
                 output_value = []
                 flat_output_values = []
 
-            if not long:
+            if not background:
                 has_update = _set_side_update(callback_ctx, response) or has_update
 
             if not has_update:

dash/_validate.py

@@ -364,6 +364,10 @@ def check_obsolete(kwargs):
                 file=sys.stderr,
             )
             continue
+        if key in ["long_callback_manager"]:
+            raise exceptions.ObsoleteKwargException(
+                "long_callback_manager is obsolete, use background_callback_manager instead"
+            )
         # any other kwarg mimic the built-in exception
         raise TypeError(f"Dash() got an unexpected keyword argument '{key}'")
 
@@ -522,9 +526,9 @@ def validate_module_name(module):
     return module
 
 
-def validate_long_callbacks(callback_map):
-    # Validate that long callback side output & inputs are not circular
-    # If circular, triggering a long callback would result in a fatal server/computer crash.
+def validate_background_callbacks(callback_map):
+    # Validate that background callback side output & inputs are not circular
+    # If circular, triggering a background callback would result in a fatal server/computer crash.
     all_outputs = set()
     input_indexed = {}
     for callback in callback_map.values():
@@ -535,21 +539,21 @@ def validate_long_callbacks(callback_map):
             input_indexed[o].update(coerce_to_list(callback["raw_inputs"]))
 
     for callback in (x for x in callback_map.values() if x.get("long")):
-        long_info = callback["long"]
-        progress = long_info.get("progress", [])
-        running = long_info.get("running", [])
+        bg_info = callback["long"]
+        progress = bg_info.get("progress", [])
+        running = bg_info.get("running", [])
 
-        long_inputs = coerce_to_list(callback["raw_inputs"])
+        bg_inputs = coerce_to_list(callback["raw_inputs"])
         outputs = set([x[0] for x in running] + progress)
         circular = [
             x
             for x in set(k for k, v in input_indexed.items() if v.intersection(outputs))
-            if x in long_inputs
+            if x in bg_inputs
         ]
 
         if circular:
-            raise exceptions.LongCallbackError(
-                f"Long callback circular error!\n{circular} is used as input for a long callback"
+            raise exceptions.BackgroundCallbackError(
+                f"Background callback circular error!\n{circular} is used as input for a background callback"
                 f" but also used as output from an input that is updated with progress or running argument."
             )
 

dash/long_callback/__init__.py renamed to dash/background_callback/__init__.py

@@ -1,8 +1,6 @@
 from .managers.celery_manager import (  # noqa: F401,E402
-    CeleryLongCallbackManager,
     CeleryManager,
 )
 from .managers.diskcache_manager import (  # noqa: F401,E402
-    DiskcacheLongCallbackManager,
     DiskcacheManager,
 )

dash/long_callback/_proxy_set_props.py renamed to dash/background_callback/_proxy_set_props.py

@@ -3,7 +3,7 @@
 import hashlib
 
 
-class BaseLongCallbackManager(ABC):
+class BaseBackgroundCallbackManager(ABC):
     UNDEFINED = object()
 
     # Keep a ref to all the ref to register every callback to every manager.
@@ -18,7 +18,7 @@ def __init__(self, cache_by):
 
         self.cache_by = cache_by
 
-        BaseLongCallbackManager.managers.append(self)
+        BaseBackgroundCallbackManager.managers.append(self)
 
         self.func_registry = {}
 
@@ -83,16 +83,16 @@ def register(self, key, fn, progress):
 
     @staticmethod
     def register_func(fn, progress, callback_id):
-        key = BaseLongCallbackManager.hash_function(fn, callback_id)
-        BaseLongCallbackManager.functions.append(
+        key = BaseBackgroundCallbackManager.hash_function(fn, callback_id)
+        BaseBackgroundCallbackManager.functions.append(
             (
                 key,
                 fn,
                 progress,
             )
         )
 
-        for manager in BaseLongCallbackManager.managers:
+        for manager in BaseBackgroundCallbackManager.managers:
             manager.register(key, fn, progress)
 
         return key

dash/long_callback/managers/__init__.py renamed to dash/background_callback/managers/__init__.py

@@ -7,11 +7,11 @@
 from dash._callback_context import context_value
 from dash._utils import AttributeDict
 from dash.exceptions import PreventUpdate
-from dash.long_callback._proxy_set_props import ProxySetProps
-from dash.long_callback.managers import BaseLongCallbackManager
+from dash.background_callback._proxy_set_props import ProxySetProps
+from dash.background_callback.managers import BaseBackgroundCallbackManager
 
 
-class CeleryManager(BaseLongCallbackManager):
+class CeleryManager(BaseBackgroundCallbackManager):
     """Manage background execution of callbacks with a celery queue."""
 
     def __init__(self, celery_app, cache_by=None, expire=None):
@@ -138,7 +138,7 @@ def get_updated_props(self, key):
 def _make_job_fn(fn, celery_app, progress, key):
     cache = celery_app.backend
 
-    @celery_app.task(name=f"long_callback_{key}")
+    @celery_app.task(name=f"background_callback_{key}")
     def job_fn(result_key, progress_key, user_callback_args, context=None):
         def _set_progress(progress_value):
             if not isinstance(progress_value, (list, tuple)):
@@ -184,7 +184,7 @@ def run():
                     result_key,
                     json.dumps(
                         {
-                            "long_callback_error": {
+                            "background_callback_error": {
                                 "msg": str(err),
                                 "tb": traceback.format_exc(),
                             }