def setup_logging(args): level = logging.DEBUG if args.verbose else logging.INFO # Adding notice level for more important lines that arent warning message_store = MessageStore() message_store.setLevel(logging.WARNING) notice_level = 25 logging.addLevelName(notice_level, "NOTICE") def notice(self, message, *args, **kws): if self.isEnabledFor(notice_level): self._log(notice_level, message, args, **kws) def notice_root(message, *args, **kwargs): logging.log(notice_level, message, *args, **kwargs) logging.Logger.notice = notice logging.notice = notice_root fmt = "[%(levelname)8s |%(filename)21s:%(lineno)3d] %(message)s" if args.verbose else "%(message)s" handlers = [logging.StreamHandler(), message_store] handlers[0].setLevel(level) logging.basicConfig(level=level, format=fmt, handlers=handlers) coloredlogs.install( level=level, fmt=fmt, reconfigure=True, level_styles=coloredlogs.parse_encoded_styles( "debug=8;notice=green;warning=yellow;error=red,bold;critical=red,inverse" ), ) return message_store
def setup_logging(args): levels = [ logging.CRITICAL, logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG ] coloredlogs.install(level=levels[min(len(levels) - 1, args.verbose)], datefmt='%H:%M:%S', level_styles={ 'debug': { 'color': 'green' }, 'info': { 'color': 'cyan' }, 'warning': { 'color': 'yellow', 'bold': True }, 'error': { 'color': 'red' }, 'critical': { 'color': 'red', 'bold': True } }, field_styles=coloredlogs.parse_encoded_styles(''))
def setup_logger(level='INFO'): global logger coloredlogs.install( level=level, logger=logger, fmt='[%(levelname)s] %(message)s', level_styles=coloredlogs.parse_encoded_styles( 'spam=22;debug=28;verbose=34;info=226;notice=220;warning=202;success=118,bold;error=124;critical=background=red' ))
def test_style_parsing(self): """Make sure :func:`~coloredlogs.parse_encoded_styles()` works as intended.""" encoded_styles = 'debug=green;warning=yellow;error=red;critical=red,bold' decoded_styles = parse_encoded_styles(encoded_styles, normalize_key=lambda k: k.upper()) assert sorted(decoded_styles.keys()) == sorted(['debug', 'warning', 'error', 'critical']) assert decoded_styles['debug']['color'] == 'green' assert decoded_styles['warning']['color'] == 'yellow' assert decoded_styles['error']['color'] == 'red' assert decoded_styles['critical']['color'] == 'red' assert decoded_styles['critical']['bold'] is True
def setup_logging(args): levels = [logging.CRITICAL, logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG] coloredlogs.install(level=levels[min(len(levels) - 1, args.verbose)], datefmt='%H:%M:%S', level_styles={ 'debug': {'color': 'green'}, 'info': {'color': 'cyan'}, 'warning': {'color': 'yellow', 'bold': True}, 'error': {'color': 'red'}, 'critical': {'color': 'red', 'bold': True} }, field_styles=coloredlogs.parse_encoded_styles(''))
def level_styles(self) -> Dict[str, Any]: """Return log level styles. If "RUNWAY_LOG_LEVEL_STYLES" exists in the environment, it will be used to update the Runway LOG_LEVEL_STYLES. """ if self.no_color: return {} result = LOG_LEVEL_STYLES.copy() if self.ENV["level_styles"]: result.update( coloredlogs.parse_encoded_styles( # type: ignore self.ENV["level_styles"])) return result
def get_logger(): import logging logger = logging.getLogger(os.path.splitext(os.path.basename(__file__))[0]) coloredlogs.install( level=logging.DEBUG if DEBUG else logging.INFO, logger=logger, fmt="%(name)s %(levelname)s %(message)s", level_styles=parse_encoded_styles( "debug=green;warning=yellow;error=red;critical=red,bold" ), # field_styles=parse_encoded_styles('debug=green;warning=yellow;error=red;critical=red,bold') ) return logger
def configure_logging(verbose=True): level = logging.DEBUG if verbose else logging.INFO fmt = "[%(levelname)8s |%(filename)21s:%(lineno)3d] %(message)s" if verbose else "%(message)s" handlers = [logging.StreamHandler()] handlers[0].setLevel(level) logging.basicConfig(level=level, format=fmt, handlers=handlers) coloredlogs.install( level=level, fmt=fmt, reconfigure=True, level_styles=coloredlogs.parse_encoded_styles( "debug=8;notice=green;warning=yellow;error=red,bold;critical=red,inverse" ), ) logging.getLogger("matplotlib").setLevel(logging.ERROR)
def field_styles(self): """Return log field styles. If "RUNWAY_LOG_FIELD_STYLES" exists in the environment, it will be used to update the Runway LOG_FIELD_STYLES. Returns: Dict[str, Any] """ if self.no_color: return {} result = LOG_FIELD_STYLES.copy() if self.ENV['field_styles']: result.update( coloredlogs.parse_encoded_styles(self.ENV['field_styles'])) return result
def setup_logging(config_filename, logging_folder, args): level = logging.DEBUG if args.verbose else logging.INFO logging_filename = f"{logging_folder}/{config_filename}.log" message_store = MessageStore() message_store.setLevel(logging.WARNING) NOTICE_LEVELV_NUM = 25 logging.addLevelName(NOTICE_LEVELV_NUM, "NOTICE") def notice(self, message, *args, **kws): if self.isEnabledFor(NOTICE_LEVELV_NUM): self._log(NOTICE_LEVELV_NUM, message, args, **kws) logging.Logger.notice = notice fmt_verbose = "[%(levelname)8s |%(filename)21s:%(lineno)3d] %(message)s" fmt_info = "%(message)s" fmt = fmt_verbose if args.verbose else fmt_info logger = get_logger() handlers = [message_store] if not args.check: handlers.append(logging.FileHandler(logging_filename, mode="w")) handlers[-1].setLevel(logging.DEBUG) handlers[-1].setFormatter(logging.Formatter(fmt_verbose)) #logging.basicConfig(level=level, format=fmt, handlers=handlers) for h in handlers: logger.addHandler(h) coloredlogs.install( level=level, fmt=fmt, reconfigure=True, level_styles=coloredlogs.parse_encoded_styles( "debug=8;notice=green;warning=yellow;error=red,bold;critical=red,inverse" ), ) logging.getLogger("matplotlib").setLevel(logging.ERROR) logger.info(f"Logging streaming out, also saving to {logging_filename}") return message_store, logging_filename
import speech_recognition as sr import scipy.io.wavfile as wav from asr_evaluation import asr_evaluation as eval from pathlib import Path import coloredlogs, logging import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' # disable ugly tensorflow logs # set up logging logger = logging.getLogger(__name__) coloredlogs.install( level='DEBUG', logger=logger, fmt='[%(levelname)s] %(message)s', level_styles=coloredlogs.parse_encoded_styles( 'spam=22;debug=28;verbose=34;info=226;notice=220;warning=202;success=118,bold;error=124;critical=background=red' )) r = sr.Recognizer() def get_logger(): return logger def get_current_directory(): return str(Path(__file__).parent.absolute()) def get_path_from_filename(filename): return get_current_directory() + '/audio/' + filename
logging.Logger.notice = notice fmt = "[%(levelname)8s |%(filename)21s:%(lineno)3d] %(message)s" if args.verbose else "%(message)s" logging.basicConfig(level=level, format=fmt, handlers=[ logging.FileHandler(logging_filename), logging.StreamHandler(), message_store, ]) coloredlogs.install( level=level, fmt=fmt, reconfigure=True, level_styles=coloredlogs.parse_encoded_styles( 'debug=8;notice=green;warning=yellow;error=red,bold;critical=red,inverse' )) logging.getLogger('matplotlib').setLevel(logging.ERROR) logger = get_logger() logger.info(f"Logging streaming out, also saving to {logging_filename}") # Load YAML config file config_path = os.path.dirname(inspect.stack()[0][1]) + args.config assert os.path.exists(config_path), f"File {config_path} cannot be found." with open(config_path, "r") as f: config = yaml.safe_load(f) manager = Manager(config_filename, config, message_store) if args.start is not None: args.refresh = True
def main(): """The application's main function.""" app = settings.ApplicationConfig() # Configuring logger. logger = logging.getLogger('sample') coloredlogs.install(fmt=app.logger_format, level_styles=coloredlogs.parse_encoded_styles( app.logger_styles), level=app.logger_level, logger=logger, milliseconds=True) logger.info('Started sample book managing application v{0}' \ .format(__version__)) # Creates director and list of builders to make the app's adapters. logger.debug('Creating director and fetching builders to create the app\'s' ' adapters') director = settings.Director() builders = settings.Builder.__subclasses__() # Configuring senders. logger.debug('Configuring senders ...') try: senders = app.senders sender_adapters = [] for sender in senders: sender_builder = next( b for b in builders if b.tech == sender \ and b.ctx == 'sender' ) # Retrieving adapter and configuring it. director.set_builder(sender_builder()) sender_adapters.append(director.get_adapter()) except StopIteration as err: logger.error( 'The chosen sender \'{0}\' has no builder or adapter' ' implementation or one of them is not decorated with @identify' \ .format(sender) ) sys.exit(1) logger.info('Using \'{0}\' adapter(s) for the sender(s)' \ .format([type(i).__name__ for i in sender_adapters])) # Configuring database. logger.debug('Configuring database ...') try: database = app.database database_builder = next(b for b in builders if b.tech == database and b.ctx == 'database') director.set_builder(database_builder()) # Retrieving adapter and configuring it. database_adapter = director.get_adapter() database_adapter.set_up() except StopIteration as err: logger.error( 'The chosen database \'{0}\' has no builder or adapter' ' implementation or one of them is not decorated with @identify' \ .format(database) ) sys.exit(1) logger.info('Using \'{0}\' adapter for database' \ .format(type(database_adapter).__name__)) """Creates message bus for exchange of commands and events with the adapters. Also creates handlers and subscribes them to their commands and events. """ bus = domain.ports.MessageBus() # Subscribes commands. bus.subscribe( domain.messages.RegisterBookCommand, handlers.RegisterBookHandler(bus, database_adapter.get_uowm())) # Subscribes events. for sender_adapter in sender_adapters: bus.subscribe( domain.messages.BookRegisteredEvent, handlers.BookRegisteredHandler(database_adapter.get_view(), sender_adapter)) # Configuring interfaces. logger.debug('Configuring interfaces ...') try: interfaces = app.interfaces interface_adapters = [] for interface in interfaces: interface_builder = next( b for b in builders if b.tech == interface \ and b.ctx == 'interface' ) # Retrieving adapter and configuring it. director.set_builder(interface_builder()) interface_adapter = director.get_adapter() interface_adapter.set_message_bus(bus) interface_adapter.set_view(database_adapter.get_view()) interface_adapters.append(interface_adapter) except StopIteration as err: logger.error( 'The chosen interface \'{0}\' has no builder or adapter' ' implementation or one of them is not decorated with @identify' \ .format(interface) ) sys.exit(1) logger.info('Using \'{0}\' adapter(s) for the interface(s)' \ .format([type(i).__name__ for i in interface_adapters])) # Starting application. logger.debug('Starting application ...') for interface_adapter in interface_adapters: interface_adapter.run() # Waiting until the application is stopped. try: while True: time.sleep(10) except KeyboardInterrupt: for interface_adapter in interface_adapters: interface_adapter.stop() logger.info('Ending application')