adding custom error handling per backend, tests and adjustments to th…

…e flow. Made endpoints for downloading the reqs

.github/workflows/testing.yml

@@ -271,6 +271,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_tests_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/backend/fastapi.py

@@ -6,6 +6,7 @@
 from contextvars import copy_context
 import importlib.util
 import time
+import traceback
 
 try:
     import uvicorn
@@ -32,14 +33,28 @@
 
 from dash.fingerprint import check_fingerprint
 from dash import _validate
-from dash.exceptions import PreventUpdate, InvalidResourceError
+from dash.exceptions import PreventUpdate, InvalidResourceError, InvalidCallbackReturnValue, BackgroundCallbackError
 from dash.backend import set_request_adapter
 from .base_server import BaseDashServer
 
+import json
+import os
+
+CONFIG_PATH = "dash_config.json"
+
+def save_config(config):
+    with open(CONFIG_PATH, "w") as f:
+        json.dump(config, f)
+
+def load_config():
+    if os.path.exists(CONFIG_PATH):
+        with open(CONFIG_PATH, "r") as f:
+            return json.load(f)
+    return {}
 
 class FastAPIDashServer(BaseDashServer):
     def __init__(self):
-        self.config = {}
+        self.error_handling_mode = "prune"
         super().__init__()
 
     def __call__(self, server, *args, **kwargs):
@@ -69,19 +84,120 @@ def register_assets_blueprint(
             pass
 
     def register_error_handlers(self, app):
-        @app.exception_handler(PreventUpdate)
-        async def _handle_error(_request, _exc):
-            return Response(status_code=204)
+        self.error_handling_mode = "prune"
+        # FastAPI uses exception handlers, but we will handle errors in middleware
+        pass
+
+    def _get_traceback(self, secret, error: Exception):
+        tb = error.__traceback__
+        errors = traceback.format_exception(type(error), error, tb)
+        pass_errs = []
+        callback_handled = False
+        for err in errors:
+            if self.error_handling_mode == "prune":
+                if not callback_handled:
+                    if 'callback invoked' in str(err) and '_callback.py' in str(err):
+                        callback_handled = True
+                    continue
+            pass_errs.append(err)
+        formatted_tb = "".join(pass_errs)
+        error_type = type(error).__name__
+        error_msg = str(error)
+
+        # Parse traceback lines to group by file
+        import re
+        file_cards = []
+        pattern = re.compile(r'  File "(.+)", line (\d+), in (\w+)')
+        lines = formatted_tb.split('\n')
+        current_file = None
+        card_lines = []
+
+        for i, line in enumerate(lines[:-1]):  # Skip the last line (error message)
+            match = pattern.match(line)
+            if match:
+                if current_file and card_lines:
+                    file_cards.append((current_file, card_lines))
+                current_file = f'{match.group(1)} (line {match.group(2)}, in {match.group(3)})'
+                card_lines = [line]
+            elif current_file:
+                card_lines.append(line)
+        if current_file and card_lines:
+            file_cards.append((current_file, card_lines))
+
+        cards_html = ""
+        for filename, card in file_cards:
+            cards_html += f"""
+            <div class="error-card">
+                <div class="error-card-header">{filename}</div>
+                <pre class="error-card-traceback">"""+ '\n'.join(card) + """</pre>
+            </div>
+            """
+
+        html = f"""
+        <!doctype html>
+        <html lang="en">
+          <head>
+            <title>{error_type}: {error_msg} // FastAPI Debugger</title>
+            <style>
+              body {{ font-family: monospace; background: #fff; color: #333; }}
+              .debugger {{ margin: 2em; max-width: 700px; }}
+              .error-card {{
+                border: 1px solid #ccc;
+                border-radius: 6px;
+                margin-bottom: 1em;
+                padding: 1em;
+                background: #f9f9f9;
+                box-shadow: 0 2px 4px rgba(0,0,0,0.03);
+                overflow: auto;
+              }}
+              .error-card-header {{
+                font-weight: bold;
+                margin-bottom: 0.5em;
+                color: #0074d9;
+              }}
+              .error-card-traceback {{
+                max-height: 150px;
+                overflow: auto;
+                margin: 0;
+                white-space: pre-wrap;
+              }}
+              .plain textarea {{ width: 100%; height: 10em; resize: vertical; overflow: auto; }}
+              h1 {{ color: #c00; }}
+            </style>
+          </head>
+          <body style="padding-bottom:10px">
+            <div class="debugger">
+              <h1>{error_type}</h1>
+              <div class="detail">
+                <p class="errormsg">{error_type}: {error_msg}</p>
+              </div>
+              <h2 class="traceback">Traceback <em>(most recent call last)</em></h2>
+              {cards_html}
+              <blockquote>{error_type}: {error_msg}</blockquote>
+              <div class="plain">
+                <p>This is the Copy/Paste friendly version of the traceback.</p>
+                <textarea readonly>{formatted_tb}</textarea>
+              </div>
+              <div class="explanation">
+                The debugger caught an exception in your ASGI application. You can now
+                look at the traceback which led to the error.
+              </div>
+              <div class="footer">
+                Brought to you by <strong class="arthur">DON'T PANIC</strong>, your
+                friendly FastAPI powered traceback interpreter.
+              </div>
+            </div>
+          </body>
+        </html>
+        """
+        return html
 
-        @app.exception_handler(InvalidResourceError)
-        async def _invalid_resources_handler(_request, exc):
-            return Response(content=exc.args[0], status_code=404)
+    def register_prune_error_handler(self, _app, _secret, prune_errors):
+        if prune_errors:
+            self.error_handling_mode = "prune"
+        else:
+            self.error_handling_mode = "raise"
 
-    def register_prune_error_handler(self, app, secret, get_traceback_func):
-        @app.exception_handler(Exception)
-        async def _wrap_errors(_error_request, error):
-            tb = get_traceback_func(secret, error)
-            return PlainTextResponse(tb, status_code=500)
 
     def _html_response_wrapper(self, view_func):
         async def wrapped(*_args, **_kwargs):
@@ -104,9 +220,10 @@ async def index(request: Request):
     def setup_catchall(self, dash_app):
         @dash_app.server.on_event("startup")
         def _setup_catchall():
+            config = load_config()
             dash_app.enable_dev_tools(
-                **self.config, first_run=False
-            )  # do this to make sure dev tools are enabled
+                **config, first_run=False
+            )
 
             async def catchall(request: Request):
                 adapter = FastAPIRequestAdapter()
