massive refactoring to switch from camelCase to snake_case:

historically, Libervia (SàT before) was using camelCase as allowed by PEP8 when using a
pre-PEP8 code, to use the same coding style as in Twisted.

However, snake_case is more readable and it's better to follow PEP8 best practices, so it
has been decided to move on full snake_case. Because Libervia has a huge codebase, this
ended with a ugly mix of camelCase and snake_case.

To fix that, this patch does a big refactoring by renaming every function and method
(including bridge) that are not coming from Twisted or Wokkel, to use fully snake_case.

This is a massive change, and may result in some bugs.
This commit is contained in:
Goffi 2023-04-08 13:54:42 +02:00
commit 6a6f15707a

View file

@ -47,8 +47,8 @@ class TwistedLogger(log.Logger):
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 @@ class ConfigureBasic(log.ConfigureBase):
# 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 ConfigureBasic(log.ConfigureBase):
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 @@ class ConfigureTwisted(ConfigureBasic):
}
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 @@ class ConfigureTwisted(ConfigureBasic):
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 @@ class ConfigureTwisted(ConfigureBasic):
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 @@ class ConfigureTwisted(ConfigureBasic):
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 @@ class ConfigureTwisted(ConfigureBasic):
)
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 @@ class ConfigureStandard(ConfigureBasic):
backend_data,
)
def preTreatment(self):
def pre_treatment(self):
"""We use logging methods directly, instead of using Logger"""
import logging
@ -230,13 +230,13 @@ class ConfigureStandard(ConfigureBasic):
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 @@ class ConfigureStandard(ConfigureBasic):
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 @@ class ConfigureStandard(ConfigureBasic):
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 @@ class ConfigureStandard(ConfigureBasic):
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 @@ class ConfigureStandard(ConfigureBasic):
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 @@ class ConfigureStandard(ConfigureBasic):
] = (
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 @@ def configure(backend, **options):
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 @@ def _parseOptions(options):
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 @@ def satConfigure(backend=C.LOG_BACKEND_STANDARD, const=None, backend_data=None):
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)