remove loguru and use builtin logging module

Author: rmorshea

.github/workflows/test.yml

@@ -2,6 +2,8 @@ name: Test
 
 on:
   push:
+    branches:
+      - main
   pull_request:
     branches:
       - main

idom/__init__.py

@@ -7,6 +7,7 @@
     # package is not installed
     __version__ = "0.0.0"
 
+from . import log
 from .client.module import Import, Module, install
 from .core import hooks
 from .core.component import Component, component
@@ -56,4 +57,5 @@
     "widgets",
     "client",
     "install",
+    "log",
 ]

idom/__main__.py

@@ -1,12 +1,4 @@
-import sys
-
-from loguru import logger
-
 from .cli import main
 
-logger.remove(0)
-logger.add(sys.stdout, format="{message}", level="INFO")
-
-
 if __name__ == "__main__":
     main()

idom/_options.py

@@ -0,0 +1,24 @@
+import os
+from typing import Any, Callable, Dict, Type
+
+IDOM_DEBUG_MODE = False
+
+
+def _load_os_environ() -> None:
+    from_string: Dict[Type[Any], Callable[[Any], Any]] = {
+        bool: lambda v: bool(int(v)),
+    }
+
+    module = globals()
+    for name, default in globals().items():
+        if not name.startswith("_") and name.upper() == name:
+            value_type = type(default)
+            value = os.environ.get(name, default)
+            if value_type in from_string:
+                value = from_string[value_type](value)
+            module[name] = value
+
+    return None
+
+
+_load_os_environ()

idom/client/manage.py

@@ -1,18 +1,19 @@
 import json
 import shutil
 import subprocess
+from logging import getLogger
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import List, Sequence, Set, Union
 
-from loguru import logger
-
 from .utils import (
     find_js_module_exports_in_source,
     get_package_name,
     open_modifiable_json,
 )
 
+logger = getLogger(__name__)
+
 APP_DIR = Path(__file__).parent / "app"
 BUILD_DIR = APP_DIR / "build"
 WEB_MODULES_DIR = BUILD_DIR / "web_modules"
@@ -102,7 +103,7 @@ def build(packages_to_install: Sequence[str], clean_build: bool = False) -> None
             snowpack_build = snowpack_config.setdefault("buildOptions", {})
             snowpack_build["clean"] = clean_build
 
-        logger.info(f"Installing {packages_to_install or 'packages'} ...", debug=True)
+        logger.info(f"Installing {packages_to_install or 'packages'} ...")
         _npm_install(packages_to_install, temp_app_dir)
         logger.info("Installed successfully ✅")
 

idom/core/dispatcher.py

@@ -1,5 +1,6 @@
 import abc
 import asyncio
+from logging import getLogger
 from typing import Any, AsyncIterator, Awaitable, Callable, Dict
 
 from anyio import create_task_group
@@ -8,6 +9,8 @@
 from .layout import Layout, LayoutEvent, LayoutUpdate
 from .utils import HasAsyncResources, async_resource
 
+logger = getLogger(__name__)
+
 SendCoroutine = Callable[[Any], Awaitable[None]]
 RecvCoroutine = Callable[[], Awaitable[LayoutEvent]]
 
@@ -49,12 +52,20 @@ async def run(self, send: SendCoroutine, recv: RecvCoroutine, context: Any) -> N
         return None
 
     async def _outgoing_loop(self, send: SendCoroutine, context: Any) -> None:
-        while True:
-            await send(await self._outgoing(self.layout, context))
+        try:
+            while True:
+                await send(await self._outgoing(self.layout, context))
+        except Exception:
+            logger.info("Failed to send outgoing update", exc_info=True)
+            raise
 
     async def _incoming_loop(self, recv: RecvCoroutine, context: Any) -> None:
-        while True:
-            await self._incoming(self.layout, context, await recv())
+        try:
+            while True:
+                await self._incoming(self.layout, context, await recv())
+        except Exception:
+            logger.info("Failed to receive incoming event", exc_info=True)
+            raise
 
     @abc.abstractmethod
     async def _outgoing(self, layout: Layout, context: Any) -> Any:

idom/core/hooks.py

@@ -1,4 +1,5 @@
 import asyncio
+from logging import getLogger
 from threading import get_ident as get_thread_id
 from typing import (
     Any,
@@ -17,7 +18,6 @@
     overload,
 )
 
-from loguru import logger
 from typing_extensions import Protocol
 
 from idom.utils import Ref
@@ -33,6 +33,7 @@
     "use_memo",
 ]
 
+logger = getLogger(__name__)
 
 _StateType = TypeVar("_StateType")
 

idom/core/layout.py

@@ -1,6 +1,7 @@
 import abc
 import asyncio
 from functools import wraps
+from logging import getLogger
 from typing import (
     Any,
     AsyncIterator,
@@ -16,16 +17,17 @@
 )
 
 from jsonpatch import apply_patch, make_patch
-from loguru import logger
 
-from idom.options import IDOM_DEBUG
+from idom._options import IDOM_DEBUG_MODE
 
 from .component import AbstractComponent
 from .events import EventHandler, EventTarget
 from .hooks import LifeCycleHook
 from .utils import CannotAccessResource, HasAsyncResources, async_resource
 from .vdom import validate_serialized_vdom
 
+logger = getLogger(__name__)
+
 
 class LayoutUpdate(NamedTuple):
     """An object describing an update to a :class:`Layout`"""
@@ -89,16 +91,18 @@ async def dispatch(self, event: LayoutEvent) -> None:
         handler = self._event_handlers.get(event.target)
         if handler is not None:
             await handler(event.data)
+        else:
+            logger.info(
+                f"Ignored event - handler {event.target!r} does not exist or its component unmounted"
+            )
 
     async def render(self) -> LayoutUpdate:
         while True:
             component = await self._rendering_queue.get()
             if self._has_component_state(component):
                 return self._create_layout_update(component)
 
-    if IDOM_DEBUG:
-        from loguru import logger
-
+    if IDOM_DEBUG_MODE:
         _debug_render = render
 
         @wraps(_debug_render)

idom/log.py

@@ -0,0 +1,36 @@
+import logging
+import sys
+from logging.config import dictConfig
+
+from ._options import IDOM_DEBUG_MODE
+
+root_logger = logging.getLogger("idom")
+
+
+LOGGING_CONFIG_DEFAULTS = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "loggers": {
+        "idom": {
+            "level": "DEBUG" if IDOM_DEBUG_MODE else "INFO",
+            "handlers": ["console"],
+        },
+    },
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+            "formatter": "generic",
+            "stream": sys.stdout,
+        }
+    },
+    "formatters": {
+        "generic": {
+            "format": "%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+            "datefmt": r"%Y-%m-%dT%H:%M:%S%z",
+            "class": "logging.Formatter",
+        }
+    },
+}
+
+
+dictConfig(LOGGING_CONFIG_DEFAULTS)

idom/options.py

@@ -15,7 +15,6 @@
 )
 from urllib.parse import urlencode, urlunparse
 
-from loguru import logger
 from selenium.webdriver import Chrome
 from selenium.webdriver.remote.webdriver import WebDriver
 
@@ -61,7 +60,6 @@ class ServerMountPoint(Generic[_Mount, _Server]):
     server: _Server
 
     _log_handler: "_LogRecordCaptor"
-    _loguru_handler_id: int
 
     def __init__(
         self,
@@ -113,20 +111,28 @@ def assert_logged_exception(
             if clear_after:
                 self.log_records.clear()
 
-    def raise_first_logged_exception(
+    def raise_if_logged_exception(
         self,
+        log_level: int = logging.ERROR,
         exclude_exc_types: Union[Type[Exception], Tuple[Type[Exception], ...]] = (),
+        clear_after: bool = True,
     ) -> None:
         """Raise the first logged exception (if any)
 
         Args:
+            log_level: The level of log to check
             exclude_exc_types: Any exception types to ignore
+            clear_after: Whether to clear logs after check
         """
-        for record in self._log_handler.records:
-            if record.exc_info is not None:
-                error = record.exc_info[1]
-                if error is not None and not isinstance(error, exclude_exc_types):
-                    raise error
+        try:
+            for record in self._log_handler.records:
+                if record.levelno >= log_level and record.exc_info is not None:
+                    error = record.exc_info[1]
+                    if error is not None and not isinstance(error, exclude_exc_types):
+                        raise error
+        finally:
+            if clear_after:
+                self.log_records.clear()
 
     def url(self, path: str = "", query: Optional[Any] = None) -> str:
         return urlunparse(
@@ -143,7 +149,6 @@ def url(self, path: str = "", query: Optional[Any] = None) -> str:
     def __enter__(self: _Self) -> _Self:
         self._log_handler = _LogRecordCaptor()
         logging.getLogger().addHandler(self._log_handler)
-        self._loguru_handler_id = logger.add(self._log_handler, format="{message}")
         self.mount, self.server = self._mount_and_server_constructor()
         return self
 
@@ -154,12 +159,8 @@ def __exit__(
         traceback: Optional[TracebackType],
     ) -> None:
         self.server.stop()
-
         logging.getLogger().removeHandler(self._log_handler)
-        logger.remove(self._loguru_handler_id)
-
-        self.raise_first_logged_exception()
-
+        self.raise_if_logged_exception()
         return None
 
 

idom/testing.py

@@ -85,7 +85,7 @@ def test(session: Session) -> None:
 @nox.session
 def test_python(session: Session) -> None:
     """Run the Python-based test suite"""
-    session.env["IDOM_DEBUG"] = "1"
+    session.env["IDOM_DEBUG_MODE"] = "1"
     session.install("-r", "requirements/test-env.txt")
     session.install(".[all]")
     args = ["pytest", "tests"] + get_posargs("pytest", session)

noxfile.py

@@ -1,4 +1,3 @@
-loguru >=0.3.2
 typing-extensions >=3.7.4
 mypy-extensions >=0.4.3
 anyio >=2.0

requirements/pkg-deps.txt

@@ -11,7 +11,6 @@
 from _pytest.config.argparsing import Parser
 from _pytest.logging import LogCaptureFixture
 from _pytest.logging import caplog as _caplog  # noqa
-from loguru import logger
 from selenium.webdriver import Chrome, ChromeOptions
 from selenium.webdriver.support.ui import WebDriverWait
 
@@ -110,9 +109,9 @@ def driver_is_headless(pytestconfig: Config):
 
 @pytest.fixture(autouse=True)
 def caplog(_caplog: LogCaptureFixture) -> Iterator[LogCaptureFixture]:
-    handler_id = logger.add(_PropogateHandler(), format="{message}")
+    _caplog.set_level(logging.DEBUG)
     yield _caplog
-    logger.remove(handler_id)
+    # check that there are no ERROR level log messages
     for record in _caplog.records:
         if record.exc_info:
             raise record.exc_info[1]