6981974383

Committed 24 Nov 2023 02:31PM UTC coverage: 88.592%. First build

Build # 6981974383

Build Type

push

github

Committed by

set-soft

Commit Message

Forced test

Run Details

3021 of 3410 relevant lines covered (88.59%)

3.77 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.42

/kiauto/log.py

# -*- coding: utf-8 -*-
# Copyright (c) 2020 Salvador E. Tropea
# Copyright (c) 2020 Instituto Nacional de Tecnologïa Industrial
# License: Apache 2.0
# Project: KiAuto (formerly kicad-automation-scripts)
# Adapted from: https://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output
"""
Log module

Handles logging initialization and formating.
"""
import sys
import logging

# Default domain, base name for the tool
domain = 'kiauto'
verbose_level = 2
do_separate = False


def get_logger(name=None):
    """Get a module for a submodule or the root logger if no name is provided"""
    return logging.getLogger(domain+'.'+name) if name else logging.getLogger(domain)


def set_domain(name):
    """Set the base name for the tool"""
    global domain
    domain = name


def set_level(logger, level):
    global verbose_level
    verbose_level = level
    if level >= 2:
        log_level = logging.DEBUG
    elif level == 1:
        log_level = logging.INFO
    else:
        log_level = logging.WARNING
    logger.setLevel(log_level)


def get_level():
    return verbose_level


class FilterOnlyInfo(object):
    def filter(self, record):
        return record.levelno == logging.INFO


class FilterNoInfo(object):
    def filter(self, record):
        return record.levelno != logging.INFO


def init(separate_info=False):
    """Initialize the logging feature using a custom format and the specified verbosity level"""
    global do_separate
    do_separate = separate_info
    logger = get_logger()
    if not separate_info:
        ch = logging.StreamHandler()
        ch.setFormatter(CustomFormatter())
        logger.addHandler(ch)
    else:
        # Handler for all but info.
        # Outputs to stderr
        ch = logging.StreamHandler()
        ch.addFilter(FilterNoInfo())
        ch.setFormatter(CustomFormatter(sys.stderr))
        logger.addHandler(ch)
        # Handler for info.
        # Outputs to stdout
        ch = logging.StreamHandler(sys.stdout)
        ch.addFilter(FilterOnlyInfo())
        ch.setFormatter(CustomFormatter(sys.stdout, no_prefix=True))
        logger.addHandler(ch)
    return logger


class CustomFormatter(logging.Formatter):
    """Logging Formatter to add colors"""

    def __init__(self, stream=None, no_prefix=False):
        super(logging.Formatter, self).__init__()
        if sys.stderr.isatty():
            grey = "\x1b[38;21m"
            yellow = "\x1b[93;1m"
            red = "\x1b[91;1m"
            bold_red = "\x1b[91;21m"
            cyan = "\x1b[36;1m"
            reset = "\x1b[0m"
        else:
            grey = ""
            yellow = ""
            red = ""
            bold_red = ""
            cyan = ""
            reset = ""
        # format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
        format = "%(levelname)s:%(message)s (%(name)s - %(filename)s:%(lineno)d)"
        format_simple = "%(message)s" if no_prefix else "%(levelname)s:%(message)s"

        self.FORMATS = {
            logging.DEBUG: cyan + format + reset,
            logging.INFO: grey + format_simple + reset,
            logging.WARNING: yellow + format + reset,
            logging.ERROR: red + format + reset,
            logging.CRITICAL: bold_red + format + reset
        }

    def format(self, record):
        log_fmt = self.FORMATS.get(record.levelno)
        formatter = logging.Formatter(log_fmt)
        return formatter.format(record)


def flush_info():
    if verbose_level < 1:
        return
    f = sys.stdout if do_separate else sys.stderr
    f.write("\n")
    f.flush()


def info_progress(msg):
    if verbose_level < 1:
        return
    f = sys.stdout if do_separate else sys.stderr
    f.write('\r'+msg)
    f.flush()

