Fix all of ruff

Author: emmuhamm

src/daqpytools/logging/__init__.py

@@ -1,14 +1,18 @@
-from daqpytools.logging.levels import logging_log_levels
-from daqpytools.logging.handlerconf import LogHandlerConf, HandlerType
-from daqpytools.logging.logger import setup_daq_ers_logger, get_daq_logger, setup_root_logger
+from daqpytools.logging.handlerconf import HandlerType, LogHandlerConf
 from daqpytools.logging.handlers import add_handler
+from daqpytools.logging.levels import logging_log_levels
+from daqpytools.logging.logger import (
+    get_daq_logger,
+    setup_daq_ers_logger,
+    setup_root_logger,
+)
 
 __all__ = [
-    "logging_log_levels",
-    "LogHandlerConf",
     "HandlerType",
-    "setup_daq_ers_logger",
+    "LogHandlerConf",
+    "add_handler",
     "get_daq_logger",
+    "logging_log_levels",
+    "setup_daq_ers_logger",
     "setup_root_logger",
-    "add_handler",
 ]

src/daqpytools/logging/exceptions.py

@@ -49,7 +49,10 @@ class ERSInitError(Exception):
 
     def __init__(self, address:str, topic:str) -> None:
         """C'tor."""
-        err_msg = f"The Kafka broker cannot be initialised using {address=} and {topic=}"
+        err_msg = (
+            "The Kafka broker cannot be initialised using "
+            f"{address=} and {topic=}"
+        )
         super().__init__(err_msg)
 
 

src/daqpytools/logging/filters.py

@@ -6,7 +6,6 @@
 from collections import defaultdict
 from datetime import datetime
 from threading import Lock
-from typing import Any
 
 from rich.text import Text
 
@@ -52,7 +51,11 @@ def __init__(
         allowed_handlers_strategy : AllowedHandlersStrategy | None = None,
     ) -> None:
         """C'tor."""
