fixing for lint

dash/backend/__init__.py

@@ -1,6 +1,8 @@
 # python
 import contextvars
-from .registry import *
+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")
 

dash/backend/base_server.py

@@ -8,7 +8,9 @@ def __call__(self, server, *args, **kwargs) -> Any:
         return server(*args, **kwargs)
 
     @abstractmethod
-    def create_app(self, name: str = "__main__", config=None) -> Any:  # pragma: no cover - interface
+    def create_app(
+        self, name: str = "__main__", config=None
+    ) -> Any:  # pragma: no cover - interface
         pass
 
     @abstractmethod
@@ -22,7 +24,9 @@ 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
+    def add_url_rule(
+        self, app, rule: str, view_func, endpoint=None, methods=None
+    ) -> None:  # pragma: no cover - interface
         pass
 
     @abstractmethod
@@ -34,11 +38,15 @@ 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
+    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
+    def make_response(
+        self, data, mimetype=None, content_type=None
+    ) -> Any:  # pragma: no cover - interface
         pass
 
     @abstractmethod

dash/backend/fastapi.py

@@ -117,7 +117,9 @@ async def catchall(request: Request):
             # pylint: disable=protected-access
             dash_app._add_url("{path:path}", catchall, methods=["GET"])
 
-    def add_url_rule(self, app, rule, view_func, endpoint=None, methods=None, include_in_schema=False):
+    def add_url_rule(
+        self, app, rule, view_func, endpoint=None, methods=None, include_in_schema=False
+    ):
         if rule == "":
             rule = "/"
         if isinstance(view_func, str):
@@ -307,8 +309,11 @@ def register_callback_api_routes(self, app, callback_api_paths):
             sig = inspect.signature(handler)
             param_names = list(sig.parameters.keys())
             fields = {name: (Optional[Any], None) for name in param_names}
-            Model = create_model(f"Payload_{endpoint}", **fields)
+            Model = create_model(
+                f"Payload_{endpoint}", **fields
+            )  # pylint: disable=cell-var-from-loop
 
+            # pylint: disable=cell-var-from-loop
             async def view_func(request: Request, body: Model):
                 kwargs = body.dict(exclude_unset=True)
                 if inspect.iscoroutinefunction(handler):
@@ -317,7 +322,6 @@ async def view_func(request: Request, body: Model):
                     result = handler(**kwargs)
                 return JSONResponse(content=result)
 
