ocrd_utils.logging.initLogging() - Code Metrics - Inspection of ":memo: changelog" - OCR-D/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 6d8539...583fdd )

by Konstantin

created 2024-11-18 13:49 UTC

ocrd_utils.logging.initLogging() C

↳ Parent: ocrd_utils.logging

Complexity

Conditions

Size

Total Lines	47
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	26
dl	0
loc	47
rs	5.9999
c	0
b	0
f	0
cc	10
nop	3

How to fix Complexity

"""
Logging setup

By default: Log with lastResort logger, usually STDERR.

Logging can be overridden either programmatically in code using the library or by creating one or more of

- /etc/ocrd_logging.py
- $HOME/ocrd_logging.py
- $PWD/ocrd_logging.py

These files will be executed in the context of ocrd/ocrd_logging.py, with `logging` global set.

Changes as of 2023-08-20:

    - Try to be less intrusive with OCR-D specific logging conventions to
      make it easier and less surprising to define logging behavior when
      using OCR-D/core as a library
    - Change setOverrideLogLevel to only override the log level of the ``ocrd``
      logger and its descendants
    - initLogging will set exactly one handler, for the root logger or for the
      ``ocrd`` logger.
    - Child loggers should propagate to the ancestor logging (default
      behavior of the logging library - no more PropagationShyLogger)
    - disableLogging only removes any handlers from the ``ocrd`` logger
"""
# pylint: disable=no-member

from __future__ import absolute_import

from traceback import format_stack

import logging
import logging.config
from pathlib import Path
import sys

from .constants import LOG_FORMAT, LOG_TIMEFMT
from .config import config


__all__ = [
    'disableLogging',
    'getLevelName',
    'getLogger',
    'initLogging',
    'logging',
    'setOverrideLogLevel',
]

LOGGING_DEFAULTS = {
    '': logging.WARNING,
    'ocrd': logging.INFO,
    'ocrd_network': logging.INFO,
    # 'ocrd.resolver': logging.INFO,
    # 'ocrd.resolver.download_to_directory': logging.INFO,
    # 'ocrd.resolver.add_files_to_mets': logging.INFO,
    # To cut back on the `Self-intersection at or near point` INFO messages
    'shapely.geos': logging.ERROR,
    'tensorflow': logging.ERROR,
    'PIL': logging.INFO,
    'paramiko.transport': logging.INFO,
    'uvicorn.access': logging.DEBUG,
    'uvicorn.error': logging.DEBUG,
    'uvicorn': logging.INFO,
    'multipart': logging.INFO,
}

_initialized_flag = False

_ocrdLevel2pythonLevel = {
    'TRACE': 'DEBUG',
    'OFF': 'CRITICAL',
    'FATAL': 'ERROR',
}

def tf_disable_interactive_logs():
    try:
        from os import environ
        # This env variable must be set before importing from Keras
        environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
        from tensorflow.keras.utils import disable_interactive_logging
        # Enabled interactive logging throws an exception
        # due to a call of sys.stdout.flush()
        disable_interactive_logging()
    except ImportError:
        # Nothing should be handled here if TF is not available
        pass

def getLevelName(lvl):
    """
    Get (string) python logging level for (string) spec-defined log level name.
    """
    lvl = _ocrdLevel2pythonLevel.get(lvl, lvl)
    return logging.getLevelName(lvl)

def getLogger(*args, **kwargs):
    """
    Wrapper around ``logging.getLogger`` that calls :py:func:`initLogging` if
    that wasn't explicitly called before.
    """
    logger = logging.getLogger(*args, **kwargs)
    return logger