1	# -- coding: utf-8 --
2	# Copyright (c) 2020 Salvador E. Tropea
3	# Copyright (c) 2020 Instituto Nacional de Tecnologïa Industrial
4	# License: Apache 2.0
5	# Project: KiAuto (formerly kicad-automation-scripts)
6	# Adapted from: https://stackoverflow.com/questions/384076/how-can-i-color-python-logging-output
7	"""	6✔
8	Log module
9
10	Handles logging initialization and formating.
11	"""
12	import sys	6✔
13	import logging	6✔
14
15	# Default domain, base name for the tool
16	domain = 'kiauto'	6✔
17	verbose_level = 2	6✔
18	do_separate = False	6✔
19
20
21	def get_logger(name=None):	6✔
22	"""Get a module for a submodule or the root logger if no name is provided"""
23	return logging.getLogger(domain+'.'+name) if name else logging.getLogger(domain)	6✔
24
25
26	def set_domain(name):	6✔
27	"""Set the base name for the tool"""
28	global domain
29	domain = name	6✔
30
31
32	def set_level(logger, level):	6✔
33	global verbose_level
34	verbose_level = level	6✔
35	if level >= 2:	6✔
36	log_level = logging.DEBUG	6✔
37	elif level == 1:	6✔
38	log_level = logging.INFO	6✔
39	else:
40	log_level = logging.WARNING	6✔
41	logger.setLevel(log_level)	6✔
42
43
44	def get_level():	6✔
45	return verbose_level	6✔
46
47
48	class FilterOnlyInfo(object):	6✔
49	def filter(self, record):	6✔
50	return record.levelno == logging.INFO	×
51
52
53	class FilterNoInfo(object):	6✔
54	def filter(self, record):	6✔
55	return record.levelno != logging.INFO	×
56
57
58	def init(separate_info=False):	6✔
59	"""Initialize the logging feature using a custom format and the specified verbosity level"""
60	global do_separate
61	do_separate = separate_info	6✔
62	logger = get_logger()	6✔
63	if not separate_info:	6✔
64	ch = logging.StreamHandler()	6✔
65	ch.setFormatter(CustomFormatter())	6✔
66	logger.addHandler(ch)	6✔
67	else:
68	# Handler for all but info.
69	# Outputs to stderr
70	ch = logging.StreamHandler()	×
71	ch.addFilter(FilterNoInfo())	×
72	ch.setFormatter(CustomFormatter(sys.stderr))	×
73	logger.addHandler(ch)	×
74	# Handler for info.
75	# Outputs to stdout
76	ch = logging.StreamHandler(sys.stdout)	×
77	ch.addFilter(FilterOnlyInfo())	×
78	ch.setFormatter(CustomFormatter(sys.stdout, no_prefix=True))	×
79	logger.addHandler(ch)	×
80	return logger	6✔
81
82
83	class CustomFormatter(logging.Formatter):	6✔
84	"""Logging Formatter to add colors"""
85
86	def __init__(self, stream=None, no_prefix=False):	6✔
87	super(logging.Formatter, self).__init__()	6✔
88	if sys.stderr.isatty():	6✔
89	grey = "\x1b[38;21m"	6✔
90	yellow = "\x1b[93;1m"	6✔
91	red = "\x1b[91;1m"	6✔
92	bold_red = "\x1b[91;21m"	6✔
93	cyan = "\x1b[36;1m"	6✔
94	reset = "\x1b[0m"	6✔
95	else:
96	grey = ""	6✔
97	yellow = ""	6✔
98	red = ""	6✔
99	bold_red = ""	6✔
100	cyan = ""	6✔
101	reset = ""	6✔
102	# format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
103	format = "%(levelname)s:%(message)s (%(name)s - %(filename)s:%(lineno)d)"	6✔
104	format_simple = "%(message)s" if no_prefix else "%(levelname)s:%(message)s"	6✔
105
106	self.FORMATS = {	6✔
107	logging.DEBUG: cyan + format + reset,
108	logging.INFO: grey + format_simple + reset,
109	logging.WARNING: yellow + format + reset,
110	logging.ERROR: red + format + reset,
111	logging.CRITICAL: bold_red + format + reset
112	}
113
114	def format(self, record):	6✔
115	log_fmt = self.FORMATS.get(record.levelno)	6✔
116	formatter = logging.Formatter(log_fmt)	6✔
117	return formatter.format(record)	6✔
118
119
120	def flush_info():	6✔
121	if verbose_level < 1:	3✔
122	return	×
123	f = sys.stdout if do_separate else sys.stderr	3✔
124	f.write("\n")	3✔
125	f.flush()	3✔
126
127
128	def info_progress(msg):	6✔
129	if verbose_level < 1:	3✔
130	return	×
131	f = sys.stdout if do_separate else sys.stderr	3✔
132	f.write('\r'+msg)	3✔
133	f.flush()	3✔

INTI-CMNB / KiAuto / 6981974383

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous