More type hints

radicale/log.py

@@ -25,42 +25,46 @@ Log messages are sent to the first available target of:
 
 """
 
-import contextlib
 import logging
 import os
 import sys
 import threading
+from typing import Any, Callable, ClassVar, Dict, Iterator, Union
 
-LOGGER_NAME = "radicale"
-LOGGER_FORMAT = "[%(asctime)s] [%(ident)s] [%(levelname)s] %(message)s"
-DATE_FORMAT = "%Y-%m-%d %H:%M:%S %z"
+from radicale import types
 
-logger = logging.getLogger(LOGGER_NAME)
+LOGGER_NAME: str = "radicale"
+LOGGER_FORMAT: str = "[%(asctime)s] [%(ident)s] [%(levelname)s] %(message)s"
+DATE_FORMAT: str = "%Y-%m-%d %H:%M:%S %z"
+
+logger: logging.Logger = logging.getLogger(LOGGER_NAME)
 
 
 class RemoveTracebackFilter(logging.Filter):
-    def filter(self, record):
+
+    def filter(self, record: logging.LogRecord) -> bool:
         record.exc_info = None
         return True
 
 
-REMOVE_TRACEBACK_FILTER = RemoveTracebackFilter()
+REMOVE_TRACEBACK_FILTER: logging.Filter = RemoveTracebackFilter()
 
 
 class IdentLogRecordFactory:
     """LogRecordFactory that adds ``ident`` attribute."""
 
-    def __init__(self, upstream_factory):
-        self.upstream_factory = upstream_factory
+    def __init__(self, upstream_factory: Callable[..., logging.LogRecord]
+                 ) -> None:
+        self._upstream_factory = upstream_factory
 
-    def __call__(self, *args, **kwargs):
-        record = self.upstream_factory(*args, **kwargs)
+    def __call__(self, *args: Any, **kwargs: Any) -> logging.LogRecord:
+        record = self._upstream_factory(*args, **kwargs)
         ident = "%d" % os.getpid()
         main_thread = threading.main_thread()
         current_thread = threading.current_thread()
         if current_thread.name and main_thread != current_thread:
             ident += "/%s" % current_thread.name
-        record.ident = ident
+        record.ident = ident  # type:ignore[attr-defined]
         return record
 
 
@@ -68,13 +72,15 @@ class ThreadedStreamHandler(logging.Handler):
     """Sends logging output to the stream registered for the current thread or
        ``sys.stderr`` when no stream was registered."""
 
-    terminator = "\n"
+    terminator: ClassVar[str] = "\n"
 
-    def __init__(self):
+    _streams: Dict[int, types.ErrorStream]
+
+    def __init__(self) -> None:
         super().__init__()
         self._streams = {}
 
-    def emit(self, record):
+    def emit(self, record: logging.LogRecord) -> None:
         try:
             stream = self._streams.get(threading.get_ident(), sys.stderr)
             msg = self.format(record)
@@ -85,8 +91,8 @@ class ThreadedStreamHandler(logging.Handler):
         except Exception:
             self.handleError(record)
 
-    @contextlib.contextmanager
-    def register_stream(self, stream):
+    @types.contextmanager
+    def register_stream(self, stream: types.ErrorStream) -> Iterator[None]:
         """Register stream for logging output of the current thread."""
         key = threading.get_ident()
         self._streams[key] = stream
@@ -96,13 +102,13 @@ class ThreadedStreamHandler(logging.Handler):
             del self._streams[key]
 
 
-@contextlib.contextmanager
-def register_stream(stream):
+@types.contextmanager
+def register_stream(stream: types.ErrorStream) -> Iterator[None]:
     """Register stream for logging output of the current thread."""
     yield
 
 
-def setup():
+def setup() -> None:
     """Set global logging up."""
     global register_stream
     handler = ThreadedStreamHandler()
@@ -114,12 +120,12 @@ def setup():
     set_level(logging.WARNING)
 
 
-def set_level(level):
+def set_level(level: Union[int, str]) -> None:
     """Set logging level for global logger."""
     if isinstance(level, str):
         level = getattr(logging, level.upper())
+        assert isinstance(level, int)
     logger.setLevel(level)
-    if level == logging.DEBUG:
-        logger.removeFilter(REMOVE_TRACEBACK_FILTER)
-    else:
+    logger.removeFilter(REMOVE_TRACEBACK_FILTER)
+    if level > logging.DEBUG:
         logger.addFilter(REMOVE_TRACEBACK_FILTER)