@@ -141,23 +258,26 @@ def after_request(self, app, func):
         # FastAPI does not have after_request, but we can use middleware
         app.middleware("http")(self._make_after_middleware(func))
 
-    def run(self, app, host, port, debug, **kwargs):
+    def run(self, dash_app, app, host, port, debug, **kwargs):
         frame = inspect.stack()[2]
-        self.config = dict({"debug": debug} if debug else {}, **kwargs)
-        reload = debug
-        if reload:
+        config = dict({"debug": debug} if debug else {}, **{
+            f'dev_tools_{k}': v for k, v in dash_app._dev_tools.items()})
+        save_config(config)
+        if debug:
+            if kwargs.get('reload') is None:
+                kwargs['reload'] = True
+        if kwargs.get('reload'):
             # Dynamically determine the module name from the file path
             file_path = frame.filename
             module_name = importlib.util.spec_from_file_location("app", file_path).name
             uvicorn.run(
                 f"{module_name}:app.server",
                 host=host,
                 port=port,
-                reload=reload,
                 **kwargs,
             )
         else:
-            uvicorn.run(app, host=host, port=port, reload=reload, **kwargs)
+            uvicorn.run(app, host=host, port=port, **kwargs)
 
     def make_response(self, data, mimetype=None, content_type=None):
         headers = {}
@@ -175,13 +295,21 @@ def get_request_adapter(self):
 
     def _make_before_middleware(self, func):
         async def middleware(request, call_next):
-            if func is not None:
-                if inspect.iscoroutinefunction(func):
-                    await func()
-                else:
-                    func()
-            response = await call_next(request)
-            return response
+            try:
+                response = await call_next(request)
+                return response
+            except PreventUpdate:
+                # No content, nothing to update
+                return Response(status_code=204)
+            except Exception as e:
+                if self.error_handling_mode in ["raise", "prune"]:
+                    # Prune the traceback to remove internal Dash calls
+                    tb = self._get_traceback(None, e)
+                    return Response(content=tb, media_type='text/html', status_code=500)
+                return JSONResponse(
+                    status_code=500,
+                    content={"error": "InternalServerError", "message": str(e.args[0])},
+                )
 
         return middleware