def set_rich_logger(config_logger, verbosity):
"""Will set the RichHandler of the logger.
Parameter
----------
config_logger :class:
Config object of the logger.
"""
theme = _parse_theme(config_logger)
global console
console = Console(theme=theme)
# These keywords Are Highlighted specially.
RichHandler.KEYWORDS = [
"Played",
"animations",
"scene",
"Reading",
"Writing",
"script",
"arguments",
"Invalid",
"Aborting",
"module",
"File",
"Rendering",
"Rendered",
]
rich_handler = RichHandler(
console=console, show_time=config_logger.getboolean("log_timestamps"))
global logger
rich_handler.setLevel(verbosity)
logger.addHandler(rich_handler)
def initalise_logger(
filename,
print_level="INFO",
file_level="DEBUG",
):
"""
Sets up (possibly multiprocessing aware) logging.
:param filename: Where to save the logs to
:param print_level: What level of logging to print to console.
Default: 'INFO'
:param file_level: What level of logging to print to file.
Default: 'DEBUG'
"""
logger = logging.getLogger()
logger.setLevel(getattr(logging, file_level))
formatter = logging.Formatter(
"%(asctime)s - %(levelname)s"
" - %(processName)s %(filename)s:%(lineno)s"
" - %(message)s"
)
formatter.datefmt = "%Y-%m-%d %H:%M:%S %p"
if filename is not None:
fh = logging.FileHandler(filename)
fh.setLevel(getattr(logging, file_level))
fh.setFormatter(formatter)
logger.addHandler(fh)
ch = RichHandler()
ch.setLevel(getattr(logging, print_level))
ch.setFormatter(formatter)
logger.addHandler(ch)
return logger
def _setup_logging(
verbosity: int,
log_file: Optional[str] = None,
):
default_log_format = (
"%(asctime)s [%(levelname)s](%(name)s:%(funcName)s:%(lineno)d): %(message)s"
)
logger = logging.getLogger("") # get root logger
logger.setLevel(logging.DEBUG)
default_formatter = logging.Formatter(fmt=default_log_format, datefmt="%X")
if log_file:
log_file_path = Path(log_file).resolve()
if not log_file_path.parent.exists():
log_file_path.parent.mkdir(parents=True, exist_ok=True)
file_handler = logging.FileHandler(log_file)
file_handler.setFormatter(default_formatter)
logger.addHandler(file_handler)
if verbosity < 0:
logger.addHandler(logging.NullHandler())
else:
level = logging.WARNING
if verbosity == 1:
level = logging.INFO
if verbosity >= 2:
level = logging.DEBUG
console_handler = RichHandler(rich_tracebacks=True,
log_time_format="[%X]",
console=console)
console_handler.setLevel(level)
console_handler.setFormatter(logging.Formatter("%(message)s"))
logger.addHandler(console_handler)
def configure_logging(config):
"""Configure the root logger based on user config."""
rootlogger = logging.getLogger()
while rootlogger.handlers:
rootlogger.handlers.pop()
try:
if config["path"]:
logfile_path = os.path.expanduser(config["path"])
else:
logfile_path = config["path"]
except KeyError:
logfile_path = DEFAULT_LOG_FILENAME
if logfile_path:
logdir = os.path.dirname(os.path.realpath(logfile_path))
if not os.path.isdir(logdir):
os.makedirs(logdir)
log_level = get_logging_level(config.get("level", "info"))
rootlogger.setLevel(log_level)
formatter_str = set_formatter_string(config)
formatter = logging.Formatter(formatter_str)
handler = None
if config.get("rich") is not False:
handler = RichHandler(
rich_tracebacks=True,
show_time=config.get("timestamp", True),
show_path=config.get("extended", True),
)
if logfile_path:
file_handler = RotatingFileHandler(
logfile_path, maxBytes=config.get("file-size", 50e6)
)
file_handler.setLevel(log_level)
file_handler.setFormatter(formatter)
rootlogger.addHandler(file_handler)
if config.get("console"):
handler = logging.StreamHandler()
handler.setFormatter(formatter)
# If we still don't have the handler, we are assuming that
# the user wants to switch off logging, let's log only
# Critical errors
if not handler:
handler = logging.StreamHandler()
handler.setFormatter(formatter)
log_level = get_logging_level("critical")
if config.get("filter") and handler:
handler.addFilter(ParsingFilter(config, config["filter"]))
if handler:
handler.setLevel(log_level)
rootlogger.addHandler(handler)
_LOGGER.info("=" * 40)
_LOGGER.info(_("Started opsdroid %s."), __version__)
def add_log_file_handler(path: str, logger_name: Optional[str] = None) -> None:
if os.path.isdir(path):
raise AssertionError
log_dir = os.path.dirname(path)
if not (os.path.isdir(log_dir) or log_dir == ""):
raise AssertionError
fh = RichHandler(console=Console(file=open(path, mode="w+")), markup=True)
fh.setLevel(logging.INFO)
logging.getLogger(logger_name).addHandler(fh)
logging.getLogger(logger_name).info(f"[green]Log to[/]: '{path}'")
def cli(
ctx,
config,
log_path,
file_log_level,
verbose,
debug,
debug_filter,
quiet,
pynetdicom_log_level,
):
"""High level DICOM file and network operations"""
if quiet:
if verbose or debug:
cli_error("Can't mix --quiet with --verbose/--debug")
# Create Rich Console outputing to stderr for logging / progress bars
rich_con = Console(stderr=True)
# Setup logging
LOG_FORMAT = "%(asctime)s %(levelname)s %(threadName)s %(name)s %(message)s"
def_formatter = logging.Formatter(LOG_FORMAT)
root_logger = logging.getLogger("")
root_logger.setLevel(logging.DEBUG)
pynetdicom_logger = logging.getLogger("pynetdicom")
pynetdicom_logger.setLevel(getattr(logging, pynetdicom_log_level))
stream_formatter = logging.Formatter("%(threadName)s %(name)s %(message)s")
stream_handler = RichHandler(console=rich_con, enable_link_path=False)
stream_handler.setFormatter(stream_formatter)
# logging.getLogger("asyncio").setLevel(logging.DEBUG)
if debug:
stream_handler.setLevel(logging.DEBUG)
elif verbose:
stream_handler.setLevel(logging.INFO)
elif quiet:
stream_handler.setLevel(logging.ERROR)
else:
stream_handler.setLevel(logging.WARN)
root_logger.addHandler(stream_handler)
handlers = [stream_handler]
if log_path is not None:
file_handler = logging.FileHandler(log_path)
file_handler.setFormatter(def_formatter)
file_handler.setLevel(getattr(logging, file_log_level))
root_logger.addHandler(file_handler)
handlers.append(file_handler)
if len(debug_filter) > 0:
for filter_name in debug_filter:
if filter_name not in debug_filters:
cli_error("Unknown debug filter: %s" % filter_name)
for handler in handlers:
handler.addFilter(debug_filters[filter_name])
# Create global param dict for subcommands to use
ctx.obj = {}
ctx.obj["config_path"] = config
ctx.obj["config"] = DcmConfig(config, create_if_missing=True)
ctx.obj["rich_con"] = rich_con
def getlogger(logfile_path=None):
if logfile_path is None:
log_folder = config().get('logging', {}).get('log_folder')
log_file = config().get('logging', {}).get('build_log_file')
logfile_path = os.path.join(log_folder, log_file)
fh = logging.FileHandler(logfile_path)
fh.setFormatter(
logging.Formatter('[%(asctime)s] %(levelname)s %(message)s'))
fh.setLevel(level="NOTSET")
rh = RichHandler(show_time=False, show_level=False, show_path=False)
rh.setLevel(level="ERROR")
#logging.basicConfig(level="NOTSET", format='%(message)s')
log = logging.getLogger()
log.addHandler(fh)
#log.addHandler(rh)
return log
def make_logger(parser, verbosity):
"""Make the manim logger and the console."""
# Throughout the codebase, use Console.print() instead of print()
theme = parse_theme(parser)
console = Console(theme=theme)
# set the rich handler
RichHandler.KEYWORDS = HIGHLIGHTED_KEYWORDS
rich_handler = RichHandler(
console=console, show_time=parser.getboolean("log_timestamps")
)
rich_handler.setLevel(verbosity)
# finally, the logger
logger = logging.getLogger("manim")
logger.addHandler(rich_handler)
return logger, console
def add_log_file_handler(path: str, logger_name: Optional[str] = None) -> None:
"""Adds log file handler to logger.
By defaults, adds the handler to the root logger.
Arguments:
path {str} -- path to output log file
Keyword Arguments:
logger_name {str} -- logger name (default: {""})
"""
assert not os.path.isdir(path)
log_dir = os.path.dirname(path)
assert os.path.isdir(log_dir) or log_dir == ""
fh = RichHandler(console=Console(file=open(path, mode="w+")), markup=True)
fh.setLevel(logging.INFO)
logging.getLogger(logger_name).addHandler(fh)
logging.info(f"[green]Log to[/]: '{path}'")
def setup(self):
if self.has_run_before or current_process().name != "MainProcess":
# print("Has been setup before", current_process())
return None
# print("Setting up logs", current_process())
# if running from CLI:
if Path("pyproject.toml").is_file():
log_dir = "./logs"
# if running from iPython / VS Code
elif Path("cli.py").is_file():
log_dir = "../logs"
else:
log_dir = "./logs"
# raise AssertionError(f"Could not figure out logging dir")
Path(log_dir).mkdir(parents=True, exist_ok=True)
filename = f"{log_dir}/log--{self.start_time}.txt"
# Create handlers
# stream_handler = logging.StreamHandler()
stream_handler = RichHandler(rich_tracebacks=True, console=console)
file_handler = logging.FileHandler(filename)
# Configure level and formatter and add it to handlers
stream_handler.setLevel(logging.WARNING)
file_handler.setLevel(
logging.DEBUG) # error and above is logged to a file
stream_handler.setFormatter(logging.Formatter("%(message)s"))
file_handler.setFormatter(
logging.Formatter(
"%(asctime)s | %(name)s | %(levelname)s | %(message)s"))
# Add handlers to the logger
logger = logging.getLogger(self.name)
logger.addHandler(stream_handler)
logger.addHandler(file_handler)
logger.setLevel(logging.DEBUG)
self.has_run_before = True
def setup():
"""Setup logging based on the configuration in ``vaex.settings``
This function is automatically called when importing vaex. If settings are changed, call :func:`reset` and this function again
to re-apply the settings.
"""
global log_handler
if vaex.settings.main.logging.setup:
logger.setLevel(logging.DEBUG)
# create console handler and accept all loglevels
if vaex.settings.main.logging.rich:
from rich.logging import RichHandler
log_handler = RichHandler()
else:
log_handler = logging.StreamHandler()
# create formatter
formatter = logging.Formatter('%(levelname)s:%(threadName)s:%(name)s:%(message)s')
# add formatter to console handler
log_handler.setFormatter(formatter)
log_handler.setLevel(logging.DEBUG)
# add console handler to logger
logger.addHandler(log_handler)
logging.getLogger("vaex").setLevel(logging.ERROR) # default to higest level
_set_log_level(vaex.settings.main.logging.error, logging.ERROR)
_set_log_level(vaex.settings.main.logging.warning, logging.WARNING)
_set_log_level(vaex.settings.main.logging.info, logging.INFO)
_set_log_level(vaex.settings.main.logging.debug, logging.DEBUG)
# VAEX_DEBUG behaves similar to VAEX_LOGGING_DEBUG, but has more effect
DEBUG_MODE = os.environ.get('VAEX_DEBUG', '')
if DEBUG_MODE:
_set_log_level(DEBUG_MODE, logging.DEBUG)
def logger(name: str) -> Logger:
_log = getLogger(name)
_log.console = Console(theme=theme)
_hndl_console = RichHandler(markup=True,
show_time=False,
show_level=False,
show_path=False,
rich_tracebacks=True,
tracebacks_show_locals=True,
console=_log.console)
if cfg.console.has('format'):
_hndl_console.setFormatter(Formatter(cfg.console.format))
if cfg.console.has('level'):
_hndl_console.setLevel(cfg.console.level)
_log.addHandler(_hndl_console)
_hndl_file = TimedRotatingFileHandler(
filename=f'{cfg.file.path}/{name}.log',
when=cfg.file.when,
interval=cfg.file.interval)
if cfg.file.has('format'):
_hndl_file.setFormatter(NoStyleFormatter(cfg.file.format))
if cfg.file.has('level'):
_hndl_file.setLevel(cfg.file.level)
_log.addHandler(_hndl_file)
_hndl_net = SocketHandler(host=cfg.net.get('host', 'localhost'),
port=cfg.net.get('port', 8765))
if cfg.net.has('format'):
_hndl_net.setFormatter(NoStyleFormatter(cfg.net.format))
if cfg.net.has('level'):
_hndl_net.setLevel(cfg.net.level)
_log.addHandler(_hndl_net)
_log.setLevel(cfg.logger.get(name, cfg.logger.__default__))
def __response(r,
ok,
error,
force={
'ok': False,
'error': False,
'exit': True
}):
_stdout = r.stdout.strip()
_stderr = r.stderr.strip()
if r.ok:
if _stderr and not force.get('ok', False):
for l in _stderr.splitlines():
_log.warning(l)
elif _stdout and not force.get('ok', False):
for l in _stdout.splitlines():
_log.info(l)
else:
_log.info(ok)
else:
if _stderr and not force.get('error', False):
for l in _stderr.strip().splitlines():
_log.error(l)
elif _stdout and not force.get('error', False):
for l in _stdout.strip().splitlines():
_log.error(l)
else:
_log.error(error)
_log.warning(
f':{icon.exit}: [warn]Exit[/warn] :{icon.code}: code: [hl]{r.exited}[/hl]'
)
if force.get('exit', True):
exit(r.exited)
else:
return r.exited
_log.response = __response
return _log
import logging
from rich.logging import RichHandler
# set up logging to file
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
datefmt='%d-%m-%Y %H:%M',
filename='cov19tdm.log',
filemode='w')
# Define a handler which writes INFO messages or higher
console = RichHandler()
console.setLevel(logging.INFO)
# Set a format which is simpler for console use
formatter = logging.Formatter(
'[%(asctime)s] %(name)-12s: %(levelname)-6s: %(message)s',
datefmt='%H:%M',
)
# Tell the handler to use this format
console.setFormatter(formatter)
# Add the handler to the root logger
logging.getLogger('').addHandler(console)
# Disable messages from external libraries lower the warnings
logging.getLogger("matplotlib").setLevel(logging.WARNING)
# create logger instance
logger = logging.getLogger(__name__)
# create dt for logging
dt = datetime.strftime(datetime.now(), "%Y%m%d-%H-%M-%S")
# handlers
shell_handler = RichHandler()
path = os.path.abspath(os.path.dirname(__file__))
file_handler = logging.FileHandler(f"{path}/logs/{dt}.log")
# formatters
shell_formatter = logging.Formatter('%(message)s')
file_formatter = logging.Formatter(
'%(levelname)s %(asctime)s [%(filename)s:%(funcName)s:%(lineno)d] %(message)s'
)
# set formatters
shell_handler.setFormatter(shell_formatter)
file_handler.setFormatter(file_formatter)
# set levels
logger.setLevel(logging.DEBUG)
shell_handler.setLevel(logging.DEBUG)
file_handler.setLevel(logging.DEBUG)
# add handlers to logger
logger.addHandler(shell_handler)
logger.addHandler(file_handler)
from rich.logging import RichHandler
from typing import Callable
from functools import wraps
# logging paths
LOGS_DIR = Path(__file__).parent.parent / "data/logs"
LOGS_DIR.mkdir(parents=True, exist_ok=True)
# setting for stdout and file logging
logger = logging.getLogger(__name__)
stdout_handler = RichHandler()
file_handler = logging.FileHandler(f"{LOGS_DIR}/debug.log")
# logging levels
logger.setLevel(logging.DEBUG)
stdout_handler.setLevel(logging.INFO)
file_handler.setLevel(logging.DEBUG)
# the formatters look
fmt_stdout = "%(message)s"
fmt_file = (
"[%(levelname)s] %(asctime)s | %(filename)s:%(funcName)s:%(lineno)d | %(message)s"
)
stdout_formatter = logging.Formatter(fmt_stdout)
file_formatter = logging.Formatter(fmt_file)
# set formatters
stdout_handler.setFormatter(stdout_formatter)
file_handler.setFormatter(file_formatter)
from rich.traceback import install
# global console and log object
console = Console()
log = logging.getLogger(__name__)
install()
# handler for logging in stdout and file
shellLogHandler = RichHandler()
log_file = open("/tmp/mate_debug.log", "a")
fileLogHandler = RichHandler(console=Console(file=log_file),
rich_tracebacks=True,
tracebacks_show_locals=True)
log.setLevel(logging.DEBUG)
shellLogHandler.setLevel(logging.INFO)
fileLogHandler.setLevel(logging.DEBUG)
# the formatter determines what our logs will look like
fmt_shell = "<%(funcName)s> %(message)s"
fmt_file = fmt_shell
shell_formatter = logging.Formatter(fmt_shell)
file_formatter = logging.Formatter(fmt_file)
# here we hook everything together
shellLogHandler.setFormatter(shell_formatter)
fileLogHandler.setFormatter(file_formatter)
log.addHandler(shellLogHandler)
log.addHandler(fileLogHandler)
# init log file
log_folder = "./logs"
check(log_folder)
log_file = os.path.join(log_folder, datetime.now().strftime("%Y%m%d_T%H%M%S.log"))
clear(log_file)
# init loggers
logger = logging.getLogger(__name__)
shell_handler = RichHandler()
file_handler = logging.FileHandler(log_file)
# set logging levels
logger.setLevel(logging.DEBUG)
shell_handler.setLevel(logging.INFO)
file_handler.setLevel(logging.DEBUG)
# set formats and formatters
fmt_shell = "%(message)s"
fmt_file = "%(levelname)s %(asctime)s [%(threadName)s] [%(filename)s:%(funcName)s:%(lineno)d] %(message)s"
shell_formatter = logging.Formatter(fmt_shell)
file_formatter = logging.Formatter(fmt_file)
shell_handler.setFormatter(shell_formatter)
file_handler.setFormatter(file_formatter)
# connect handlers to logger
logger.addHandler(shell_handler)
logger.addHandler(file_handler)
if not os.path.isfile(BotLogger.log_file):
os.makedirs(BotLogger.base_dir, exist_ok=True)
logging.setLoggerClass(BotLogger)
logging.addLevelName(15, "VERBOSE")
logging.addLevelName(25, "SUCCESS")
# create file handler which logs even debug messages
file_handler = logging.FileHandler(BotLogger.log_file)
file_handler.setLevel(logging.DEBUG)
# create formatter and add it to the handlers
formatter = logging.Formatter('%(asctime)s - [%(levelname)s] %(message)s')
file_handler.setFormatter(formatter)
rich_handler = RichHandler(rich_tracebacks=True,
show_time=False,
markup=True,
show_level=False,
show_path=False)
rich_handler.setLevel(logging.INFO)
logging.basicConfig(
format="%(message)s",
handlers=[rich_handler, file_handler]
)
logger: BotLogger = logging.getLogger(BotLogger.appname)
logger.setLevel(logging.DEBUG)
def get_console_handler(level=logging.INFO):
console_handler = RichHandler(console=console, markup=True)
console_handler.setFormatter(FORMATER)
console_handler.setLevel(level)
return console_handler
console.print("⚠️ Potential Differences detected:", style="bold yellow")
for diff in differences:
table.add_row(diff.name, diff.current, diff.latest)
console.print(table)
if __name__ == "__main__":
parser = argparse.ArgumentParser(
prog="poormans_dependabot", description="Sort of dependabot-like local utility"
)
parser.add_argument("--verbose", action="store_true", help="Show verbose log info")
args = parser.parse_args()
if args.verbose:
LOG_LEVEL = logging.INFO
else:
LOG_LEVEL = logging.WARNING
logger = logging.getLogger()
logger.setLevel(LOG_LEVEL)
ch = RichHandler()
ch.setLevel(LOG_LEVEL)
formatter = logging.Formatter("%(asctime)s - %(message)s")
ch.setFormatter(formatter)
logger.addHandler(ch)
asyncio.run(main=main())
