fix misc

- various type annotation fixes
- servers do not have a general _run_dispatcher anymore
  as a result we need a new way to capture the last_server_error
  - the solution is to use logs

Author: rmorshea

idom/dialect.py

@@ -5,7 +5,7 @@
 from pyalect import DialectError, Dialect
 
 
-class HtmlDialectTranspiler(Dialect, name="html"):
+class HtmlDialectTranspiler(Dialect, name="html"):  # type: ignore
     """An HTML dialect transpiler for Python."""
 
     def __init__(self, filename: Optional[str] = None):

idom/server/base.py

@@ -74,7 +74,7 @@ def register(self: _Self, app: Optional[_App]) -> _Self:
         self._app = app
         return self
 
-    def wait_until_server_start(self, timeout: float = 3.0):
+    def wait_until_server_start(self, timeout: float = 3.0) -> None:
         """Block until the underlying application has started"""
         if not self._server_did_start.wait(timeout=timeout):
             raise RuntimeError(  # pragma: no cover

idom/server/flask.py

@@ -50,16 +50,17 @@ def stop(self, timeout: Optional[float] = None) -> None:
             server.stop(timeout)
 
     def _create_config(self, config: Optional[Config]) -> Config:
-        return Config(
-            {
-                "import_name": __name__,
-                "url_prefix": "",
-                "cors": False,
-                "serve_static_files": True,
-                "redirect_root_to_index": True,
-                **(config or {}),
-            }
-        )
+        new_config: Config = {
+            "import_name": __name__,
+            "url_prefix": "",
+            "cors": False,
+            "serve_static_files": True,
+            "redirect_root_to_index": True,
+        }
+        if config is not None:
+            # BUG: https://github.com/python/mypy/issues/6462
+            new_config.update(config)  # type: ignore
+        return new_config
 
     def _default_application(self, config: Config) -> Flask:
         return Flask(config["import_name"])

idom/server/prefab.py

@@ -56,7 +56,7 @@ def run(
         server.register(app)
 
     run_server = server.run if not daemon else server.daemon
-    run_server(host, port, **(run_kwargs or {}))
+    run_server(host, port, **(run_kwargs or {}))  # type: ignore
 
     return server
 

idom/server/sanic.py

@@ -28,7 +28,7 @@ class Config(TypedDict, total=False):
 
     cors: Union[bool, Dict[str, Any]]
     url_prefix: str
-    server_static_files: bool
+    serve_static_files: bool
     redirect_root_to_index: bool
 
 
@@ -43,15 +43,15 @@ def stop(self) -> None:
         self._loop.call_soon_threadsafe(self.application.stop)
 
     def _create_config(self, config: Optional[Config]) -> Config:
-        return Config(
-            {
-                "cors": False,
-                "url_prefix": "",
-                "serve_static_files": True,
-                "redirect_root_to_index": True,
-                **(config or {}),
-            }
-        )
+        new_config: Config = {
+            "cors": False,
+            "url_prefix": "",
+            "serve_static_files": True,
+            "redirect_root_to_index": True,
+        }
+        if config is not None:
+            new_config.update(config)
+        return new_config
 
     def _default_application(self, config: Config) -> Sanic:
         return Sanic()

idom/server/tornado.py

@@ -5,7 +5,7 @@
 from asyncio import Queue as AsyncQueue
 from typing import Optional, Type, Any, List, Tuple, Dict
 
-from tornado.web import Application, StaticFileHandler, RedirectHandler
+from tornado.web import Application, StaticFileHandler, RedirectHandler, RequestHandler
 from tornado.websocket import WebSocketHandler
 from tornado.platform.asyncio import AsyncIOMainLoop
 from typing_extensions import TypedDict
@@ -18,7 +18,10 @@
 from .base import AbstractRenderServer
 
 
-class Config(TypedDict):
+_RouteHandlerSpecs = List[Tuple[str, Type[RequestHandler], Any]]
+
+
+class Config(TypedDict, total=False):
     """Render server config for :class:`TornadoRenderServer` subclasses"""
 
     base_url: str
@@ -31,7 +34,7 @@ class TornadoRenderServer(AbstractRenderServer[Application, Config]):
 
     _model_stream_handler_type: Type[WebSocketHandler]
 
-    def stop(self):
+    def stop(self) -> None:
         try:
             loop = self._loop
         except AttributeError:  # pragma: no cover
@@ -42,14 +45,14 @@ def stop(self):
             loop.call_soon_threadsafe(self._loop.stop)
 
     def _create_config(self, config: Optional[Config]) -> Config:
-        return Config(
-            {
-                "base_url": "",
-                "serve_static_files": True,
-                "redirect_root_to_index": True,
-                **(config or {}),
-            }
-        )
+        new_config: Config = {
+            "base_url": "",
+            "serve_static_files": True,
+            "redirect_root_to_index": True,
+        }
+        if config is not None:
+            new_config.update(config)
+        return new_config
 
     def _default_application(self, config: Config) -> Application:
         return Application()
@@ -73,8 +76,8 @@ def _setup_application_did_start_event(
     ) -> None:
         pass
 
-    def _create_route_handlers(self, config: Config) -> List[Tuple[Any, ...]]:
-        handlers = [
+    def _create_route_handlers(self, config: Config) -> _RouteHandlerSpecs:
+        handlers: _RouteHandlerSpecs = [
             (
                 "/stream",
                 self._model_stream_handler_type,
@@ -119,18 +122,18 @@ def _run_application_in_thread(
         self._run_application(config, app, host, port, args, kwargs)
 
 
-class PerClientStateModelStreamHandler(WebSocketHandler):
+class PerClientStateModelStreamHandler(WebSocketHandler):  # type: ignore
     """A web-socket handler that serves up a new model stream to each new client"""
 
     _dispatcher_type: Type[AbstractDispatcher] = SingleViewDispatcher
     _dispatcher_inst: AbstractDispatcher
-    _message_queue: AsyncQueue
+    _message_queue: "AsyncQueue[str]"
 
     def initialize(self, component_constructor: ComponentConstructor) -> None:
         self._component_constructor = component_constructor
 
-    async def open(self):
-        message_queue = AsyncQueue()
+    async def open(self) -> None:
+        message_queue: "AsyncQueue[str]" = AsyncQueue()
         query_params = {k: v[0].decode() for k, v in self.request.arguments.items()}
         dispatcher = self._dispatcher_type(
             Layout(self._component_constructor(**query_params))
@@ -154,7 +157,7 @@ async def run() -> None:
     async def on_message(self, message: str) -> None:
         await self._message_queue.put(message)
 
-    def on_close(self):
+    def on_close(self) -> None:
         asyncio.ensure_future(self._dispatcher_inst.__aexit__(None, None, None))
 
 

idom/server/utils.py

@@ -24,7 +24,7 @@ def find_builtin_server_type(type_name: str) -> Type[Any]:
 
     for builtin_module in installed_builtin_modules:
         try:
-            return getattr(builtin_module, type_name)
+            return getattr(builtin_module, type_name)  # type: ignore
         except AttributeError:  # pragma: no cover
             pass
     else:  # pragma: no cover

idom/testing.py

@@ -1,9 +1,7 @@
 from urllib.parse import urlunparse, urlencode
-from contextlib import contextmanager
 from typing import (
     Callable,
     Tuple,
-    Iterator,
     Type,
     Optional,
     Any,
@@ -20,7 +18,6 @@
 from idom.server.base import AbstractRenderServer
 from idom.server.prefab import hotswap_server
 from idom.server.utils import find_available_port
-from idom.utils import Ref
 
 
 __all__ = [
@@ -55,7 +52,7 @@ def create_simple_selenium_web_driver(
 
 class ServerMountPoint(Generic[_Mount, _Server]):
 
-    __slots__ = "server", "host", "port", "_mount", "__weakref__"
+    __slots__ = "server", "host", "port", "mount", "__weakref__"
 
     def __init__(
         self,
@@ -64,32 +61,23 @@ def __init__(
         port: Optional[int] = None,
         server_config: Optional[Any] = None,
         run_kwargs: Optional[Dict[str, Any]] = None,
-        mount_and_server_constructor: "Callable[..., Tuple[_Mount, _Server]]" = hotswap_server,
+        mount_and_server_constructor: "Callable[..., Tuple[_Mount, _Server]]" = hotswap_server,  # type: ignore
         app: Optional[Any] = None,
         **other_options: Any,
     ):
         self.host = host
         self.port = port or find_available_port(host)
-        self._mount, server = mount_and_server_constructor(
-            (
-                server_type
-                if issubclass(server_type, _RenderServerWithLastError)
-                else type(
-                    server_type.__name__,
-                    (_RenderServerWithLastError, server_type),
-                    {"last_server_error_for_idom_testing": Ref(None)},
-                )
-            ),
+        self.mount, self.server = mount_and_server_constructor(
+            server_type,
             self.host,
             self.port,
             server_config,
             run_kwargs,
             app,
             **other_options,
         )
-        self.server = server
         # stop server once mount is done being used
-        finalize(self, server.stop)
+        finalize(self, self.server.stop)
 
     def url(self, path: str = "", query: Optional[Any] = None) -> str:
         return urlunparse(
@@ -102,25 +90,3 @@ def url(self, path: str = "", query: Optional[Any] = None) -> str:
                 "",
             ]
         )
-
-    @contextmanager
-    def open_mount_function(self) -> Iterator[_Mount]:
-        self.server.last_server_error_for_idom_testing.current = None
-        try:
-            yield self._mount
-        finally:
-            if self.server.last_server_error_for_idom_testing.current is not None:
-                raise self.server.last_server_error_for_idom_testing.current  # pragma: no cover
-
-
-class _RenderServerWithLastError(AnyRenderServer):
-    """A server that updates the ``last_server_error`` fixture"""
-
-    last_server_error_for_idom_testing: Ref[Optional[Exception]]
-
-    async def _run_dispatcher(self, *args: Any, **kwargs: Any) -> None:
-        self.last_server_error_for_idom_testing.current = None
-        try:
-            await super()._run_dispatcher(*args, **kwargs)
-        except Exception as e:
-            self.last_server_error_for_idom_testing.current = e

noxfile.py

@@ -26,7 +26,9 @@ def test_with_coverage(session: Session) -> None:
 @nox.session
 def check_types(session: Session) -> None:
     session.install("-r", "requirements/check-types.txt")
+    session.log("Check Packages (strict)")
     session.run("mypy", "--strict", "idom")
+    session.log("Check Tests (lenient)")
     session.run("mypy", "tests")
 
 

tests/conftest.py

@@ -40,12 +40,14 @@ def pytest_addoption(parser: Parser) -> None:
 
 
 @pytest.fixture
-def display(driver, server_mount_point, mount):
+def display(driver, server_mount_point):
     display_id = idom.Ref(0)
 
     def mount_and_display(component_constructor, query=None, check_mount=True):
         component_id = f"display-{display_id.set_current(display_id.current + 1)}"
-        mount(lambda: idom.html.div({"id": component_id}, component_constructor()))
+        server_mount_point.mount(
+            lambda: idom.html.div({"id": component_id}, component_constructor())
+        )
         driver.get(server_mount_point.url(query=query))
         if check_mount:
             driver.find_element_by_id(component_id)
@@ -59,17 +61,6 @@ def driver_get(driver, server_mount_point):
     return lambda query=None: driver.get(server_mount_point.url(query=query))
 
 
-@pytest.fixture
-def mount(server_mount_point):
-    with server_mount_point.open_mount_function() as mount:
-        yield mount
-
-
-@pytest.fixture
-def last_server_error(server_mount_point):
-    return server_mount_point.server.last_server_error_for_idom_testing
-
-
 @pytest.fixture
 def server_mount_point():
     """An IDOM layout mount function and server as a tuple
@@ -115,11 +106,13 @@ def driver_is_headless(pytestconfig: Config):
 
 @pytest.fixture(autouse=True)
 def caplog(_caplog: LogCaptureFixture) -> Iterator[LogCaptureFixture]:
-
     handler_id = logger.add(_PropogateHandler(), format="{message}")
     yield _caplog
     logger.remove(handler_id)
-    assert not _caplog.record_tuples
+    for record in _caplog.records:
+        if record.exc_info:
+            raise record.exc_info[1]
+        assert record.levelno < logging.ERROR
 
 
 class _PropogateHandler(logging.Handler):

tests/test_core/test_element.py renamed to tests/test_core/test_component.py

@@ -21,7 +21,7 @@ def server_mount_point(request):
     return ServerMountPoint(request.param, sync_views=True)
 
 
-def test_shared_client_state(create_driver, mount, server_mount_point):
+def test_shared_client_state(create_driver, server_mount_point):
     driver_1 = create_driver()
     driver_2 = create_driver()
     was_garbage_collected = Event()
@@ -46,7 +46,7 @@ def Counter(count):
         finalize(component, was_garbage_collected.set)
         return idom.html.div({"id": f"count-is-{count}"}, count)
 
-    mount(IncrCounter)
+    server_mount_point.mount(IncrCounter)
 
     driver_1.get(server_mount_point.url())
     driver_2.get(server_mount_point.url())
@@ -71,15 +71,17 @@ def Counter(count):
 
 
 def test_shared_client_state_server_does_not_support_per_client_parameters(
-    driver_get, last_server_error
+    driver_get, caplog
 ):
     driver_get({"per_client_param": 1})
 
-    error = last_server_error.current
+    for record in caplog.records:
+        if record.exc_info and isinstance(record.exc_info[1], ValueError):
+            assert "does not support per-client view parameters" in str(
+                record.exc_info[1]
+            )
+            break
+    else:
+        assert False, "did not log error"
 
-    assert error is not None
-
-    assert isinstance(error, ValueError)
-    assert "does not support per-client view parameters" in str(error)
-
-    last_server_error.current = None
+    caplog.clear()