Building support for decoupling Dash from Flask and supporting Quart / FastAPI servers

.github/workflows/testing.yml

@@ -17,6 +17,7 @@ jobs:
       # This output will be 'true' if files in the 'table_related_paths' list changed, 'false' otherwise.
       table_paths_changed: ${{ steps.filter.outputs.table_related_paths }}
       background_cb_changed: ${{ steps.filter.outputs.background_paths }}
+      backend_cb_changed: ${{ steps.filter.outputs.backend_paths }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -37,6 +38,9 @@ jobs:
               - 'tests/background_callback/**'
               - 'tests/async_tests/**'
               - 'requirements/**'
+            backend_paths:
+              - 'dash/backend/**'
+              - 'tests/backend/**'
 
   build:
     name: Build Dash Package
@@ -271,6 +275,109 @@ jobs:
           cd bgtests
           pytest --headless --nopercyfinalize tests/async_tests -v -s
 
+  backend-tests:
+    name: Run Backend Callback Tests (Python ${{ matrix.python-version }})
+    needs: [build, changes_filter]
+    if: |
+      (github.event_name == 'push' && (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/dev')) ||
+      needs.changes_filter.outputs.backend_cb_changed == 'true'
+    timeout-minutes: 30
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.12"]
+
+    services:
+      redis:
+        image: redis:6
+        ports:
+          - 6379:6379
+        options: >-
+          --health-cmd "redis-cli ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    env:
+      REDIS_URL: redis://localhost:6379
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install Node.js dependencies
+        run: npm ci
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pip'
+
+      - name: Download built Dash packages
+        uses: actions/download-artifact@v4
+        with:
+          name: dash-packages
+          path: packages/
+
+      - name: Install Dash packages
+        run: |
+          python -m pip install --upgrade pip wheel
+          python -m pip install "setuptools<78.0.0"
+          python -m pip install "selenium==4.32.0"
+          find packages -name dash-*.whl -print -exec sh -c 'pip install "{}[async,ci,testing,dev,celery,diskcache,fastapi,quart]"' \;
+
+      - name: Install Google Chrome
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y google-chrome-stable
+
+      - name: Install ChromeDriver
+        run: |
+          echo "Determining Chrome version..."
+          CHROME_BROWSER_VERSION=$(google-chrome --version)
+          echo "Installed Chrome Browser version: $CHROME_BROWSER_VERSION"
+          CHROME_MAJOR_VERSION=$(echo "$CHROME_BROWSER_VERSION" | cut -f 3 -d ' ' | cut -f 1 -d '.')
+          echo "Detected Chrome Major version: $CHROME_MAJOR_VERSION"
+          if [ "$CHROME_MAJOR_VERSION" -ge 115 ]; then
+            echo "Fetching ChromeDriver version for Chrome $CHROME_MAJOR_VERSION using CfT endpoint..."
+            CHROMEDRIVER_VERSION_STRING=$(curl -sS "https://googlechromelabs.github.io/chrome-for-testing/LATEST_RELEASE_${CHROME_MAJOR_VERSION}")
+            if [ -z "$CHROMEDRIVER_VERSION_STRING" ]; then
+              echo "Could not automatically find ChromeDriver version for Chrome $CHROME_MAJOR_VERSION via LATEST_RELEASE. Please check CfT endpoints."
+              exit 1
+            fi
+            CHROMEDRIVER_URL="https://edgedl.me.gvt1.com/edgedl/chrome/chrome-for-testing/${CHROMEDRIVER_VERSION_STRING}/linux64/chromedriver-linux64.zip"
+          else
+            echo "Fetching ChromeDriver version for Chrome $CHROME_MAJOR_VERSION using older method..."
+            CHROMEDRIVER_VERSION_STRING=$(curl -sS "https://chromedriver.storage.googleapis.com/LATEST_RELEASE_${CHROME_MAJOR_VERSION}")
+            CHROMEDRIVER_URL="https://chromedriver.storage.googleapis.com/${CHROMEDRIVER_VERSION_STRING}/chromedriver_linux64.zip"
+          fi
+          echo "Using ChromeDriver version string: $CHROMEDRIVER_VERSION_STRING"
+          echo "Downloading ChromeDriver from: $CHROMEDRIVER_URL"
+          wget -q -O chromedriver.zip "$CHROMEDRIVER_URL"
+          unzip -o chromedriver.zip -d /tmp/
+          sudo mv /tmp/chromedriver-linux64/chromedriver /usr/local/bin/chromedriver || sudo mv /tmp/chromedriver /usr/local/bin/chromedriver
+          sudo chmod +x /usr/local/bin/chromedriver
+          echo "/usr/local/bin" >> $GITHUB_PATH
+        shell: bash
+
+      - name: Build/Setup test components
+        run: npm run setup-tests.py
+
+      - name: Run Backend Callback Tests
+        run: |
+          mkdir bgtests
+          cp -r tests bgtests/tests
+          cd bgtests
+          touch __init__.py
+          pytest --headless --nopercyfinalize tests/backend_tests -v -s
+
   table-unit:
     name: Table Unit/Lint Tests (Python ${{ matrix.python-version }})
     needs: [build, changes_filter]

dash/_callback.py

@@ -6,7 +6,7 @@
 
 
 import asyncio
-import flask
+from dash.backend import get_request_adapter
 
 from .dependencies import (
     handle_callback_args,
@@ -376,7 +376,7 @@ def _get_callback_manager(
                 " and store results on redis.\n"
             )
 
-    old_job = flask.request.args.getlist("oldJob")
+    old_job = get_request_adapter().get_args().getlist("oldJob")
 
     if old_job:
         for job in old_job:
@@ -436,7 +436,7 @@ def _setup_background_callback(
 
 def _progress_background_callback(response, callback_manager, background):
     progress_outputs = background.get("progress")
-    cache_key = flask.request.args.get("cacheKey")
+    cache_key = get_request_adapter().get_args().get("cacheKey")
 
     if progress_outputs:
         # Get the progress before the result as it would be erased after the results.
@@ -453,8 +453,8 @@ def _update_background_callback(
     """Set up the background callback and manage jobs."""
     callback_manager = _get_callback_manager(kwargs, background)
 
-    cache_key = flask.request.args.get("cacheKey")
-    job_id = flask.request.args.get("job")
+    cache_key = get_request_adapter().get_args().get("cacheKey")
+    job_id = get_request_adapter().get_args().get("job")
 
     _progress_background_callback(response, callback_manager, background)
 
@@ -474,8 +474,8 @@ def _handle_rest_background_callback(
     multi,
     has_update=False,
 ):
-    cache_key = flask.request.args.get("cacheKey")
-    job_id = flask.request.args.get("job")
+    cache_key = get_request_adapter().get_args().get("cacheKey")
+    job_id = get_request_adapter().get_args().get("job")
     # Must get job_running after get_result since get_results terminates it.
     job_running = callback_manager.job_running(job_id)
     if not job_running and output_value is callback_manager.UNDEFINED:
@@ -688,11 +688,10 @@ def add_context(*args, **kwargs):
             )
 
             response: dict = {"multi": True}
-
             jsonResponse = None
             try:
                 if background is not None:
-                    if not flask.request.args.get("cacheKey"):
+                    if not get_request_adapter().get_args().get("cacheKey"):
                         return _setup_background_callback(
                             kwargs,
                             background,
@@ -763,7 +762,7 @@ async def async_add_context(*args, **kwargs):
 
             try:
                 if background is not None:
-                    if not flask.request.args.get("cacheKey"):
+                    if not get_request_adapter().get_args().get("cacheKey"):
                         return _setup_background_callback(
                             kwargs,
                             background,

dash/_callback_context.py

@@ -288,6 +288,14 @@ def path(self):
         """
         return _get_from_context("path", "")
 
+    @property
+    @has_context
+    def args(self):
+        """
+        Query parameters of the callback request as a dictionary-like object.
+        """
+        return _get_from_context("args", "")
+
     @property
     @has_context
     def remote(self):

dash/_pages.py

@@ -389,15 +389,15 @@ def _path_to_page(path_id):
     return {}, None
 
 
-def _page_meta_tags(app):
-    start_page, path_variables = _path_to_page(flask.request.path.strip("/"))
+def _page_meta_tags(app, request):
+    request_path = request.get_path()
+    start_page, path_variables = _path_to_page(request_path.strip("/"))
 
-    # use the supplied image_url or create url based on image in the assets folder
     image = start_page.get("image", "")
     if image:
         image = app.get_asset_url(image)
     assets_image_url = (
-        "".join([flask.request.url_root, image.lstrip("/")]) if image else None
+        "".join([request.get_root(), image.lstrip("/")]) if image else None
     )
     supplied_image_url = start_page.get("image_url")
     image_url = supplied_image_url if supplied_image_url else assets_image_url
@@ -413,7 +413,7 @@ def _page_meta_tags(app):
     return [
         {"name": "description", "content": description},
         {"property": "twitter:card", "content": "summary_large_image"},
-        {"property": "twitter:url", "content": flask.request.url},
+        {"property": "twitter:url", "content": request.get_url()},
         {"property": "twitter:title", "content": title},
         {"property": "twitter:description", "content": description},
         {"property": "twitter:image", "content": image_url or ""},

dash/_utils.py

@@ -104,6 +104,11 @@ def set_read_only(self, names, msg="Attribute is read-only"):
         else:
             object.__setattr__(self, "_read_only", new_read_only)
 
+    def unset_read_only(self, keys):
+        if hasattr(self, "_read_only"):
+            for key in keys:
+                self._read_only.pop(key, None)
+
     def finalize(self, msg="Object is final: No new keys may be added."):
         """Prevent any new keys being set."""
         object.__setattr__(self, "_final", msg)

dash/backend/__init__.py

@@ -0,0 +1,15 @@
+# python
+import contextvars
+from .registry import get_backend  # pylint: disable=unused-import
+
+__all__ = ["set_request_adapter", "get_request_adapter", "get_backend"]
+
+_request_adapter_var = contextvars.ContextVar("request_adapter")
+
+
+def set_request_adapter(adapter):
+    _request_adapter_var.set(adapter)
+
+
+def get_request_adapter():
+    return _request_adapter_var.get()

dash/backend/base_server.py

@@ -0,0 +1,58 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class BaseDashServer(ABC):
+    def __call__(self, server, *args, **kwargs) -> Any:
+        # Default: WSGI
+        return server(*args, **kwargs)
+
+    @abstractmethod
+    def create_app(
+        self, name: str = "__main__", config=None
+    ) -> Any:  # pragma: no cover - interface
+        pass
+
+    @abstractmethod
+    def register_assets_blueprint(
+        self, app, blueprint_name: str, assets_url_path: str, assets_folder: str
+    ) -> None:  # pragma: no cover - interface
+        pass
+
+    @abstractmethod
+    def register_error_handlers(self, app) -> None:  # pragma: no cover - interface
+        pass
+
+    @abstractmethod
+    def add_url_rule(
+        self, app, rule: str, view_func, endpoint=None, methods=None
+    ) -> None:  # pragma: no cover - interface
+        pass
+
+    @abstractmethod
+    def before_request(self, app, func) -> None:  # pragma: no cover - interface
+        pass
+
+    @abstractmethod
+    def after_request(self, app, func) -> None:  # pragma: no cover - interface
+        pass
+
+    @abstractmethod
+    def run(
+        self, app, host: str, port: int, debug: bool, **kwargs
+    ) -> None:  # pragma: no cover - interface
+        pass
+
+    @abstractmethod
+    def make_response(
+        self, data, mimetype=None, content_type=None
+    ) -> Any:  # pragma: no cover - interface
+        pass
+
+    @abstractmethod
+    def jsonify(self, obj) -> Any:  # pragma: no cover - interface
+        pass
+
+    @abstractmethod
+    def get_request_adapter(self) -> Any:  # pragma: no cover - interface
+        pass