def setOverrideLogLevel(lvl, silent=not config.OCRD_LOGGING_DEBUG):
    """
    Override the output log level of the handlers attached to the ``ocrd`` logger.

    Args:
        lvl (string): Log level name.
        silent (boolean): Whether to log the override call
    """
    if lvl is not None:
        lvl = getLevelName(lvl)
        if not _initialized_flag:
            initLogging(silent=silent)
        # affect all configured loggers
        for logger_name in logging.root.manager.loggerDict:
            if not silent:
                print(f'[LOGGING] Overriding {logger_name} log level to {lvl}', file=sys.stderr)
            logging.getLogger(logger_name).setLevel(lvl)

def get_logging_config_files():
    """
    Return a list of all ``ocrd_logging.conf`` files found in CWD, HOME or /etc.
    """
    CONFIG_PATHS = [
        Path.cwd(),
        Path.home(),
        Path('/etc'),
    ]
    return [f for f \
            in [p / 'ocrd_logging.conf' for p in CONFIG_PATHS] \
            if f.exists()]

def initLogging(builtin_only=False, force_reinit=False, silent=not config.OCRD_LOGGING_DEBUG):
    """
    Reset ``ocrd`` logger, read logging configuration if exists, otherwise use basicConfig

    initLogging is to be called by OCR-D/core once, i.e.
        -  for the ``ocrd`` CLI
        -  for the processor wrapper methods

    Other processes that use OCR-D/core as a library can, but do not have to, use this functionality.

    Keyword Args:
        - builtin_only (bool, False): Whether to search for logging configuration
                                      on-disk (``False``) or only use the
                                      hard-coded config (``True``). For testing
        - force_reinit (bool, False): Whether to ignore the module-level
                                      ``_initialized_flag``. For testing only.
        - silent (bool, True): Whether to log logging behavior by printing to stderr
    """
    global _initialized_flag
    if _initialized_flag:
        if force_reinit:
            disableLogging(silent=silent)
        else:
            return

    config_file = None
    if not builtin_only:
        config_file = get_logging_config_files()
    if config_file:
        if len(config_file) > 1 and not silent:
            print(f"[LOGGING] Multiple logging configuration files found at {config_file}, using first one", file=sys.stderr)
        config_file = config_file[0]
        if not silent:
            print(f"[LOGGING] Picked up logging config at {config_file}", file=sys.stderr)
        logging.config.fileConfig(config_file)
    else:
        if not silent:
            print("[LOGGING] Initializing logging with built-in defaults", file=sys.stderr)
        # Default logging config
        ocrd_handler = logging.StreamHandler(stream=sys.stderr)
        ocrd_handler.setFormatter(logging.Formatter(fmt=LOG_FORMAT, datefmt=LOG_TIMEFMT))
        ocrd_handler.setLevel(logging.DEBUG)
        root_logger = logging.getLogger('')
        root_logger.addHandler(ocrd_handler)
        for logger_name, logger_level in LOGGING_DEFAULTS.items():
            logging.getLogger(logger_name).setLevel(logger_level)
    _initialized_flag = True

def disableLogging(silent=not config.OCRD_LOGGING_DEBUG):
    """
    Disables all logging of the ``ocrd`` logger and descendants

    Keyword Args:
        - silent (bool, True): Whether to log logging behavior by printing to stderr
    """
    global _initialized_flag # pylint: disable=global-statement
    if _initialized_flag and not silent:
        print("[LOGGING] Disabling logging", file=sys.stderr)
    _initialized_flag = False
    # remove all handlers we might have added (via initLogging on builtin or file config)
    for logger_name in logging.root.manager.loggerDict:
        if not silent:
            print(f'[LOGGING] Resetting {logger_name} log level and handlers')
        logger = logging.getLogger(logger_name)
        logger.setLevel(logging.NOTSET)
        for handler in logger.handlers[:]:
            logger.removeHandler(handler)
    for handler in logging.root.handlers[:]:
        logging.root.removeHandler(handler)
    # Python default log level is WARNING
    logging.root.setLevel(logging.WARNING)



