feat: type hinting in gLogger

Author: aldbr

src/DIRAC/FrameworkSystem/private/standardLogging/LogLevels.py

@@ -1,6 +1,7 @@
 """
 LogLevels wrapper
 """
+from __future__ import annotations
 from enum import IntEnum
 import logging
 
@@ -53,7 +54,7 @@ class LogLevels:
     }
 
     @classmethod
-    def getLevelValue(cls, sName):
+    def getLevelValue(cls, sName: str) -> int | None:
         """
         Get a level value from a level name.
         We could use logging.getLevelName() to get the level value but it is less simple.
@@ -64,7 +65,7 @@ def getLevelValue(cls, sName):
         return cls.__levelDict.get(sName.upper())
 
     @classmethod
-    def getLevel(cls, level):
+    def getLevel(cls, level: int) -> str | None:
         """
         Get a level name from a level value.
         We could use logging.getLevelName() to get the level value but it is less simple.
@@ -78,14 +79,14 @@ def getLevel(cls, level):
         return None
 
     @classmethod
-    def getLevelNames(cls):
+    def getLevelNames(cls) -> list[str]:
         """
         :return: all level names available in the wrapper
         """
         return list(cls.__levelDict)
 
     @classmethod
-    def getLevels(cls):
+    def getLevels(cls) -> dict[str, int]:
         """
         :return: the level dictionary. Must no be redefined
         """

src/DIRAC/FrameworkSystem/private/standardLogging/Logging.py

@@ -1,6 +1,7 @@
 """
 Logging
 """
+from __future__ import annotations
 import logging
 import os
 
@@ -29,7 +30,7 @@ class Logging:
     # lock the configuration of the Logging
     _lockConfig = _lockRing.getLock("config")
 
-    def __init__(self, father=None, name=""):
+    def __init__(self, father: Logging | None = None, name: str = ""):
         """
         Initialization of the Logging object. By default, 'name' is empty,
         because getChild only accepts string and the first empty string corresponds to the root logger.
@@ -93,15 +94,15 @@ def __init__(self, father=None, name=""):
         # lockObjectLoader to protect the ObjectLoader singleton
         self._lockObjectLoader = self._lockRing.getLock("objectLoader")
 
-    def showHeaders(self, yesno=True):
+    def showHeaders(self, yesno: bool = True):
         """
         Depending on the value, display or not the prefix of the message.
 
         :param bool yesno: determine the log record format
         """
         self._setOption("headerIsShown", yesno)
 
-    def showThreadIDs(self, yesno=True):
+    def showThreadIDs(self, yesno: bool = True):
         """
         Depending on the value, display or not the thread ID.
         Make sure to enable the headers: showHeaders(True) before
@@ -110,7 +111,7 @@ def showThreadIDs(self, yesno=True):
         """
         self._setOption("threadIDIsShown", yesno)
 
-    def showTimeStamps(self, yesno=True):
+    def showTimeStamps(self, yesno: bool = True):
         """
         Depending on the value, display or not the timestamp of the message.
         Make sure to enable the headers: showHeaders(True) before
@@ -119,7 +120,7 @@ def showTimeStamps(self, yesno=True):
         """
         self._setOption("timeStampIsShown", yesno)
 
-    def showContexts(self, yesno=True):
+    def showContexts(self, yesno: bool = True):
         """
         Depending on the value, display or not the context of the message.
         Make sure to enable the headers: showHeaders(True) before
@@ -128,7 +129,7 @@ def showContexts(self, yesno=True):
         """
         self._setOption("contextIsShown", yesno)
 
-    def _setOption(self, optionName, value, directCall=True):
+    def _setOption(self, optionName: str, value: bool, directCall: bool = True):
         """
         Depending on the value, modify the value of the option and propagate the option to the children.
         The options of the children will be updated if they were not modified before by a developer.
@@ -155,7 +156,9 @@ def _setOption(self, optionName, value, directCall=True):
         finally:
             self._lockOptions.release()
 
-    def registerBackend(self, desiredBackend, backendOptions=None, backendFilters=None):
+    def registerBackend(
+        self, desiredBackend: str, backendOptions: dict | None = None, backendFilters: dict | None = None
+    ) -> bool:
         """
         Attach a backend to the Logging object.
         Convert backend name to backend class name to a Backend object and add it to the Logging object
@@ -184,7 +187,7 @@ def registerBackend(self, desiredBackend, backendOptions=None, backendFilters=No
         self._addBackend(_class["Value"], backendOptions, filterInstances)
         return True
 
-    def _addBackend(self, backendType, backendOptions=None, backendFilters=None):
+    def _addBackend(self, backendType, backendOptions: dict | None = None, backendFilters: list | None = None):
         """
         Attach a Backend object to the Logging object.
 
