def initialize_logging(self, verbosity):
"""
Initialize the logging subsystem.
"""
# Create a logger instance.
self.logger = verboselogs.VerboseLogger('vim-plugin-manager')
self.set_log_level(logging.DEBUG)
# Add a handler for logging to a file.
log_file = os.path.expanduser('~/.vim-plugin-manager.log')
log_exists = os.path.isfile(log_file)
file_handler = coloredlogs.ColoredStreamHandler(open(log_file, 'a'),
show_name=True,
isatty=False)
self.logger.addHandler(file_handler)
# The log file is always verbose.
file_handler.setLevel(logging.DEBUG)
# Add a delimiter to the log file to delimit the messages of the
# current run from those of previous runs.
if log_exists:
self.logger.info("-" * 40)
# Add a logging handler for console output, after logging the delimiter
# to the log file (the delimiter is useless on the console).
console_handler = coloredlogs.ColoredStreamHandler(show_name=True)
self.logger.addHandler(console_handler)
# Set the verbosity of the console output.
if verbosity >= 2:
self.set_log_level(logging.DEBUG)
self.logger.debug("Enabling debugging output.")
elif verbosity == 1:
self.set_log_level(logging.VERBOSE)
self.logger.verbose("Enabling verbose output.")
else:
self.set_log_level(logging.INFO)
# Mention the log file on the console after setting the verbosity?
self.logger.debug("Logging messages to %s.", log_file)
def setup_logger(name):
"""Set up stream and file handlers."""
root = logging.getLogger(name)
root.setLevel(logging.DEBUG)
root.propagate = False
stream_handler = coloredlogs.ColoredStreamHandler(
stream=sys.stdout,
show_name=False,
show_hostname=False,
level=logging.DEBUG)
root.addHandler(stream_handler)
return root
# External dependency, install with:
# pip install coloredlogs
import coloredlogs
# External dependency, bundled because it's not on PyPi.
# import libs.soupselect as soupselect
# Sensible defaults (you probably shouldn't change these).
TEXT_WIDTH = 79
SHIFT_WIDTH = 2
# Initialize the logging subsystem.
logger = logging.getLogger('html2vimdoc')
logger.setLevel(logging.INFO)
logger.addHandler(coloredlogs.ColoredStreamHandler(show_name=True))
# Mapping of HTML element names to custom Node types.
name_to_type_mapping = {}
def main():
"""
Command line interface for html2vimdoc.
"""
filename, title, url, arguments, preview, markdown_extensions = parse_args(
sys.argv[1:])
filename, url, text = get_input(filename, url, arguments,
markdown_extensions)
vimdoc = html2vimdoc(text, title=title, filename=filename, url=url)
output = vimdoc.encode('utf-8')
def create_logger(debug=False, logfile=None, replace_stdout=True):
"""
Create the logger and attach the handlers.
:param debug: the level of the messages that we should log
:type debug: bool
:param logfile: the file name of where we should to save the logs
:type logfile: str
:return: the new logger with the attached handlers.
:rtype: logging.Logger
"""
# TODO: get severity from command line args
if debug:
level = logging.DEBUG
else:
level = logging.WARNING
# Create logger and formatter
logger = logging.getLogger(name='leap')
logger.setLevel(level)
formatter = logging.Formatter(LOG_FORMAT)
# Console handler
try:
import coloredlogs
console = coloredlogs.ColoredStreamHandler(level=level)
except ImportError:
console = logging.StreamHandler()
console.setLevel(level)
console.setFormatter(formatter)
using_coloredlog = False
else:
using_coloredlog = True
if using_coloredlog:
replace_stdout = False
silencer = SelectiveSilencerFilter()
console.addFilter(silencer)
logger.addHandler(console)
logger.debug('Console handler plugged!')
# LEAP custom handler
leap_handler = LeapLogHandler()
leap_handler.setLevel(level)
leap_handler.addFilter(silencer)
logger.addHandler(leap_handler)
logger.debug('Leap handler plugged!')
# File handler
if logfile is not None:
logger.debug('Setting logfile to %s ', logfile)
fileh = logging.FileHandler(logfile)
fileh.setLevel(logging.DEBUG)
fileh.setFormatter(formatter)
fileh.addFilter(silencer)
logger.addHandler(fileh)
logger.debug('File handler plugged!')
if replace_stdout:
replace_stdout_stderr_with_logging(logger)
return logger
#!/usr/bin/env python
#-*- coding: utf-8 -*-
# Configure your logger.
import logging, coloredlogs
logger = logging.getLogger('your-module')
logger.addHandler(coloredlogs.ColoredStreamHandler())
# Some examples.
logger.setLevel(logging.DEBUG)
logger.debug("this is a debugging message")
logger.info("this is an informational message")
logger.warn("this is a warning message")
logger.error("this is an error message")
logger.fatal("this is a fatal message")
logger.critical("this is a critical message")