1			"""
2			Logging setup
3
4			By default: Log with lastResort logger, usually STDERR.
5
6			Logging can be overridden either programmatically in code using the library or by creating one or more of
7
8			- /etc/ocrd_logging.py
9			- $HOME/ocrd_logging.py
10			- $PWD/ocrd_logging.py
11
12			These files will be executed in the context of ocrd/ocrd_logging.py, with `logging` global set.
13
14			Changes as of 2023-08-20:
15
16			- Try to be less intrusive with OCR-D specific logging conventions to
17			make it easier and less surprising to define logging behavior when
18			using OCR-D/core as a library
19			- Change setOverrideLogLevel to only override the log level of the ``ocrd``
20			logger and its descendants
21			- initLogging will set exactly one handler, for the root logger or for the
22			``ocrd`` logger.
23			- Child loggers should propagate to the ancestor logging (default
24			behavior of the logging library - no more PropagationShyLogger)
25			- disableLogging only removes any handlers from the ``ocrd`` logger
26			"""
27			# pylint: disable=no-member
28
29			from __future__ import absolute_import
30
31			from traceback import format_stack
32
33			import logging
34			import logging.config
35			from pathlib import Path
36			import sys
37
38			from .constants import LOG_FORMAT, LOG_TIMEFMT
39			from .config import config
40
41
42			__all__ = [
43			'disableLogging',
44			'getLevelName',
45			'getLogger',
46			'initLogging',
47			'logging',
48			'setOverrideLogLevel',
49			]
50
51			LOGGING_DEFAULTS = {
52			'': logging.WARNING,
53			'ocrd': logging.INFO,
54			'ocrd_network': logging.INFO,
55			# 'ocrd.resolver': logging.INFO,
56			# 'ocrd.resolver.download_to_directory': logging.INFO,
57			# 'ocrd.resolver.add_files_to_mets': logging.INFO,
58			# To cut back on the `Self-intersection at or near point` INFO messages
59			'shapely.geos': logging.ERROR,
60			'tensorflow': logging.ERROR,
61			'PIL': logging.INFO,
62			'paramiko.transport': logging.INFO,
63			'uvicorn.access': logging.DEBUG,
64			'uvicorn.error': logging.DEBUG,
65			'uvicorn': logging.INFO,
66			'multipart': logging.INFO,
67			}
68
69			_initialized_flag = False
70
71			_ocrdLevel2pythonLevel = {
72			'TRACE': 'DEBUG',
73			'OFF': 'CRITICAL',
74			'FATAL': 'ERROR',
75			}
76
77			def tf_disable_interactive_logs():
78			try:
79			from os import environ
80			# This env variable must be set before importing from Keras
81			environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
82			from tensorflow.keras.utils import disable_interactive_logging
83			# Enabled interactive logging throws an exception
84			# due to a call of sys.stdout.flush()
85			disable_interactive_logging()
86			except ImportError:
87			# Nothing should be handled here if TF is not available
88			pass
89
90			def getLevelName(lvl):
91			"""
92			Get (string) python logging level for (string) spec-defined log level name.
93			"""
94			lvl = _ocrdLevel2pythonLevel.get(lvl, lvl)
95			return logging.getLevelName(lvl)
96
97			def getLogger(args, *kwargs):
98			"""
99			Wrapper around ``logging.getLogger`` that calls :py:func:`initLogging` if
100			that wasn't explicitly called before.
101			"""
102			logger = logging.getLogger(args, *kwargs)
103			return logger
104
105			def setOverrideLogLevel(lvl, silent=not config.OCRD_LOGGING_DEBUG):
106			"""
107			Override the output log level of the handlers attached to the ``ocrd`` logger.
108
109			Args:
110			lvl (string): Log level name.
111			silent (boolean): Whether to log the override call
112			"""
113			if lvl is not None:
114			lvl = getLevelName(lvl)
115			if not _initialized_flag:
116			initLogging(silent=silent)
117			# affect all configured loggers
118			for logger_name in logging.root.manager.loggerDict:
119			if not silent:
120			print(f'[LOGGING] Overriding {logger_name} log level to {lvl}', file=sys.stderr)
121			logging.getLogger(logger_name).setLevel(lvl)
122
123			def get_logging_config_files():
124			"""
125			Return a list of all ``ocrd_logging.conf`` files found in CWD, HOME or /etc.
126			"""
127			CONFIG_PATHS = [
128			Path.cwd(),
129			Path.home(),
130			Path('/etc'),
131			]
132			return [f for f \
133			in [p / 'ocrd_logging.conf' for p in CONFIG_PATHS] \
134			if f.exists()]
135
136			def initLogging(builtin_only=False, force_reinit=False, silent=not config.OCRD_LOGGING_DEBUG):
137			"""
138			Reset ``ocrd`` logger, read logging configuration if exists, otherwise use basicConfig
139
140			initLogging is to be called by OCR-D/core once, i.e.
141			- for the ``ocrd`` CLI
142			- for the processor wrapper methods
143
144			Other processes that use OCR-D/core as a library can, but do not have to, use this functionality.
145
146			Keyword Args:
147			- builtin_only (bool, False): Whether to search for logging configuration
148			on-disk (``False``) or only use the
149			hard-coded config (``True``). For testing
150			- force_reinit (bool, False): Whether to ignore the module-level
151			``_initialized_flag``. For testing only.
152			- silent (bool, True): Whether to log logging behavior by printing to stderr
153			"""
154			global _initialized_flag
155			if _initialized_flag:
156			if force_reinit:
157			disableLogging(silent=silent)
158			else:
159			return
160
161			config_file = None
162			if not builtin_only:
163			config_file = get_logging_config_files()
164			if config_file:
165			if len(config_file) > 1 and not silent:
166			print(f"[LOGGING] Multiple logging configuration files found at {config_file}, using first one", file=sys.stderr)
167			config_file = config_file[0]
168			if not silent:
169			print(f"[LOGGING] Picked up logging config at {config_file}", file=sys.stderr)
170			logging.config.fileConfig(config_file)
171			else:
172			if not silent:
173			print("[LOGGING] Initializing logging with built-in defaults", file=sys.stderr)
174			# Default logging config
175			ocrd_handler = logging.StreamHandler(stream=sys.stderr)
176			ocrd_handler.setFormatter(logging.Formatter(fmt=LOG_FORMAT, datefmt=LOG_TIMEFMT))
177			ocrd_handler.setLevel(logging.DEBUG)
178			root_logger = logging.getLogger('')
179			root_logger.addHandler(ocrd_handler)
180			for logger_name, logger_level in LOGGING_DEFAULTS.items():
181			logging.getLogger(logger_name).setLevel(logger_level)
182			_initialized_flag = True
183
184			def disableLogging(silent=not config.OCRD_LOGGING_DEBUG):
185			"""
186			Disables all logging of the ``ocrd`` logger and descendants
187
188			Keyword Args:
189			- silent (bool, True): Whether to log logging behavior by printing to stderr
190			"""
191			global _initialized_flag # pylint: disable=global-statement
192			if _initialized_flag and not silent:
193			print("[LOGGING] Disabling logging", file=sys.stderr)
194			_initialized_flag = False
195			# remove all handlers we might have added (via initLogging on builtin or file config)
196			for logger_name in logging.root.manager.loggerDict:
197			if not silent:
198			print(f'[LOGGING] Resetting {logger_name} log level and handlers')
199			logger = logging.getLogger(logger_name)
200			logger.setLevel(logging.NOTSET)
201			for handler in logger.handlers[:]:
202			logger.removeHandler(handler)
203			for handler in logging.root.handlers[:]:
204			logging.root.removeHandler(handler)
205			# Python default log level is WARNING
206			logging.root.setLevel(logging.WARNING)
207
208

OCR-D / core

Push — master ( 6d8539...583fdd )

ocrd_utils.logging.initLogging() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like