@@ -205,7 +208,7 @@ def _addBackend(self, backendType, backendOptions=None, backendFilters=None):
             self._lockLevel.release()
             self._lockOptions.release()
 
-    def _generateFilter(self, filterType, filterOptions=None):
+    def _generateFilter(self, filterType: str, filterOptions: dict | None = None):
         """
         Create a filter and add it to the handler of the backend.
 
@@ -218,7 +221,7 @@ def _generateFilter(self, filterType, filterOptions=None):
             return None
         return _class["Value"](filterOptions)
 
-    def setLevel(self, levelName):
+    def setLevel(self, levelName: str) -> bool:
         """
         Check if the level name exists and set it.
 
@@ -234,13 +237,13 @@ def setLevel(self, levelName):
             return True
         return False
 
-    def getLevel(self):
+    def getLevel(self) -> str:
         """
         :return: the name of the level
         """
         return LogLevels.getLevel(self._logger.getEffectiveLevel())
 
-    def shown(self, levelName):
+    def shown(self, levelName: str) -> bool:
         """
         Determine whether messages with a certain level will be displayed.
 
@@ -259,19 +262,19 @@ def shown(self, levelName):
             self._lockLevel.release()
 
     @classmethod
-    def getName(cls):
+    def getName(cls) -> str:
         """
         :return: "system name/component name"
         """
         return cls._componentName
 
-    def getSubName(self):
+    def getSubName(self) -> str:
         """
         :return: the name of the logger
         """
         return self.name
 
-    def getDisplayOptions(self):
+    def getDisplayOptions(self) -> dict[str, bool]:
         """
         :return: the dictionary of the display options and their values. Must not be redefined
         """
@@ -284,7 +287,7 @@ def getDisplayOptions(self):
         finally:
             self._lockOptions.release()
 
-    def __loadLogClass(self, modulePath):
+    def __loadLogClass(self, modulePath: str):
         """Load class thread-safe."""
         # import ObjectLoader here to avoid a dependancy loop
         from DIRAC.Core.Utilities.ObjectLoader import ObjectLoader
@@ -300,69 +303,71 @@ def __loadLogClass(self, modulePath):
             self._lockObjectLoader.release()
 
     @staticmethod
-    def getAllPossibleLevels():
+    def getAllPossibleLevels() -> list[str]:
         """
         :return: a list of all levels available
         """
         return LogLevels.getLevelNames()
 
-    def always(self, sMsg, sVarMsg=""):
+    def always(self, sMsg: str, sVarMsg: str = "") -> bool:
         """
         Always level
         """
         return self._createLogRecord(LogLevels.ALWAYS, sMsg, sVarMsg)
 
-    def notice(self, sMsg, sVarMsg=""):
+    def notice(self, sMsg: str, sVarMsg: str = "") -> bool:
         """
         Notice level
         """
         return self._createLogRecord(LogLevels.NOTICE, sMsg, sVarMsg)
 
-    def info(self, sMsg, sVarMsg=""):
+    def info(self, sMsg: str, sVarMsg: str = "") -> bool:
         """
         Info level
         """
         return self._createLogRecord(LogLevels.INFO, sMsg, sVarMsg)
 
-    def verbose(self, sMsg, sVarMsg=""):
+    def verbose(self, sMsg: str, sVarMsg: str = "") -> bool:
         """
         Verbose level
         """
         return self._createLogRecord(LogLevels.VERBOSE, sMsg, sVarMsg)
 
-    def debug(self, sMsg, sVarMsg=""):
+    def debug(self, sMsg: str, sVarMsg: str = "") -> bool:
         """
         Debug level
         """
         return self._createLogRecord(LogLevels.DEBUG, sMsg, sVarMsg)
 
-    def warn(self, sMsg, sVarMsg=""):
+    def warn(self, sMsg: str, sVarMsg: str = "") -> bool:
         """
         Warn
         """
         return self._createLogRecord(LogLevels.WARN, sMsg, sVarMsg)
 
-    def error(self, sMsg, sVarMsg=""):
+    def error(self, sMsg: str, sVarMsg: str = "") -> bool:
         """
         Error level
         """
         return self._createLogRecord(LogLevels.ERROR, sMsg, sVarMsg)
 
-    def exception(self, sMsg="", sVarMsg="", lException=False, lExcInfo=False):
+    def exception(self, sMsg: str = "", sVarMsg: str = "", lException: bool = False, lExcInfo: bool = False) -> bool:
         """
         Exception level
         """
         _ = lException  # Make pylint happy
         _ = lExcInfo
         return self._createLogRecord(LogLevels.ERROR, sMsg, sVarMsg, exc_info=True)
 
-    def fatal(self, sMsg, sVarMsg=""):
+    def fatal(self, sMsg: str, sVarMsg: str = "") -> bool:
         """
         Fatal level
         """
         return self._createLogRecord(LogLevels.FATAL, sMsg, sVarMsg)
 
-    def _createLogRecord(self, level, sMsg, sVarMsg, exc_info=False, local_context=None):
+    def _createLogRecord(
+        self, level: int, sMsg: str, sVarMsg: str, exc_info: bool = False, local_context: dict | None = None
+    ) -> bool:
         """
         Create a log record according to the level of the message.
 
