fix linting

Author: T4rk1n

dash/_callback.py

@@ -276,7 +276,7 @@ def insert_callback(
     no_output=False,
     optional=False,
     hidden=None,
-):
+) -> str:
     if prevent_initial_call is None:
         prevent_initial_call = config_prevent_initial_callbacks
 

dash/backends/__init__.py

@@ -1,4 +1,6 @@
 import importlib
+from typing import Type
+
 from .base_server import BaseDashServer
 
 
@@ -12,7 +14,7 @@
 }
 
 
-def get_backend(name: str) -> BaseDashServer:
+def get_backend(name: str) -> Type[BaseDashServer]:
     module_name, server_class = _backend_imports[name.lower()]
     try:
         module = importlib.import_module(module_name)

dash/backends/_fastapi.py

@@ -94,13 +94,14 @@ def _remove_config(config_path):
         pass
 
 
-class FastAPIDashServer(BaseDashServer):
+class FastAPIDashServer(BaseDashServer[FastAPI]):
     def __init__(self, server: FastAPI):
+        super().__init__(server)
         self.server_type = "fastapi"
-        self.server: FastAPI = server
         self.error_handling_mode = "ignore"
         self.request_adapter = FastAPIRequestAdapter
         self._before_request_funcs = []
+        self._before_middleware_added = False
 
         fname = inspect.stack()[2]
         file_path = fname.filename
@@ -114,7 +115,6 @@ def __init__(self, server: FastAPI):
         hash_digest = hashlib.sha256(file_path.encode("utf-8")).hexdigest()
         config_filename = f"{hash_digest}.json"
         self._CONFIG_PATH = os.path.join(config_dir, config_filename)
-        super().__init__()
 
     def __call__(self, *args: Any, **kwargs: Any):
         # ASGI: (scope, receive, send)
@@ -232,7 +232,7 @@ def has_request_context(self) -> bool:
 
     def run(self, dash_app: Dash, host, port, debug, **kwargs):
         frame = inspect.stack()[2]
-        dev_tools = dash_app._dev_tools  # pylint-disable=W0212
+        dev_tools = dash_app._dev_tools  # pylint: disable=W0212
         config = dict(
             {"debug": debug} if debug else {"debug": False},
             **{f"dev_tools_{k}": v for k, v in dev_tools.items()},
@@ -260,6 +260,7 @@ def run(self, dash_app: Dash, host, port, debug, **kwargs):
         # Add any other kwargs as CLI args if needed
 
         try:
+            # pylint: disable=R1732
             proc = subprocess.Popen(uvicorn_args, env=os.environ.copy())
             proc.wait()
         finally:
@@ -293,7 +294,7 @@ async def middleware(request, call_next):
                 return response
             except PreventUpdate:
                 return Response(status_code=204)
-            except Exception as e:
+            except Exception as e:  # pylint: disable=W0718
                 if self.error_handling_mode in ["raise", "prune"]:
                     tb = self._get_traceback(None, e)
                     return Response(content=tb, media_type="text/html", status_code=500)
@@ -465,14 +466,18 @@ async def view_func(_request: Request, body: dict = Body(...)):
             )
 
     def enable_compression(self) -> None:
-        from fastapi.middleware.gzip import GZipMiddleware
+        from fastapi.middleware.gzip import (
+            GZipMiddleware,
+        )  # pylint: disable=import-outside-toplevel
 
         self.server.add_middleware(GZipMiddleware, minimum_size=500)
-        config = _load_config()
+        config = _load_config(self._CONFIG_PATH)
         if "COMPRESS_ALGORITHM" not in config:
-            config["COMPRESS_ALGORITHM"] = ["gzip"]
+            config["COMPRESS_ALGORITHM"] = [
+                "gzip"
+            ]  # pylint: disable=no-value-for-parameter
 
-        _save_config(config)
+        _save_config(self._CONFIG_PATH, config)
 
 
 class FastAPIRequestAdapter(RequestAdapter):

dash/backends/_flask.py

@@ -37,12 +37,11 @@
     from dash import Dash
 
 
-class FlaskDashServer(BaseDashServer):
+class FlaskDashServer(BaseDashServer[Flask]):
     def __init__(self, server: Flask) -> None:
-        self.server: Flask = server
+        super().__init__(server)
         self.server_type = "flask"
         self.request_adapter = FlaskRequestAdapter
-        super().__init__()
 
     def __call__(self, *args: Any, **kwargs: Any):
         # Always WSGI

dash/backends/_quart.py

@@ -33,18 +33,17 @@
 from dash.fingerprint import check_fingerprint
 from dash._utils import parse_version
 from dash import _validate, Dash
-from .base_server import BaseDashServer
+from .base_server import BaseDashServer, RequestAdapter
 from ._utils import format_traceback_html
 
 
-class QuartDashServer(BaseDashServer):
+class QuartDashServer(BaseDashServer[Quart]):
     def __init__(self, server: Quart) -> None:
+        super().__init__(server)
         self.server_type = "quart"
-        self.server: Quart = server
         self.config = {}
         self.error_handling_mode = "ignore"
         self.request_adapter = QuartRequestAdapter
-        super().__init__()
 
     def __call__(self, *args: Any, **kwargs: Any):  # type: ignore[name-defined]
         return self.server(*args, **kwargs)
@@ -340,7 +339,7 @@ def enable_compression(self) -> None:
             ) from error
 
 
-class QuartRequestAdapter:
+class QuartRequestAdapter(RequestAdapter):
     def __init__(self) -> None:
         self._request = request  # type: ignore[assignment]
         if self._request is None:
@@ -396,5 +395,6 @@ def origin(self):
     def path(self):
         return self.request.path
 
-    async def get_json(self):
+    async def get_json(self):  # pylint: disable=W0236
+        # TODO consider using a sync wraper
         return await self.request.get_json()

dash/backends/base_server.py

@@ -1,5 +1,13 @@
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Type
+from typing import Any, Dict, Type, TypeVar, Generic, Protocol
+
+
+class _ServerCallable(Protocol):  # pylint: disable=too-few-public-methods
+    def __call__(self, *args: Any, **kwds: Any) -> Any:
+        raise NotImplementedError
+
+
+ServerType = TypeVar("ServerType", bound=_ServerCallable)
 
 
 class RequestAdapter(ABC):
@@ -67,12 +75,16 @@ def path(self) -> str:
         raise NotImplementedError()
 
 
-class BaseDashServer(ABC):
+class BaseDashServer(ABC, Generic[ServerType]):
     server_type: str
-    server: Any
+    server: ServerType
     config: Dict[str, Any]
     request_adapter: Type[RequestAdapter]
 
+    def __init__(self, server: ServerType) -> None:
+        super().__init__()
+        self.server = server
+
     def __call__(self, *args, **kwargs) -> Any:
         # Default: WSGI
         return self.server(*args, **kwargs)

dash/dash.py

@@ -2301,6 +2301,7 @@ def run(
             host = host or "127.0.0.1"
         else:
             host = host or os.getenv("HOST", "127.0.0.1")
+        assert host
         port = port or os.getenv("PORT", "8050")
         proxy = proxy or os.getenv("DASH_PROXY")