-
             app.add_api_route(
                 route,
                 view_func,

dash/backend/flask.py

@@ -4,8 +4,8 @@
 import sys
 import mimetypes
 import time
-import flask
 import inspect
+import flask
 from dash.fingerprint import check_fingerprint
 from dash import _validate
 from dash.exceptions import PreventUpdate, InvalidResourceError
@@ -213,18 +213,23 @@ def register_callback_api_routes(self, app, callback_api_paths):
             methods = ["POST"]
 
             if inspect.iscoroutinefunction(handler):
+
                 async def view_func(*args, handler=handler, **kwargs):
                     data = flask.request.get_json()
                     result = await handler(**data) if data else await handler()
                     return flask.jsonify(result)
+
             else:
+
                 def view_func(*args, handler=handler, **kwargs):
                     data = flask.request.get_json()
                     result = handler(**data) if data else handler()
                     return flask.jsonify(result)
 
             # Flask 2.x+ supports async views natively
-            app.add_url_rule(route, endpoint=endpoint, view_func=view_func, methods=methods)
+            app.add_url_rule(
+                route, endpoint=endpoint, view_func=view_func, methods=methods
+            )
 
 
 class FlaskRequestAdapter:

dash/backend/quart.py

@@ -1,15 +1,25 @@
-from .base_server import BaseDashServer
-from quart import Quart, Request, Response, jsonify, request
-from dash.exceptions import PreventUpdate, InvalidResourceError
-from dash.backend import set_request_adapter
-from dash.fingerprint import check_fingerprint
-from dash import _validate
-from contextvars import copy_context
 import inspect
 import pkgutil
 import mimetypes
 import sys
 import time
+from contextvars import copy_context
+
+try:
+    import quart
+    from quart import Quart, Response, jsonify, request, Blueprint
+except ImportError:
+    quart = None
+    Quart = None
+    Response = None
+    jsonify = None
+    request = None
+    Blueprint = None
+from dash.exceptions import PreventUpdate, InvalidResourceError
+from dash.backend import set_request_adapter
+from dash.fingerprint import check_fingerprint
+from dash import _validate
+from .base_server import BaseDashServer
 
 
 class QuartDashServer(BaseDashServer):
@@ -24,7 +34,7 @@ def __init__(self) -> None:
         super().__init__()
 
     def __call__(self, server, *args, **kwargs):
-        return super().__call__(server, *args, **kwargs)
+        return server(*args, **kwargs)
 
     def create_app(self, name="__main__", config=None):
         app = Quart(name)
@@ -36,8 +46,6 @@ def create_app(self, name="__main__", config=None):
     def register_assets_blueprint(
         self, app, blueprint_name, assets_url_path, assets_folder
     ):
-        from quart import Blueprint
-
         bp = Blueprint(
             blueprint_name,
             __name__,
@@ -53,15 +61,15 @@ async def _wrap_errors(_error_request, error):
             return tb, 500
 
     def register_timing_hooks(self, app, _first_run):  # parity with Flask factory
-        from quart import g
-
         @app.before_request
         async def _before_request():  # pragma: no cover - timing infra
-            g.timing_information = {"__dash_server": {"dur": time.time(), "desc": None}}
+            quart.g.timing_information = {
+                "__dash_server": {"dur": time.time(), "desc": None}
+            }
 
         @app.after_request
         async def _after_request(response):  # pragma: no cover - timing infra
-            timing_information = getattr(g, "timing_information", None)
+            timing_information = getattr(quart.g, "timing_information", None)
             if timing_information is None:
                 return response
             dash_total = timing_information.get("__dash_server", None)
@@ -90,7 +98,7 @@ async def _invalid_resource(err):
             return err.args[0], 404
 
     def _html_response_wrapper(self, view_func):
-        async def wrapped(*args, **kwargs):
+        async def wrapped(*_args, **_kwargs):
             html_val = view_func() if callable(view_func) else view_func
             if inspect.iscoroutine(html_val):  # handle async function returning html
                 html_val = await html_val
@@ -105,21 +113,25 @@ def add_url_rule(self, app, rule, view_func, endpoint=None, methods=None):
         )
 
     def setup_index(self, dash_app):
-        async def index():
+        async def index(*args, **kwargs):
             adapter = QuartRequestAdapter()
             set_request_adapter(adapter)
-            adapter.set_request(request)
-            return Response(dash_app.index(), content_type="text/html")
+            adapter.set_request()
+            return Response(dash_app.index(*args, **kwargs), content_type="text/html")
 
+        # pylint: disable=protected-access
         dash_app._add_url("", index, methods=["GET"])
 
     def setup_catchall(self, dash_app):
-        async def catchall(path):  # noqa: ARG001 - path is unused but kept for route signature
+        async def catchall(
+            path, *args, **kwargs
+        ):  # noqa: ARG001 - path is unused but kept for route signature, pylint: disable=unused-argument
             adapter = QuartRequestAdapter()
             set_request_adapter(adapter)
-            adapter.set_request(request)
-            return Response(dash_app.index(), content_type="text/html")
+            adapter.set_request()
+            return Response(dash_app.index(*args, **kwargs), content_type="text/html")
 
+        # pylint: disable=protected-access
         dash_app._add_url("<path:path>", catchall, methods=["GET"])
 
     def before_request(self, app, func):
@@ -135,7 +147,7 @@ async def _after(response):
             return response
 
     def run(self, app, host, port, debug, **kwargs):
-        self.config = {'debug': debug, **kwargs} if debug else kwargs
+        self.config = {"debug": debug, **kwargs} if debug else kwargs
         app.run(host=host, port=port, debug=debug, **kwargs)
 
     def make_response(self, data, mimetype=None, content_type=None):
@@ -147,7 +159,9 @@ def jsonify(self, obj):
     def get_request_adapter(self):
         return QuartRequestAdapter
 
-    def serve_component_suites(self, dash_app, package_name, fingerprinted_path, req):  # noqa: ARG002 unused req preserved for interface parity
+    def serve_component_suites(
+        self, dash_app, package_name, fingerprinted_path
+    ):  # noqa: ARG002 unused req preserved for interface parity
         path_in_pkg, has_fingerprint = check_fingerprint(fingerprinted_path)
         _validate.validate_js_path(dash_app.registered_paths, package_name, path_in_pkg)
         extension = "." + path_in_pkg.split(".")[-1]
@@ -170,24 +184,30 @@ def serve_component_suites(self, dash_app, package_name, fingerprinted_path, req
     def setup_component_suites(self, dash_app):
         async def serve(package_name, fingerprinted_path):
             return self.serve_component_suites(
-                dash_app, package_name, fingerprinted_path, request
+                dash_app, package_name, fingerprinted_path
             )
 
+        # pylint: disable=protected-access
         dash_app._add_url(
             "_dash-component-suites/<string:package_name>/<path:fingerprinted_path>",
             serve,
         )
 
+    # pylint: disable=unused-argument
     def dispatch(self, app, dash_app, use_async=True):  # Quart always async
         async def _dispatch():
             adapter = QuartRequestAdapter()
             set_request_adapter(adapter)
-            adapter.set_request(request)
+            adapter.set_request()
             body = await request.get_json()
+            # pylint: disable=protected-access
             g = dash_app._initialize_context(body, adapter)
+            # pylint: disable=protected-access
             func = dash_app._prepare_callback(g, body)
+            # pylint: disable=protected-access
             args = dash_app._inputs_to_vals(g.inputs_list + g.states_list)
             ctx = copy_context()
+            # pylint: disable=protected-access
             partial_func = dash_app._execute_callback(func, args, g.outputs_list, g)
             response_data = ctx.run(partial_func)
             if inspect.iscoroutine(response_data):  # if user callback is async
@@ -209,20 +229,25 @@ def register_callback_api_routes(self, app, callback_api_paths):
 
             def _make_view_func(handler):
                 if inspect.iscoroutinefunction(handler):
+
                     async def async_view_func(*args, **kwargs):
                         data = await request.get_json()
                         result = await handler(**data) if data else await handler()
                         return jsonify(result)
+
                     return async_view_func
-                else:
-                    async def sync_view_func(*args, **kwargs):
-                        data = await request.get_json()
-                        result = handler(**data) if data else handler()
-                        return jsonify(result)
-                    return sync_view_func
+
+                async def sync_view_func(*args, **kwargs):
+                    data = await request.get_json()
+                    result = handler(**data) if data else handler()
+                    return jsonify(result)
+
+                return sync_view_func
 
             view_func = _make_view_func(handler)
-            app.add_url_rule(route, endpoint=endpoint, view_func=view_func, methods=methods)
+            app.add_url_rule(
+                route, endpoint=endpoint, view_func=view_func, methods=methods
+            )
 
     def _serve_default_favicon(self):
         return Response(
@@ -234,7 +259,7 @@ class QuartRequestAdapter:
     def __init__(self) -> None:
         self._request = None
 
-    def set_request(self, request: Request) -> None:
+    def set_request(self) -> None:
         self._request = request
 
     # Accessors (instance-based)

dash/backend/registry.py

@@ -1,15 +1,17 @@
 import importlib
 
 _backend_imports = {
-    'flask': ('dash.backend.flask', 'FlaskDashServer'),
-    'fastapi': ('dash.backend.fastapi', 'FastAPIDashServer'),
-    'quart': ('dash.backend.quart', 'QuartDashServer'),
+    "flask": ("dash.backend.flask", "FlaskDashServer"),
+    "fastapi": ("dash.backend.fastapi", "FastAPIDashServer"),
+    "quart": ("dash.backend.quart", "QuartDashServer"),
 }
 
+
 def register_backend(name, module_path, class_name):
     """Register a new backend by name."""
     _backend_imports[name.lower()] = (module_path, class_name)
 
+
 def get_backend(name):
     try:
         module_name, class_name = _backend_imports[name.lower()]
@@ -18,7 +20,10 @@ def get_backend(name):
     except KeyError as e:
         raise ValueError(f"Unknown backend: {name}") from e
     except ImportError as e:
-        raise ImportError(f"Could not import module '{module_name}' for backend '{name}': {e}") from e
+        raise ImportError(
+            f"Could not import module '{module_name}' for backend '{name}': {e}"
+        ) from e
     except AttributeError as e:
-        raise AttributeError(f"Module '{module_name}' does not have class '{class_name}' for backend '{name}': {e}") from e
-
+        raise AttributeError(
+            f"Module '{module_name}' does not have class '{class_name}' for backend '{name}': {e}"
+        ) from e