@@ -410,15 +415,15 @@ def _createLogRecord(self, level, sMsg, sVarMsg, exc_info=False, local_context=N
         finally:
             self._lockLevel.release()
 
-    def showStack(self):
+    def showStack(self) -> bool:
         """
         Display a debug message without any content.
 
         :return: boolean, True if the message is sent, else False
         """
         return self.debug("")
 
-    def getSubLogger(self, subName):
+    def getSubLogger(self, subName: str) -> Logging:
         """
         Create a new Logging object, child of this Logging, if it does not exists.
 
@@ -459,7 +464,7 @@ class LocalSubLogger:
         (see https://github.com/DIRACGrid/DIRAC/issues/5280)
         """
 
-        def __init__(self, logger, extra):
+        def __init__(self, logger: Logging, extra: dict):
             """
             :param logger: :py:class:`Logging` object on which to be based
             :param extra: dictionary of extra information to be passed
@@ -468,63 +473,65 @@ def __init__(self, logger, extra):
             self.logger = logger
             self.extra = extra
 
-        def always(self, sMsg, sVarMsg=""):
+        def always(self, sMsg: str, sVarMsg: str = "") -> bool:
             """
             Always level
             """
             return self.logger._createLogRecord(  # pylint: disable=protected-access
                 LogLevels.ALWAYS, sMsg, sVarMsg, local_context=self.extra
             )
 
-        def notice(self, sMsg, sVarMsg=""):
+        def notice(self, sMsg: str, sVarMsg: str = "") -> bool:
             """
             Notice level
             """
             return self.logger._createLogRecord(  # pylint: disable=protected-access
                 LogLevels.NOTICE, sMsg, sVarMsg, local_context=self.extra
             )
 
-        def info(self, sMsg, sVarMsg=""):
+        def info(self, sMsg: str, sVarMsg: str = "") -> bool:
             """
             Info level
             """
             return self.logger._createLogRecord(  # pylint: disable=protected-access
                 LogLevels.INFO, sMsg, sVarMsg, local_context=self.extra
             )
 
-        def verbose(self, sMsg, sVarMsg=""):
+        def verbose(self, sMsg: str, sVarMsg: str = "") -> bool:
             """
             Verbose level
             """
             return self.logger._createLogRecord(  # pylint: disable=protected-access
                 LogLevels.VERBOSE, sMsg, sVarMsg, local_context=self.extra
             )
 
-        def debug(self, sMsg, sVarMsg=""):
+        def debug(self, sMsg: str, sVarMsg: str = "") -> bool:
             """
             Debug level
             """
             return self.logger._createLogRecord(  # pylint: disable=protected-access
                 LogLevels.DEBUG, sMsg, sVarMsg, local_context=self.extra
             )
 
-        def warn(self, sMsg, sVarMsg=""):
+        def warn(self, sMsg: str, sVarMsg: str = "") -> bool:
             """
             Warn
             """
             return self.logger._createLogRecord(  # pylint: disable=protected-access
                 LogLevels.WARN, sMsg, sVarMsg, local_context=self.extra
             )
 
-        def error(self, sMsg, sVarMsg=""):
+        def error(self, sMsg: str, sVarMsg: str = "") -> bool:
             """
             Error level
             """
             return self.logger._createLogRecord(  # pylint: disable=protected-access
                 LogLevels.ERROR, sMsg, sVarMsg, local_context=self.extra
             )
 
-        def exception(self, sMsg="", sVarMsg="", lException=False, lExcInfo=False):
+        def exception(
+            self, sMsg: str = "", sVarMsg: str = "", lException: bool = False, lExcInfo: bool = False
+        ) -> bool:
             """
             Exception level
             """
@@ -534,15 +541,15 @@ def exception(self, sMsg="", sVarMsg="", lException=False, lExcInfo=False):
                 LogLevels.ERROR, sMsg, sVarMsg, exc_info=True, local_context=self.extra
             )
 
-        def fatal(self, sMsg, sVarMsg=""):
+        def fatal(self, sMsg: str, sVarMsg: str = "") -> bool:
             """
             Fatal level
             """
             return self.logger._createLogRecord(  # pylint: disable=protected-access
                 LogLevels.FATAL, sMsg, sVarMsg, local_context=self.extra
             )
 
-    def getLocalSubLogger(self, subName):
+    def getLocalSubLogger(self, subName: str) -> Logging.LocalSubLogger:
         """
         Create a subLogger which is meant to have very short lifetime,
         (e.g. when you want to add the jobID in the name)