-        self.fallback_handlers = set(fallback_handlers) if fallback_handlers is not None else LogHandlerConf.get_base() #! We should check if this is still the case
+        self.fallback_handlers = (
+            set(fallback_handlers)
+            if fallback_handlers is not None
+            else LogHandlerConf.get_base()
+        )
 
         self.allowed_handlers_strategy = (
             allowed_handlers_strategy or 
@@ -61,6 +64,7 @@ def __init__(
         super().__init__()
 
     def get_allowed(self, record: logging.LogRecord) -> set[HandlerType] | None:
+        """Resolve the allowed handlers for a record."""
         return self.allowed_handlers_strategy.resolve(record, self.fallback_handlers)
 
 
@@ -261,9 +265,9 @@ def _build_throttle_filter(
     fallback_handlers: set[HandlerType],
     initial_treshold : int = 30,
     time_limit: int = 30,
-    **extras: Any,
+    **extras: object,
 ) -> logging.Filter:
-    """Build throttle filter from extras"""
+    """Build a throttle filter from extras."""
     del extras
     return ThrottleFilter(
         fallback_handlers=fallback_handlers,
@@ -282,20 +286,26 @@ def _build_throttle_filter(
     HandlerType.Throttle: THROTTLE_FILTER_SPEC
 }
 
-def get_filter_spec(handler_types: HandlerType):
+def get_filter_spec(handler_types: HandlerType) -> FilterSpec | None:
+    """Return the filter specification for a handler type."""
     return FILTER_SPEC_REGISTRY.get(handler_types)
 
 def add_filter(
     log: logging.Logger,
     handler_type:HandlerType,
     fallback_handlers : set[HandlerType]| None,
-    **extras: Any,
+    **extras: object,
 ) -> None:
-    """Add a logger filter according to the spec"""
+    """Add a logger filter according to the spec."""
     spec = get_filter_spec(handler_type)
 
+    effective_fallback_handlers = (
+        fallback_handlers
+        if fallback_handlers is not None
+        else set(spec.fallback_types)
+    )
     logger_filter = spec.factory(
-        fallback_handlers if fallback_handlers is not None else set(spec.fallback_types),
+        effective_fallback_handlers,
         **extras
     )
     log.addFilter(logger_filter)
@@ -305,7 +315,7 @@ def add_throttle_filter(
     log: logging.Logger,
     fallback_handlers: set[HandlerType] | None = None,
 ) -> None:
-    """Add the Throttle filter to the logger"""
+    """Add the Throttle filter to the logger."""
     add_filter(
         log,
         HandlerType.Throttle,

src/daqpytools/logging/handlerconf.py

@@ -189,8 +189,10 @@ def _make_ers_handler_conf(ers_log_level :str) -> ERSPyLogHandlerConf:
         protobufconf: ProtobufConf | None = None
 
         for raw_handler in envvalue.split(","):
-            handlertype, parsed_protobufconf = LogHandlerConf._convert_str_to_handlertype(
+            handlertype, parsed_protobufconf = (
+                LogHandlerConf._convert_str_to_handlertype(
                 raw_handler.strip()
+                )
             )
 
             if handlertype is not None:

src/daqpytools/logging/handlers.py

@@ -3,7 +3,7 @@
 import io
 import logging
 import sys
-from typing import Any, cast
+from typing import cast
 
 from erskafka.ERSKafkaLogHandler import ERSKafkaLogHandler
 
@@ -147,7 +147,7 @@ def logger_or_ancestors_have_handler(
 
 #### Handlers #### 
 
-def _build_rich_handler(width: int | None = None, **_: Any) -> logging.Handler:
+def _build_rich_handler(width: int | None = None, **_: object) -> logging.Handler:
     """Building the rich handler with any extras."""
     real_width = width if width is not None else get_width()
     return FormattedRichHandler(width=real_width)
@@ -159,7 +159,7 @@ def _build_rich_handler(width: int | None = None, **_: Any) -> logging.Handler:
     fallback_types = (HandlerType.Rich,), # For HandleIDFilter
 )
 
-def _build_stdout_handler(**_: Any) -> logging.Handler:
+def _build_stdout_handler(**_: object) -> logging.Handler:
     handler = logging.StreamHandler(sys.stdout)
     handler.setFormatter(LoggingFormatter())
     return handler
@@ -172,7 +172,7 @@ def _build_stdout_handler(**_: Any) -> logging.Handler:
     fallback_types = (HandlerType.Stream, HandlerType.Lstdout),
 )
 
-def _build_stderr_handler(**_: Any) -> logging.Handler:
+def _build_stderr_handler(**_: object) -> logging.Handler:
     handler = logging.StreamHandler(sys.stderr)
     handler.setFormatter(LoggingFormatter())
     handler.setLevel(logging.ERROR)
@@ -186,7 +186,7 @@ def _build_stderr_handler(**_: Any) -> logging.Handler:
     fallback_types = (HandlerType.Stream, HandlerType.Lstderr),
 )
 
-def _build_file_handler(path: str | None = None, **_: Any) -> logging.Handler:
+def _build_file_handler(path: str | None = None, **_: object) -> logging.Handler:
     if not path:
         err_msg = "path is required for file handler"
         raise ValueError(err_msg)
@@ -207,7 +207,7 @@ def _build_erskafka_handler(
         topic : str = "ers_stream",
         address : str = "monkafka.cern.ch:30092",
         ers_app_name : str | None = None,
-        **_) -> logging.Handler: 
+    **_: object) -> logging.Handler: 
 
     try:
         return ERSKafkaLogHandler(
@@ -216,8 +216,8 @@ def _build_erskafka_handler(
             kafka_topic = topic,
             app_name=ers_app_name
         )
-    except:
-        raise ERSInitError(address, topic)
+    except Exception as err:
+        raise ERSInitError(address, topic) from err
 
 
 ERSKAFKA_HANDLER_SPEC = HandlerSpec(
@@ -239,18 +239,23 @@ def _build_erskafka_handler(
     HandlerType.Protobufstream: (ERSKAFKA_HANDLER_SPEC,)
 }
 
-def get_handler_specs(handler_type: HandlerType):
-    """Get the specs defined in the registry"""
-    return HANDLER_SPEC_REGISTRY.get(handler_type, tuple())
+def get_handler_specs(handler_type: HandlerType) -> tuple[HandlerSpec, ...]:
+    """Get the specs defined in the registry."""
+    return HANDLER_SPEC_REGISTRY.get(handler_type, ())
 
 def add_handler(
     log: logging.Logger,
     handler_type: HandlerType | str, 
     use_parent_handlers:bool, 
     fallback_handler: set[HandlerType] | None = None,
-    **extras: Any
-):    
-    ht = HandlerType.from_string(handler_type) if isinstance(handler_type, str) else handler_type
+    **extras: object
+ ) -> None:
+    """Add a handler to the logger from the handler spec registry."""
+    ht = (
+        HandlerType.from_string(handler_type)
+        if isinstance(handler_type, str)
+        else handler_type
+    )
     specs = get_handler_specs(ht) 
 
     for spec in specs:
@@ -271,13 +276,20 @@ def add_handler(
         )
 
         handler = spec.factory(**extras)
-        effective_default_case = fallback_handler if fallback_handler is not None else spec.fallback_types
+        effective_default_case = (
+            fallback_handler
+            if fallback_handler is not None
+            else spec.fallback_types
+        )
 
         handler_ids: HandlerType | list[HandlerType]
         if len(spec.fallback_types) == 1:
             handler_ids = cast(HandlerType, spec.fallback_types[0])
         else: 
-            handler_ids = [cast(HandlerType, handler_id) for handler_id in spec.fallback_types] 
+            handler_ids = [
+                cast(HandlerType, handler_id)
+                for handler_id in spec.fallback_types
+            ] 
 
         handler.addFilter(
             HandleIDFilter(
@@ -294,7 +306,7 @@ def add_handlers_from_types(
     handler_types: set[HandlerType],
     use_parent_handlers: bool,
     fallback_handlers: set[HandlerType],
-    **extras: Any,
+    **extras: object,
 ) -> None:
     """Add handlers and filters from a set of HandlerType values.
 

src/daqpytools/logging/logger.py

@@ -69,7 +69,7 @@ def get_daq_logger(
     stream_handlers: bool = False,
     ers_kafka_session: str | None = None,
     throttle: bool = False,
-    **extras
+    **extras: object
 ) -> logging.Logger:
     """C'tor for the default logging instances.
 
@@ -85,6 +85,7 @@ def get_daq_logger(
             protobuf handler. If None, no ERS protobuf handler is added.
         throttle (bool): Whether to add the throttle filter or not. Note, does not mean
             outputs are filtered by default! See ThrottleFilter for details.
+        **extras (object): Extra keyword arguments forwarded to handler builders.
 
     Returns:
         logging.Logger: Configured logger instance.
@@ -183,6 +184,7 @@ def setup_daq_ers_logger(
     Args:
         logger (logging.Logger): Logger to configure.
         ers_kafka_session (str): ERS session name used for protobufstream handler.
+        ers_app_name (str | None): Optional ERS application name for kafka handler.
 
     Returns:
         None

src/daqpytools/logging/routing.py

@@ -6,12 +6,13 @@
 from daqpytools.logging.levels import level_to_ers_var
 
 """
-So this file basically allows us to define the set of handlers that the logger should send to 
+This module defines strategies that decide which handlers a logger should emit
+to for each record.
 """
 
 
 class AllowedHandlersStrategy(ABC):
-    """Strategy for resolving allowed handler types for a log record"""
+    """Strategy for resolving allowed handler types for a log record."""
 
     @abstractmethod
     def resolve(
@@ -22,18 +23,20 @@ def resolve(
         """Resolve allowd handlers for a given record."""
 
     def safe_return_set(self, raw_set : set[Any]) -> set[Any] | None:
+        """Return a set without `None` values, or `None` if empty."""
         return {obj for obj in raw_set if obj is not None}
 
 
 
 class DefaultAllowedHandlerStrategy(AllowedHandlersStrategy):
-    """Resolve allowed handlers from record.handlers, or a fallback case"""
+    """Resolve allowed handlers from `record.handlers` or a fallback set."""
 
     def resolve(
         self,
         record: logging.LogRecord,
         fallback_handlers : set[Any]
     ) -> set[Any] | None:
+        """Resolve handlers from the record or fallback handlers."""
         allowed = getattr(record, "handlers", fallback_handlers)
         if allowed is None:
             return None
@@ -47,7 +50,7 @@ def resolve(
         record: logging.LogRecord,
         fallback_handlers : set[Any] 
     ) -> set[Any] | None:
-        
+        """Resolve handlers from ERS metadata attached to the record."""
         del fallback_handlers # unused
 
         # Chain None checks using walrus operator
@@ -66,13 +69,14 @@ def resolve(
 
 
 class StreamAwareAllowedHandlersStrategy(AllowedHandlersStrategy):
-    """A dispatcher, chooses specific strategies based on record.stream"""
+    """Dispatch to a strategy based on `record.stream`."""
 
     def __init__(
         self,
         default_strategy : AllowedHandlersStrategy | None = None,
         ers_strategy: AllowedHandlersStrategy | None = None,
     ) -> None: 
+        """Initialize strategy dispatchers for default and ERS streams."""
         self.default_strategy =  default_strategy or DefaultAllowedHandlerStrategy()
         self.ers_strategy = ers_strategy or ERSAllowedHandlersStrategy()
 
@@ -81,7 +85,7 @@ def resolve(
         record: logging.LogRecord,
         fallback_handlers : set[Any],
         ) -> set[Any] | None:
-
+        """Resolve handlers using stream-aware strategy selection."""
         if getattr(record, "stream", None) == StreamType.ERS:
             return self.ers_strategy.resolve(record, fallback_handlers)
         return self.default_strategy.resolve(record, fallback_handlers)

src/daqpytools/logging/specs.py

@@ -48,4 +48,4 @@ class FilterSpec:
     alias: Any
     filter_class: type[logging.Filter]
     factory: Callable[[set[Any], Mapping[str, Any]], logging.Filter]
-    fallback_types: tuple[Any, ...] = tuple()
+    fallback_types: tuple[Any, ...] = ()