--- a/sat/core/log_config.py	Fri Apr 07 15:18:39 2023 +0200
+++ b/sat/core/log_config.py	Sat Apr 08 13:54:42 2023 +0200
@@ -47,8 +47,8 @@
 
 
 class ConfigureBasic(log.ConfigureBase):
-    def configureColors(self, colors, force_colors, levels_taints_dict):
-        super(ConfigureBasic, self).configureColors(
+    def configure_colors(self, colors, force_colors, levels_taints_dict):
+        super(ConfigureBasic, self).configure_colors(
             colors, force_colors, levels_taints_dict
         )
         if colors:
@@ -61,14 +61,14 @@
             # FIXME: isatty should be tested on each handler, not globaly
             if (force_colors or isatty):
                 # we need colors
-                log.Logger.post_treat = lambda logger, level, message: self.ansiColors(
+                log.Logger.post_treat = lambda logger, level, message: self.ansi_colors(
                     level, message
                 )
         elif force_colors:
             raise ValueError("force_colors can't be used if colors is False")
 
     @staticmethod
-    def getProfile():
+    def get_profile():
         """Try to find profile value using introspection"""
         import inspect
 
@@ -107,7 +107,7 @@
 class ConfigureTwisted(ConfigureBasic):
     LOGGER_CLASS = TwistedLogger
 
-    def preTreatment(self):
+    def pre_treatment(self):
         from twisted import logger
         global logger
         self.level_map = {
@@ -119,17 +119,17 @@
         }
         self.LOGGER_CLASS.level_map = self.level_map
 
-    def configureLevel(self, level):
+    def configure_level(self, level):
         self.level = self.level_map[level]
 
-    def configureOutput(self, output):
+    def configure_output(self, output):
         import sys
         from twisted.python import logfile
         self.log_publisher = logger.LogPublisher()
 
         if output is None:
             output = C.LOG_OPT_OUTPUT_SEP + C.LOG_OPT_OUTPUT_DEFAULT
-        self.manageOutputs(output)
+        self.manage_outputs(output)
 
         if C.LOG_OPT_OUTPUT_DEFAULT in log.handlers:
             if self.backend_data is None:
@@ -139,11 +139,11 @@
             options = self.backend_data
             log_file = logfile.LogFile.fromFullPath(options['logfile'])
             self.log_publisher.addObserver(
-                logger.FileLogObserver(log_file, self.textFormatter))
+                logger.FileLogObserver(log_file, self.text_formatter))
             # we also want output to stdout if we are in debug or nodaemon mode
             if options.get("nodaemon", False) or options.get("debug", False):
                 self.log_publisher.addObserver(
-                    logger.FileLogObserver(sys.stdout, self.textFormatter))
+                    logger.FileLogObserver(sys.stdout, self.text_formatter))
 
         if C.LOG_OPT_OUTPUT_FILE in log.handlers:
 
@@ -152,15 +152,15 @@
                     sys.stdout if path == "-" else logfile.LogFile.fromFullPath(path)
                 )
                 self.log_publisher.addObserver(
-                    logger.FileLogObserver(log_file, self.textFormatter))
+                    logger.FileLogObserver(log_file, self.text_formatter))
 
         if C.LOG_OPT_OUTPUT_MEMORY in log.handlers:
             raise NotImplementedError(
                 "Memory observer is not implemented in Twisted backend"
             )
 
-    def configureColors(self, colors, force_colors, levels_taints_dict):
-        super(ConfigureTwisted, self).configureColors(
+    def configure_colors(self, colors, force_colors, levels_taints_dict):
+        super(ConfigureTwisted, self).configure_colors(
             colors, force_colors, levels_taints_dict
         )
         self.LOGGER_CLASS.colors = colors
@@ -168,7 +168,7 @@
         if force_colors and not colors:
             raise ValueError("colors must be True if force_colors is True")
 
-    def postTreatment(self):
+    def post_treatment(self):
         """Install twistedObserver which manage non SàT logs"""
         # from twisted import logger
         import sys
@@ -180,7 +180,7 @@
         )
         logger.globalLogBeginner.beginLoggingTo([filtering_obs])
 
-    def textFormatter(self, event):
+    def text_formatter(self, event):
         if event.get('sat_logged', False):
             timestamp = ''.join([logger.formatTime(event.get("log_time", None)), " "])
             return f"{timestamp}{event.get('log_format', '')}\n"
@@ -219,7 +219,7 @@
             backend_data,
         )
 
-    def preTreatment(self):
+    def pre_treatment(self):
         """We use logging methods directly, instead of using Logger"""
         import logging
 
@@ -230,13 +230,13 @@
         log.error = logging.error
         log.critical = logging.critical
 
-    def configureLevel(self, level):
+    def configure_level(self, level):
         if level is None:
             level = C.LOG_LVL_DEBUG
         self.level = level
 
-    def configureFormat(self, fmt):
-        super(ConfigureStandard, self).configureFormat(fmt)
+    def configure_format(self, fmt):
+        super(ConfigureStandard, self).configure_format(fmt)
         import logging
 
         class SatFormatter(logging.Formatter):
