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 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')