@@ -250,11 +250,11 @@
 
             def format(self, record):
                 if self._with_profile:
-                    record.profile = ConfigureStandard.getProfile()
+                    record.profile = ConfigureStandard.get_profile()
                 do_color = self.with_colors and (self.can_colors or self.force_colors)
                 if ConfigureStandard._color_location:
                     # we copy raw formatting strings for color_*
-                    # as formatting is handled in ansiColors in this case
+                    # as formatting is handled in ansi_colors in this case
                     if do_color:
                         record.color_start = log.COLOR_START
                         record.color_end = log.COLOR_END
@@ -262,19 +262,19 @@
                         record.color_start = record.color_end = ""
                 s = super(SatFormatter, self).format(record)
                 if do_color:
-                    s = ConfigureStandard.ansiColors(record.levelname, s)
+                    s = ConfigureStandard.ansi_colors(record.levelname, s)
                 return s
 
         self.formatterClass = SatFormatter
 
-    def configureOutput(self, output):
-        self.manageOutputs(output)
+    def configure_output(self, output):
+        self.manage_outputs(output)
 
-    def configureLogger(self, logger):
+    def configure_logger(self, logger):
         self.name_filter = log.FilterName(logger) if logger else None
 
-    def configureColors(self, colors, force_colors, levels_taints_dict):
-        super(ConfigureStandard, self).configureColors(
+    def configure_colors(self, colors, force_colors, levels_taints_dict):
+        super(ConfigureStandard, self).configure_colors(
             colors, force_colors, levels_taints_dict
         )
         self.formatterClass.with_colors = colors
@@ -282,14 +282,14 @@
         if not colors and force_colors:
             raise ValueError("force_colors can't be used if colors is False")
 
-    def _addHandler(self, root_logger, hdlr, can_colors=False):
+    def _add_handler(self, root_logger, hdlr, can_colors=False):
         hdlr.setFormatter(self.formatterClass(can_colors))
         root_logger.addHandler(hdlr)
         root_logger.setLevel(self.level)
         if self.name_filter is not None:
             hdlr.addFilter(self.name_filter)
 
-    def postTreatment(self):
+    def post_treatment(self):
         import logging
 
         root_logger = logging.getLogger()
@@ -301,7 +301,7 @@
                         can_colors = hdlr.stream.isatty()
                     except AttributeError:
                         can_colors = False
-                    self._addHandler(root_logger, hdlr, can_colors=can_colors)
+                    self._add_handler(root_logger, hdlr, can_colors=can_colors)
                 elif handler == C.LOG_OPT_OUTPUT_MEMORY:
                     from logging.handlers import BufferingHandler
 
@@ -315,20 +315,20 @@
                     ] = (
                         hdlr
                     )  # we keep a reference to the handler to read the buffer later
-                    self._addHandler(root_logger, hdlr, can_colors=False)
+                    self._add_handler(root_logger, hdlr, can_colors=False)
                 elif handler == C.LOG_OPT_OUTPUT_FILE:
                     import os.path
 
                     for path in options:
                         hdlr = logging.FileHandler(os.path.expanduser(path))
-                        self._addHandler(root_logger, hdlr, can_colors=False)
+                        self._add_handler(root_logger, hdlr, can_colors=False)
                 else:
                     raise ValueError("Unknown handler type")
         else:
             root_logger.warning("Handlers already set on root logger")
 
     @staticmethod
-    def memoryGet(size=None):
+    def memory_get(size=None):
         """Return buffered logs
 
         @param size: number of logs to return
@@ -355,7 +355,7 @@
     return log.configure(backend, **options)
 
 
-def _parseOptions(options):
+def _parse_options(options):
     """Parse string options as given in conf or environment variable, and return expected python value
 
     @param options (dict): options with (key: name, value: string value)
@@ -378,7 +378,7 @@
         options[LEVEL] = level
 
 
-def satConfigure(backend=C.LOG_BACKEND_STANDARD, const=None, backend_data=None):
+def sat_configure(backend=C.LOG_BACKEND_STANDARD, const=None, backend_data=None):
     """Configure logging system for SàT, can be used by frontends
 
     logs conf is read in SàT conf, then in environment variables. It must be done before Memory init
@@ -396,16 +396,16 @@
     import os
 
     log_conf = {}
-    sat_conf = config.parseMainConf()
+    sat_conf = config.parse_main_conf()
     for opt_name, opt_default in C.LOG_OPTIONS():
         try:
             log_conf[opt_name] = os.environ[
                 "".join((C.ENV_PREFIX, C.LOG_OPT_PREFIX.upper(), opt_name.upper()))
             ]
         except KeyError:
-            log_conf[opt_name] = config.getConfig(
+            log_conf[opt_name] = config.config_get(
                 sat_conf, C.LOG_OPT_SECTION, C.LOG_OPT_PREFIX + opt_name, opt_default
             )
 
-    _parseOptions(log_conf)
+    _parse_options(log_conf)
     configure(backend, backend_data=backend_data, **log_conf)