def setup(): formatter = logging.Formatter("[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") # same as default # setup `RainbowLoggingHandler` # and quiet some logs for the test output handler = RainbowLoggingHandler(sys.stderr) handler.setFormatter(formatter) logger = logging.getLogger() logger.addHandler(handler) if "VERBOSE_TEST" in os.environ: logger.setLevel(logging.DEBUG) else: logger.setLevel(logging.ERROR) logger = logging.getLogger("requests.packages.urllib3.connectionpool") logger.setLevel(logging.ERROR) logger = logging.getLogger("cryptoassets.core.backend.blockio") logger.setLevel(logging.DEBUG) logger = logging.getLogger("cryptoassets.core.backend.bitcoind") logger.setLevel(logging.WARN) # SQL Alchemy transactions logger = logging.getLogger("txn") logger.setLevel(logging.ERROR)
def setup_console_logging(log_level=None): """Setup console logging. Aimed to give easy sane defaults for loggig in command line applications. Don't use logging settings from INI, but use hardcoded defaults. """ formatter = logging.Formatter("[%(asctime)s] [%(name)s %(funcName)s] %(message)s") # same as default # setup `RainbowLoggingHandler` # and quiet some logs for the test output handler = RainbowLoggingHandler(sys.stdout) handler.setFormatter(formatter) logger = logging.getLogger() logger.handlers = [handler] env_level = os.environ.get("LOG_LEVEL", "info") log_level = log_level or getattr(logging, env_level.upper()) logger.setLevel(log_level) logger = logging.getLogger("requests.packages.urllib3.connectionpool") logger.setLevel(logging.ERROR) # SQL Alchemy transactions logger = logging.getLogger("txn") logger.setLevel(logging.ERROR)
def setup_custom_logger(): LOG_FILE = 'log/cpa' formatter = logging.Formatter("[%(asctime)s] %(threadName)s - %(pathname)s %(funcName)s():%(lineno)d %(levelname)s \t%(message)s") # same as default # formatter = logging.Formatter('%(asctime)s [%(pathname)s: %(lineno)d] %(levelname)s %(message)s') logger = logging.getLogger() logger.setLevel(logging.DEBUG) file_handler = ParallelTimedRotatingFileHandler(LOG_FILE, when='H') file_handler.setFormatter(formatter) logger.addHandler(file_handler) # console_handler = logging.StreamHandler(sys.stdout) # console_handler.formatter = formatter # logger.addHandler(console_handler) # setup `RainbowLoggingHandler` handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True)) handler.setFormatter(formatter) logger.addHandler(handler) #Add file handler handler = TimedRotatingFileHandler(LOG_FILE, when="h", interval=1, backupCount=48) # try: # raise RuntimeError("Opa!") # except Exception as e: # logger.exception(e) return logger
def test_format_all_column(): logger = logging.getLogger('test_logging_format_all_column') logger.setLevel(logging.DEBUG) formatter = logging.Formatter(''' name = '%(name)s' levelno = '%(levelno)s' levelname = '%(levelname)s' pathname = '%(pathname)s' filename = '%(filename)s' module = '%(module)s' lineno = '%(lineno)d' funcName = '%(funcName)s' created = '%(created)f' asctime = '%(asctime)s' msecs = '%(msecs)d' relativeCreated = '%(relativeCreated)d' thread = '%(thread)d' threadName = '%(threadName)s' process = '%(process)d' message = '%(message)s' ''') handler = RainbowLoggingHandler(sys.stderr) handler.setFormatter(formatter) logger.addHandler(handler) logger.debug("debug msg")
def setup_logging() -> None: """ Sets up the logging module to have a verbose option and formats the Console handler and File handler """ logging.addLevelName(VERBOSE, "VERBOSE") logging.Logger.verbose = logger_verbose logging.verbose = logging_verbose logging.VERBOSE = VERBOSE # define console handler console_handler = ConsoleHandler(sys.stderr) if hasattr(console_handler, "_column_color"): # noinspection PyProtectedMember # pylint: disable=protected-access console_handler._column_color['%(message)s'][logging.VERBOSE] = ('cyan', None, False) console_formatter = logging.Formatter("[%(asctime)s] %(levelname)s : %(message)s", "%H:%M:%S") console_handler.setFormatter(console_formatter) console_handler.setLevel(logging.VERBOSE) # define file handler if not os.path.exists(os.path.dirname(get_global_conf().getdir("install", "log_file"))): os.makedirs(os.path.dirname(get_global_conf().getdir("install", "log_file"))) file_handler = logging.FileHandler(get_global_conf().getdir("install", "log_file")) # add handlers logging.getLogger().addHandler(console_handler) logging.getLogger().addHandler(file_handler) logging.getLogger().setLevel(get_global_conf().getint("install", "log_level"))
def setup_logging(): log = logging.getLogger("") handler = RainbowLoggingHandler(sys.stderr) handler._column_color['%(asctime)s'] = ('cyan', None, False) handler._column_color['%(levelname)-7s'] = ('green', None, False) handler._column_color['%(message)s'][logging.INFO] = ('blue', None, False) handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-7s %(name)-15s %(message)s")) log.addHandler(handler) log.setLevel(logging.INFO)
def logger(config_file): CONFIG = configparser.RawConfigParser() CONFIG.read(config_file) logger_config = CONFIG['logger'] logger = logging.getLogger(logger_config['name']) logger.setLevel(LOGGING_LEVELS.get(logger_config['level'], logging.NOTSET)) formatter = logging.Formatter( '[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s' ) handler = RainbowLoggingHandler( sys.stderr, color_funcName=('black', 'yellow', True) ) handler.setFormatter(formatter) logger.addHandler(handler) if CONFIG.has_section('file_logger'): file_logger_config = CONFIG['file_logger'] fh = logging.handlers.RotatingFileHandler( file_logger_config['file_path'], maxBytes=int(file_logger_config['max_log_file_size']), backupCount=int(file_logger_config['backup_count']) ) fh.setLevel(LOGGING_LEVELS.get(file_logger_config['level'], logging.NOTSET)) fh.setFormatter(formatter) logger.addHandler(fh) if CONFIG.has_section('email_logger'): email_logger_config = CONFIG['email_logger'] eh = logging.handlers.SMTPHandler( (email_logger_config['host'], email_logger_config['port']), email_logger_config['from'], email_logger_config['to'], email_logger_config['subject'], (email_logger_config['username'], email_logger_config['password']), () ) eh.setLevel(LOGGING_LEVELS.get(email_logger_config['level'], logging.NOTSET)) eh.setFormatter(formatter) logger.addHandler(eh) return logger
def add_stdout_handler(logger, formatter): try: from rainbow_logging_handler import RainbowLoggingHandler handler = RainbowLoggingHandler(sys.stderr, color_funcName=( 'black', 'black', True)) except ImportError: handler = logging.StreamHandler() pass handler.setFormatter(formatter) logger.addHandler(handler)
def setup_logging(verbose=False): log = logging.getLogger("") handler = RainbowLoggingHandler(sys.stderr) handler._column_color['%(asctime)s'] = ('cyan', None, False) handler._column_color['%(levelname)-7s'] = ('green', None, False) handler._column_color['%(message)s'][logging.INFO] = ('blue', None, False) handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-7s %(name)-15s %(message)s")) log.addHandler(handler) log.setLevel([logging.INFO, logging.DEBUG][verbose]) logging.getLogger("boto").level = logging.CRITICAL
def __init__(self, module_name): self.logger_tmp = None logger = logging.getLogger(module_name) logging.basicConfig(filename='/tmp/r2als.log',level=logging.DEBUG,format='%(asctime)s %(levelname)s %(message)s') # logging.basicConfig(level=logging.DEBUG) formatter = logging.Formatter("[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") # same as default # setup `RainbowLoggingHandler` handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'gray', True)) handler.setFormatter(formatter) logger.addHandler(handler) self.logger_tmp = logger
def test_custom_format(): logger = logging.getLogger('test_logging_custom_format') logger.setLevel(logging.DEBUG) formatter = logging.Formatter("MESSAGE ONLY => %(message)s") handler = RainbowLoggingHandler(sys.stderr) handler.setFormatter(formatter) logger.addHandler(handler) logger.debug("debug msg") logger.info("info msg") logger.warn("warn msg") logger.error("error msg") logger.critical("critical msg")
def setup(): # prepare log file global f_log, logpath (fd, logpath) = mkstemp(prefix='raibow-', suffix='.txt') f_log = os.fdopen(fd, 'w') # prepare 'test_format' logger logger = logging.getLogger('test_format') logger.setLevel(logging.DEBUG) formatter = logging.Formatter("AAA %(name)s - %(levelname)s - %(message)s ZZZ") # testing whether this format is used handler = RainbowLoggingHandler(f_log) handler.setFormatter(formatter) logger.addHandler(handler)
def get_logger(): global logger if logger == None: logger = logging.getLogger('freesprints') logger.setLevel(logging.DEBUG) formatter = logging.Formatter("[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") # same as default # setup colored logging handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True)) handler.setFormatter(formatter) logger.addHandler(handler) return logger
def setup_logging(verbose=False, silent=False, debug=False): log = logging.getLogger("") handler = RainbowLoggingHandler(sys.stderr) handler._column_color['%(asctime)s'] = ('cyan', None, False) handler._column_color['%(levelname)-7s'] = ('green', None, False) handler._column_color['%(message)s'][logging.INFO] = ('blue', None, False) handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-7s %(name)-15s %(message)s")) log.addHandler(handler) log.setLevel([logging.INFO, logging.DEBUG][verbose or debug]) if silent: log.setLevel(logging.ERROR) logging.getLogger("requests").setLevel([logging.CRITICAL, logging.ERROR][verbose or debug]) return handler
def setup_logging(self, args, verbose=False, silent=False, debug=False, logging_name=""): """Setup the RainbowLoggingHandler for the logs and call setup_other_logging""" log = logging.getLogger(logging_name) handler = RainbowLoggingHandler(self.logging_handler_file) handler._column_color['%(asctime)s'] = ('cyan', None, False) handler._column_color['%(levelname)-7s'] = ('green', None, False) handler._column_color['%(message)s'][logging.INFO] = ('blue', None, False) handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)-7s %(name)-15s %(message)s")) log.addHandler(handler) log.setLevel([logging.INFO, logging.DEBUG][verbose or debug]) if silent: log.setLevel(logging.ERROR) self.setup_other_logging(args, verbose, silent, debug) return handler
def setup_TerminalLogger(log_level, logger_name='TerminalLogger'): """Setup colorful logger *Usage* .. code-block:: python setup_TerminalLogger(logging.DEBUG) logger = logging.getLogger('TerminalLogger') logger.debug('hello') """ logger = logging.getLogger(logger_name) logger.setLevel(log_level) handler = RainbowLoggingHandler(sys.stderr, datefmt=None) handler.setFormatter(logging.Formatter("[%(asctime)s] %(filename)s %(funcName)s():%(lineno)d\t%(message)s")) logger.addHandler(handler)
def add_stdout_handler(logger): formatter = Formatter( "[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") try: # Si está instalado rainbow_logging_handler (coloriza el output # de consola) lo usamos, sino defaulteamos al módulo logging from rainbow_logging_handler import RainbowLoggingHandler handler = RainbowLoggingHandler(sys.stderr, color_funcName=( 'black', 'black', True)) except ImportError: handler = StreamHandler() pass handler.setFormatter(formatter) logger.addHandler(handler)
def colorlogs(): try: from rainbow_logging_handler import RainbowLoggingHandler import sys # setup `RainbowLoggingHandler` logger = logging.root formatter = logging.Formatter( "[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") # ^^^ same as default handler = RainbowLoggingHandler( sys.stderr, color_funcName=('black', 'gray', True)) handler.setFormatter(formatter) logger.addHandler(handler) except ImportError: # rainbow logger not found, that's ok pass
def main_func(): # Check the number of inputs numofinputs = len(sys.argv) # Conditional expressions if numofinputs > 5 : print ("Invalid arguments \nGood BYE") else : # Get the input arguments filename = argv.pop(1) # EXE name, File Name, Module Name operation = argv.pop(1) # DEBUG, INFO, WARN, ERROR, CRITICAL, EXCEPTION message = argv.pop(1) # Message to be printed logFile = argv.pop(1) # Log file # setup `logging` module logger = logging.getLogger(filename) fileHandler = logging.FileHandler('Logger.log') logger.setLevel(logging.INFO) formatter = logging.Formatter("[%(asctime)s] [%(name)s] : %(message)s") # setup `RainbowLoggingHandler` handler = RainbowLoggingHandler(sys.stderr, color_name=('grey', None , True),color_asctime=('green', None , True)) handler.setFormatter(formatter) fileHandler.setFormatter(formatter) logger.addHandler(fileHandler) logger.addHandler(handler) if operation == 'DEBUG' : logger.debug(message) if operation == 'INFO' : logger.info(message) if operation == 'WARN' : logger.warn(message) if operation == 'ERROR' : logger.error(message) if operation == 'CRITICAL' : logger.critical(message) if operation == 'EXCEPTION' : raise RuntimeError("InstallException!") logger.exception(message) logger.exception(e)
def setup_logging(verbose=False, boto_debug=False): log = logging.getLogger("") handler = RainbowLoggingHandler(sys.stderr) handler._column_color['%(asctime)s'] = ('cyan', None, False) handler._column_color['%(levelname)-7s'] = ('green', None, False) handler._column_color['%(message)s'][logging.INFO] = ('blue', None, False) handler.setFormatter( logging.Formatter( "%(asctime)s %(levelname)-7s %(name)-15s %(message)s")) log.addHandler(handler) log.setLevel([logging.INFO, logging.DEBUG][verbose]) if boto_debug: logging.getLogger("boto").setLevel(logging.DEBUG) else: logging.getLogger("boto").setLevel([logging.CRITICAL, logging.ERROR][verbose]) logging.getLogger("requests").setLevel([logging.CRITICAL, logging.ERROR][verbose])
def colorlogs(format="short"): """Append a rainbow logging handler and a formatter to the root logger""" try: from rainbow_logging_handler import RainbowLoggingHandler import sys # setup `RainbowLoggingHandler` logger = logging.root # same as default if format == "short": fmt = "%(message)s " else: fmt = "[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s [%(levelname)s]" formatter = logging.Formatter(fmt) handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'gray', True)) handler.setFormatter(formatter) logger.addHandler(handler) except ImportError: # rainbow logger not found, that's ok pass
def setup_console_logging(log_level=None): """Setup console logging. Aimed to give easy sane defaults for loggig in command line applications. Don't use logging settings from INI, but use hardcoded defaults. """ formatter = logging.Formatter("[%(asctime)s] [%(name)s %(funcName)s:%(lineno)d] %(message)s") # same as default # setup `RainbowLoggingHandler` # and quiet some logs for the test output handler = RainbowLoggingHandler(sys.stdout) handler.setFormatter(formatter) logger = logging.getLogger() logger.handlers = [handler] env_level = os.environ.get("LOG_LEVEL", "info") log_level = log_level or getattr(logging, env_level.upper()) logger.setLevel(log_level)
def test_usage(): root_logger = logging.getLogger() root_logger.setLevel(logging.DEBUG) handler = RainbowLoggingHandler(sys.stderr) formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s") handler.setFormatter(formatter) root_logger.addHandler(handler) logger = logging.getLogger('test') logger.debug("debug msg") logger.info("info msg") logger.warn("warn msg") logger.error("error msg") logger.critical("critical msg") try: raise RuntimeError("Opa!") except Exception as e: logger.exception(e)
def __init__(self, application_object, plugin_object): # setup logger self.logger = logging.getLogger('Needles') self.logger.setLevel(logging.DEBUG) formatter = logging.Formatter("[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") # same as default # setup colored logging handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True)) handler.setFormatter(formatter) self.logger.addHandler(handler) self.logger.debug("init in Needles plugin") self.application = application_object self.plugin_object = plugin_object self.display_surface = self.application.get_window_surface() font_path = "./fonts/Cave-Story.ttf" distance_font_path = "./fonts/Warenhaus-Standard.ttf" self.font_big = pygame.font.Font(distance_font_path, 68) self.font_distance = pygame.font.Font(distance_font_path, 50)
def get_logger(name): logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) handler = logging.FileHandler(os.path.join(config.logs_dir, '{}.log'.format(name))) handler.setFormatter(log_formatter) handler.setLevel(logging.DEBUG) handler2 = RainbowLoggingHandler( sys.stdout, '%Y-%m-%d %H:%M:%S', color_asctime=('white', None, False) ) handler2.setFormatter(log_formatter) handler2.setLevel(logging.DEBUG) logger.addHandler(handler) logger.addHandler(handler2) return logger
def setup_custom_logger(): LOG_PATH = 'log' FileUtils.create_folder_if_not_exists(LOG_PATH) LOG_FILE = "{0}/{1}".format(LOG_PATH, "thinklog") # logging.Formatter.converter = time.gmtime formatter = logging.Formatter( "[%(asctime)s] %(threadName)s - %(pathname)s %(funcName)s():%(lineno)d %(levelname)s \t%(message)s" ) # same as default # formatter = logging.Formatter('%(asctime)s [%(pathname)s: %(lineno)d] %(levelname)s %(message)s') logger = logging.getLogger() logger.setLevel(logging.DEBUG) file_handler = ParallelTimedRotatingFileHandler(LOG_FILE, when='H') file_handler.setFormatter(formatter) logger.addHandler(file_handler) # console_handler = logging.StreamHandler(sys.stdout) # console_handler.formatter = formatter # logger.addHandler(console_handler) # setup `RainbowLoggingHandler` handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True)) handler.setFormatter(formatter) logger.addHandler(handler) #Add file handler handler = TimedRotatingFileHandler(LOG_FILE, when="h", interval=1, backupCount=24) # try: # raise RuntimeError("Opa!") # except Exception as e: # logger.exception(e) return logger
def enable_logging(filename: str, level: str): class Squelch(logging.Filter): def filter(self, record): if record.levelno == logging.DEBUG: return not record.name.startswith('asyncio') and \ not record.name.startswith('websockets') and \ not record.name.startswith('aiohttp') elif record.levelno == logging.INFO and record.name.startswith('asyncio'): return False return True formatter = logging.Formatter(fmt='%(asctime)s.%(msecs)03d:%(levelname)s:%(name)s:%(message)s') # File logger captures everything. file_handler = logging.FileHandler(filename) file_handler.setLevel(logging.DEBUG) # Console output level is configurable. stream_handler = RainbowLoggingHandler( sys.stdout, color_asctime=('cyan', None, False), color_msecs=('cyan', None, False), color_levelname=('gray', None, False), color_module=('yellow', None, False), color_name=('blue', None, False), color_lineno=('green', None, False), datefmt="%Y-%m-%d %H:%M:%S" ) stream_handler.setLevel(getattr(logging, level)) stream_handler.addFilter(Squelch()) # Set an output format. stream_handler.setFormatter(formatter) file_handler.setFormatter(formatter) file_handler.addFilter(Squelch()) # Add handlers to root. root = logging.getLogger('') root.setLevel(logging.DEBUG) root.addHandler(stream_handler) root.addHandler(file_handler)
def _setup_logging(verbose, no_color): """Set up Python logging based on verbosity level. :param verbose: verbosity level :param no_color: do not use colorized output """ level = logging.WARNING if verbose == 1: level = logging.INFO elif verbose > 1: level = logging.DEBUG logger = logging.getLogger() logger.setLevel(level) if not no_color: formatter = logging.Formatter("%(process)d: [%(asctime)s] %(name)s %(funcName)s:%(lineno)d: %(message)s") # setup RainbowLoggingHandler handler = RainbowLoggingHandler(sys.stderr) handler.setFormatter(formatter) logger.addHandler(handler)
class MyLogging(object): """ 自定义logging类 """ def __init__(self): """ 初始化类 """ self.formatter = logging.Formatter( '%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s' ) self.local_time = time.strftime("%Y%m%d-%H%M%S") self.path = 'result\log' if not os.path.exists(self.path): os.makedirs(self.path) # 日志文件 self.file_handler = logging.FileHandler('result\log\Testlog_%s.log' % self.local_time) # 控制台日志 self.color_handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True)) def get_logger(self): """ 获取日志实例 :return: None """ logger = logging.getLogger("Logger") logger.setLevel(logging.DEBUG) self.file_handler.setLevel(logging.DEBUG) self.file_handler.setFormatter(self.formatter) self.color_handler.setFormatter(self.formatter) logger.addHandler(self.file_handler) logger.addHandler(self.color_handler) return logger
def setup(): formatter = logging.Formatter("[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") # same as default # setup `RainbowLoggingHandler` # and quiet some logs for the test output handler = RainbowLoggingHandler(sys.stderr) handler.setFormatter(formatter) logger = logging.getLogger() logger.addHandler(handler) if "VERBOSE_TEST" in os.environ: logger.setLevel(logging.DEBUG) else: logger.setLevel(logging.ERROR) logger = logging.getLogger("requests.packages.urllib3.connectionpool") logger.setLevel(logging.ERROR) logger = logging.getLogger("cryptoassets.core.backend.bitcoind") logger.setLevel(logging.WARN) # SQL Alchemy transactions logger = logging.getLogger("txn") logger.setLevel(logging.ERROR)
from rainbow_logging_handler import RainbowLoggingHandler import datetime if __name__ == "__main__": # logger取得 logger = logging.getLogger("log") # レベル設定 logger.setLevel(logging.DEBUG) # 出力フォーマット formatter = logging.Formatter(fmt="%(asctime)s %(message)s") # 色付け出力ハンドラの登録 rainbow_handler = RainbowLoggingHandler(sys.stderr, color_message_info=("green", None, True)) rainbow_handler.setFormatter(formatter) logger.addHandler(rainbow_handler) # ファイル出力用ハンドラの登録 date_obj = datetime.datetime.now() date_str = date_obj.strftime("%Y-%m-%d-%H:%M:%S") logfilename = "./log/%s.log" % (date_str) file_handler = logging.FileHandler(logfilename, "w") file_handler.setFormatter(formatter) logger.addHandler(file_handler) logger.debug("this is debug") logger.info("this is info") logger.warning("this is warning") logger.error("this is error") logger.critical("this is critical")
""" Creates an ordered dict out of a list of elements. :param items: list of elements :param key_func: function that returns a key for each passed list element :return: created ordered dict with the elements in the same order as in the passed list """ if items is None: return InsertionTimeOrderedDict() ret = InsertionTimeOrderedDict() for item in items: ret[key_func(item)] = item return ret #formatter = logging.Formatter("[%(asctime)s] %(name)s %(levelname)s \t%(message)s") # setup `RainbowLoggingHandler` handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True)) """ Colored logging handler that is used for the root logger """ handler.setFormatter(logging.Formatter("[%(asctime)s] %(message)s")) logging.getLogger().addHandler(handler) def geom_std(values: t.List[float]) -> float: """ Calculates the geometric standard deviation for the passed values. Source: https://en.wikipedia.org/wiki/Geometric_standard_deviation """ import scipy.stats as stats import scipy as sp gmean = stats.gmean(values) return sp.exp(sp.sqrt(sp.sum([sp.log(x / gmean) ** 2 for x in values]) / len(values)))
# set up stream handler if not disable_stream_handler: try: # Rainbow Logging from rainbow_logging_handler import RainbowLoggingHandler # noqa: E402 color_msecs = ('green', None, True) stream_handler = RainbowLoggingHandler( sys.stdout, color_msecs=color_msecs, datefmt=datefmt ) # msecs color stream_handler._column_color['.'] = color_msecs stream_handler._column_color['%(asctime)s'] = color_msecs stream_handler._column_color['%(msecs)03d'] = color_msecs except Exception: stream_handler = StreamHandler() # the level of output logging stream_handler.setLevel(DEBUG) stream_handler.setFormatter(default_fmt) logger.addHandler(stream_handler) if not disable_file_handler: file_handler = FileHandler(filename=save_filename) # the level of output logging file_handler.setLevel(DEBUG) file_handler.setFormatter(default_fmt) logger.addHandler(file_handler)
#! /usr/bin/env python # -*- coding:utf-8 -*- # Standard lib imports import logging.handlers import sys import time # Third Party imports from rainbow_logging_handler import RainbowLoggingHandler # BITSON imports logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) log_format = "".join(["[%(asctime)s] %(levelname)8s: ", "%(message)s"]) formatter = logging.Formatter(fmt=log_format) # Format UTC Time formatter.converter = time.gmtime # Console Handler ch = RainbowLoggingHandler(sys.stderr) ch.setLevel(logging.DEBUG) ch.setFormatter(formatter) logger.addHandler(ch)
# Standard lib imports import logging.handlers import time import os import sys # Third Party imports from rainbow_logging_handler import RainbowLoggingHandler # BITSON imports from config import Config console_logger = logging.getLogger('trest') console_logger.setLevel(logging.DEBUG) console_handler = RainbowLoggingHandler(sys.stderr) console_handler.setLevel(logging.DEBUG) console_handler.setFormatter(logging.Formatter(fmt="%(message)s")) console_logger.addHandler(console_handler) log_format = "".join( ["[%(asctime)s] %(name)20s - %(levelname)8s: ", "%(threadName)15s-%(funcName)15s() - %(message)s"] ) formatter = logging.Formatter(fmt=log_format) # Format UTC Time formatter.converter = time.gmtime if not os.path.isdir(Config.LOG_FOLDER): os.mkdir(Config.LOG_FOLDER) logfile = os.path.join(Config.LOG_FOLDER,
def initialize_logger(args, script_name, syslog_server=None): """ Initialize the logging instance with the values provided by the user and return the logging object. """ LOGGER = logging.getLogger(script_name) FORMATTER = logging.Formatter( ""+script_name+" : "+str(getpass.getuser())+" : %(asctime)s : %(levelname)s : %(message)s", datefmt='%m/%d/%Y %I:%M:%S %p') # create console handler and set level to info logging.StreamHandler() # setup `RainbowLoggingHandler` handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'white', True)) handler.setFormatter(FORMATTER) LOGGER.addHandler(handler) # setup log level from arguments if args.log: if contains('DEBUG', args.log.upper()): handler.setLevel(logging.DEBUG) LOGGER.setLevel(logging.DEBUG) elif contains('WARNING', args.log.upper()): handler.setLevel(logging.WARNING) LOGGER.setLevel(logging.WARNING) elif contains('ERROR', args.log.upper()): handler.setLevel(logging.ERROR) LOGGER.setLevel(logging.ERROR) else: handler.setLevel(logging.INFO) LOGGER.setLevel(logging.INFO) LOGGER.info('Logging level has been set to {}'.format(args.log.upper())) # setup logging directory to store log files if args.log_dir: if not os.path.isdir(args.log_dir): os.makedirs(args.log_dir) output_dir = args.log_dir else: output_dir = create_log_dir() LOGGER.info('Logging directory has been set to {}'.format(output_dir)) # create optional syslog handler, if the argument has been supplied to support it if args.syslog: DESIG_SYSLOG_SERVER = syslog_server handler = logging.handlers.SysLogHandler(address=(DESIG_SYSLOG_SERVER, logging.handlers.SYSLOG_UDP_PORT)) syslog_format = logging.Formatter( '[appname]: %(name)s: [alias]: '+str(getpass.getuser())+' %(message)s') handler.setFormatter(syslog_format) if args.syslog_level: # Set syslog level to the user specified level if args.syslog_level == 'info': handler.setLevel(logging.INFO) elif args.syslog_level == 'warning': handler.setLevel(logging.WARNING) elif args.syslog_level == 'error': handler.setLevel(logging.ERROR) LOGGER.info( 'Syslog has been enabled for [{}] logging level, sent to syslog server [{}]'.format( args.syslog_level, DESIG_SYSLOG_SERVER)) # Add syslog handler to logging object LOGGER.addHandler(handler) # create error file handler and set level to error handler = logging.FileHandler(os.path.join( output_dir, "error.log"),"a", encoding=None, delay="true") handler.setLevel(logging.ERROR) handler.setFormatter(FORMATTER) LOGGER.addHandler(handler) # create debug file handler and set level to debug handler = logging.FileHandler(os.path.join(output_dir, "all.log"),"a") handler.setLevel(logging.DEBUG) handler.setFormatter(FORMATTER) LOGGER.addHandler(handler) if args.logfile_rotate: ''' User has specified they would like to create a daily rotating logfile. Create an instance and DO NOT create a single serving logfile. ''' LOGGER.info('Logfiles are now set to auto-rotate at midnight UTC.') filepath_and_name_format = ('{}/{}'.format(output_dir, script_name.replace('.py',''))) LOGGER.info('Logfiles are now being written at {}'.format(filepath_and_name_format)) log_filename=filepath_and_name_format # maxBytes takes the max file size in MB and bit-shift converts to bytes handler=SizedTimedRotatingFileHandler( log_filename, maxBytes=args.logsize<<20) handler.setLevel(logging.DEBUG) handler.setFormatter(FORMATTER) handler.suffix = "%Y-%m-%d.log" LOGGER.addHandler(handler) else: # create individual execution file handler and set level to debug now = datetime.datetime.now() datetime_stamp = now.strftime("%Y-%m-%d_%H-%M-%S") datetime_stamp = ('{}_{}.log'.format(datetime_stamp, script_name.replace('.py',''))) filename = os.path.join(output_dir, datetime_stamp) handler = logging.FileHandler(filename, "a") if contains('DEBUG', args.log.upper()): handler.setLevel(logging.DEBUG) elif contains('WARNING', args.log.upper()): handler.setLevel(logging.WARNING) elif contains('ERROR', args.log.upper()): handler.setLevel(logging.ERROR) else: handler.setLevel(logging.INFO) handler.setFormatter(FORMATTER) LOGGER.addHandler(handler) # display the exact file name / path to the user LOGGER.info('Logs for this session now being written to {}'.format(filename)) # Attach filepath / filename string to logger LOGGER.filename = filename return LOGGER
def main(): # setup `logging` module logger = logging.getLogger('Rancher Deployment') # logger.setLevel(logging.DEBUG) formatter = logging.Formatter("%(message)s") # same as default # setup `RainbowLoggingHandler` handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True), color_module=('yellow', None, False)) handler.setFormatter(formatter) logger.addHandler(handler) # ################################### # Importing Args Modules # ----------------------------------- from src import arguments # ##################################################### # 1. Confirming Command Config and Required Arguments # ----------------------------------------------------- # Check to see if arguments have been passed at all if arguments.noSystemArgsExist(sys.argv): arguments.printHelpDocumentationThenExit() # Check if we are printing out the version information if arguments.isVersionCommandEntered(sys.argv): arguments.printVersionInformationThenExit() # Check for the existance of flags if arguments.doFlagsExist(sys.argv): flags = sys.argv[1] arguments.checkHelpFlag(flags) FORCE_MODE = arguments.setForceFlag(flags) VERBOSE_MODE = arguments.setVerboseFlag(flags) DEVELOPMENT_MODE = arguments.setDevelopmentFlag(flags) else: FORCE_MODE = False VERBOSE_MODE = False DEVELOPMENT_MODE = False if VERBOSE_MODE: logger.setLevel(logging.DEBUG) logger.info("INFO: Flag Configuration Set") logger.debug("DEBUG: Force Mode: %s", FORCE_MODE) logger.debug("DEBUG: Verbose Mode: %s", VERBOSE_MODE) logger.debug("DEBUG: Development Mode: %s\n", DEVELOPMENT_MODE) if not DEVELOPMENT_MODE: arguments.checkArgumentStructure(sys.argv) ENV_ARGUMENT = arguments.setEnvironment(sys.argv) RANCHER_URL = arguments.setRancherUrl(sys.argv) RANCHER_ACCESS_KEY = arguments.setRancherKey(sys.argv) RANCHER_SECRET_KEY = arguments.setRancherSecret(sys.argv) else: logger.info("INFO: Currently In Development Mode. Setting Default Parameters.") ENV_ARGUMENT = "staging" RANCHER_URL = 'http://localhost:8080/v1/' RANCHER_ACCESS_KEY = '9F68C78100A2CAA209EC' RANCHER_SECRET_KEY = 'pEkMsBYjcZNxhY4rzYuEfdLLj7mDBZ8EPYwbtgVZ' if not FORCE_MODE: print "Rancher Arguments Set" print "ENVIRONMENT: %s" % ENV_ARGUMENT logger.debug("DEBUG: RANCHER_URL: %s", RANCHER_URL) logger.debug("DEBUG: RANCHER_ACCESS_KEY: %s", RANCHER_ACCESS_KEY) logger.debug("DEBUG: RANCHER_SECRET_KEY: %s", RANCHER_SECRET_KEY) print "Would you like to continue?" var = raw_input("Please enter (Y|N): ") if var == "y" or var == "Y": print "User Confirmation Accepted. Performing Rancher Deployment" logger.debug("DEBUG: Please use the [-f] flag to force application execution and skip confirmation") elif var == "n" or var == "N": logger.error("ERROR: User stopped app execution.") logger.debug("DEBUG: Please use the [-f] flag to force application execution and skip confirmation") print sys.exit(0) else: logger.error("ERROR: Invalid User Input") logger.error("ERROR: Please use the [-f] flag to force application execution and skip confirmation") print sys.exit(0) else: logger.info("INFO: Force Mode Enabled. Skipping Flag Confirmation") print "Starting Matador Deploy..." # ################################## # Import Additional Custom Modules # ---------------------------------- # NOTE: This is done here so that the global vars can be used in the inner modules from src import yml_reader from src import compose_builder from src import rancher_compose # ################################## # 2. Reading YAML Files Into Script # ---------------------------------- rancher_compose_list = yml_reader.readRancherComposeTemplate() docker_compose_list = yml_reader.readDockerComposeTemplate() config_file = yml_reader.readConfigurationFile() global_config = yml_reader.getGlobalConfig() env_config = yml_reader.getEnvConfig(ENV_ARGUMENT) PROJECT_NAME = config_file['project_name'] + "-" + ENV_ARGUMENT # ################################################## # 3. Combine config into the rancher compose # -------------------------------------------------- compose_builder.addConfigToDockerCompose(docker_compose_list, global_config) compose_builder.addConfigToDockerCompose(docker_compose_list, env_config) # ############################################### # 4. Set the image for the deployment # ----------------------------------------------- compose_builder.setImageForDockerConfig(docker_compose_list, ENV_ARGUMENT, config_file['image_base']) # ############################################### # 5. Save new yml out to a temp file # ----------------------------------------------- yml_reader.createBuildDirectory() yml_reader.saveRancherComposeFile(rancher_compose_list) yml_reader.saveDockerComposeFile(docker_compose_list) # ############################################### # 6. Start updating this stuff to rancher baby # ----------------------------------------------- cattle_client = cattle.Client( url=RANCHER_URL, access_key=RANCHER_ACCESS_KEY, secret_key=RANCHER_SECRET_KEY ) rancher_compose.setRancherVars(RANCHER_URL, RANCHER_ACCESS_KEY, RANCHER_SECRET_KEY, PROJECT_NAME) rancher_compose.checkForExistingEnvironment(cattle_client, PROJECT_NAME) rancher_compose.pushToRancher()
import logging, traceback, sys from rainbow_logging_handler import RainbowLoggingHandler # logging.basicConfig(level=logging.DEBUG, format='%(filename)-15s:%(lineno)-4d %(levelname)s: %(message)s') handler = RainbowLoggingHandler(sys.stderr) handler.setFormatter(logging.Formatter("%(filename)s:%(lineno)d\t%(levelname)s: %(message)s")) logger = logging.getLogger() logger.setLevel(logging.DEBUG) logger.addHandler(handler) logging.getLogger("OpenGL").setLevel(99) # allow importing from the repository root import sys, os, json sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) import apc.baxter_scoop as baxter from integration.visualization import debug_cloud from integration.camera import uvtexture, invalid_mask from integration.io import pcd from perception.segmentation.color import rgb2yuv, make_uv_hist from klampt.robotsim import WorldModel from klampt import se3, so3 from time import sleep, time import numpy, math from matplotlib import pyplot def load_histogram(obj, n):
import logging import sys from rainbow_logging_handler import RainbowLoggingHandler # setup `logging` module logger = logging.getLogger('console') formatter = logging.Formatter("%(message)s") # setup `RainbowLoggingHandler` handler = RainbowLoggingHandler(sys.stderr, color_funcName=('black', 'yellow', True)) handler.setFormatter(formatter) logger.addHandler(handler) def get_logger(): return logger def set_level(level): logger.setLevel(level)
""" Initialise the application. @author: Chris Scott """ import sys import platform import logging try: from rainbow_logging_handler import RainbowLoggingHandler root = logging.getLogger() root.setLevel(logging.NOTSET) formatter = logging.Formatter("%(name)s:%(funcName)s():%(lineno)d: %(message)s") handler = RainbowLoggingHandler(sys.stderr) handler.setFormatter(formatter) root.addHandler(handler) except ImportError: # configure logging (we have to set logging.NOTSET here as global for root logger) logging.basicConfig(format="%(levelname)s: %(name)s: %(message)s", level=logging.NOTSET) from PySide import QtGui, QtCore # set default for stream handler (we don't want it to be NOTSET by default) _argLevel = None if len(sys.argv) > 1: if "DEBUG" in sys.argv: _argLevel = logging.DEBUG elif "INFO" in sys.argv: _argLevel = logging.INFO elif "WARNING" in sys.argv:
from pensive.coders import register_numpy logger = logging.getLogger(__name__) # configure the root logger to accept all records logger = logging.getLogger() logger.setLevel(logging.NOTSET) formatter = logging.Formatter( '%(asctime)s\t[%(name)s] %(pathname)s:%(lineno)d\t%(levelname)s:\t%(message)s' ) # set up colored logging to console from rainbow_logging_handler import RainbowLoggingHandler console_handler = RainbowLoggingHandler(sys.stderr) console_handler.setFormatter(formatter) logger.addHandler(console_handler) class RealsenseCalibration(QtWidgets.QWidget): def __init__(self): super(RealsenseCalibration, self).__init__() self.initUI() self.thread = VideoThread() self.thread.signal.connect(self.updateView) cameramat, cameracoeff = self.thread.getIntrinsics() if cameramat is None: logger.warning( "Unable to get camera coefficients for camera. Setting to zeros..." ) cameramat = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
def main(instruments, mode, log_level, debug, step, start_date=None, end_date=None): """ Algorithmic trading tool. """ _start_time = time() if debug: def exception_handler(type, value, traceback): click.secho( '\nAn exception occurred while executing the requested ' 'command:', fg='red' ) hr(fg='red') sys.__excepthook__(type, value, traceback) click.secho('\nStarting interactive debugging session:', fg='red') hr(fg='red') pdb.post_mortem(traceback) sys.excepthook = exception_handler if step: pdb.set_trace() # Make urllib3 logger more calm urllib3_logger = logging.getLogger('urllib3') urllib3_logger.setLevel(logging.CRITICAL) try: os.makedirs('logs') except OSError as exception: if exception.errno != errno.EEXIST: raise numeric_level = getattr(logging, log_level.upper(), None) if not isinstance(numeric_level, int): raise ValueError('Invalid log level: %s' % log_level) log_filename = "logs/pyfx_debug_{}-{}.log".format( strftime("%Y_%m_%d-%H_%M"), settings.ENVIRONMENT) logging.basicConfig(filename=log_filename, level=logging.DEBUG) formatter = logging.Formatter( "[%(asctime)s/%(levelname)s] %(funcName)s():%(lineno)d\t%(message)s") handler = RainbowLoggingHandler( sys.stdout, color_funcName=('black', 'yellow', True)) handler.setFormatter(formatter) handler.setLevel(numeric_level) log.addHandler(handler) start_date_ = start_date if start_date else settings.BACKTEST_START end_date_ = end_date if end_date else settings.BACKTEST_END BACKTEST_START = parser.parse(start_date_).replace(tzinfo=pytz.utc) BACKTEST_END = parser.parse(end_date_).replace(tzinfo=pytz.utc) if mode == 'backtest': api = oandapy.API( environment=settings.ENVIRONMENT, access_token=settings.ACCESS_TOKEN, ) broker = OandaBacktestBroker( api=api, account_id=settings.ACCOUNT_ID, initial_balance=decimal.Decimal(5000)) # Oanda 20:00, Local: 22:00, DailyFx: 16:00 clock_interval = settings.CLOCK_INTERVAL log.info('Starting simulated clock with interval {} seconds'.format(clock_interval)) clock = SimulatedClock( start=BACKTEST_START, stop=BACKTEST_END, interval=clock_interval, ) elif mode == 'live': api = oandapy.API( environment=settings.ENVIRONMENT, access_token=settings.ACCESS_TOKEN, ) clock = IntervalClock(interval=settings.CLOCK_INTERVAL) broker = OandaRealtimeBroker(api=api, account_id=settings.ACCOUNT_ID) else: raise NotImplementedError() # TODO Optimize load of instrument info instrument_list = set(instruments) for inst in instrument_list: inst.load(broker) # TODO We have to be able to instantiate strategies with custom args strategies = [settings.STRATEGY(instrument) for instrument in instrument_list] if mode == 'backtest': broker.init_backtest(BACKTEST_START, BACKTEST_END, strategies) pf = Portfolio(broker, mode='backtest') else: pf = Portfolio(broker, mode='live') controller = Controller(clock, broker, pf, strategies) controller.run_until_stopped() log.info('script duration: {:.2f}s'.format(time() - _start_time))
# set up handler try: # Rainbow Logging import sys from rainbow_logging_handler import RainbowLoggingHandler color_msecs = ('black', None, True) default_handler = RainbowLoggingHandler(sys.stdout, color_msecs=color_msecs, datefmt=datefmt) # HACK for msecs color default_handler._column_color['.'] = color_msecs default_handler._column_color['%(msecs)03d'] = color_msecs except Exception: default_handler = logging.StreamHandler() default_handler.setFormatter(default_fmt) default_handler.setLevel(logging.DEBUG) # setup root logger logger = logging.getLogger() logger.addHandler(default_handler) logger.setLevel(logging.DEBUG) def set_fmt(fmt=default_fmt): global defaut_handler default_handler.setFormatter(fmt) def set_root_level(level): global logger
logging.basicConfig(level=logging.DEBUG, format='[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s', datefmt='%m-%d %H:%M', filename='spam.log', filemode='w') # define a Handler which writes INFO messages or higher to the sys.stderr console = RainbowLoggingHandler(sys.stdout) #logging.StreamHandler() # handler = RainbowLoggingHandler(sys.stdout) # get level from command input console.setLevel(log_level) formatter = logging.Formatter("[%(asctime)s] %(name)s %(funcName)s():%(lineno)d\t%(message)s") # tell the handler to use this format console.setFormatter(formatter) # add the handler to the root logger logging.getLogger('').addHandler(console) logger = logging.getLogger('nrk2013') # tell requests lib to chill out requests_log = logging.getLogger("requests") requests_log.setLevel(logging.WARNING) # Dette skulle hjelpe? # En ekte glob! request = False ### Hjelpefunksjoner def dispatch_on_template(soup, data, dictionary):
def main(instruments, mode, log_level, start_date=None, end_date=None): """ Algorithmic trading tool. """ # Make urllib3 logger more calm urllib3_logger = logging.getLogger('urllib3') urllib3_logger.setLevel(logging.CRITICAL) numeric_level = getattr(logging, log_level.upper(), None) if not isinstance(numeric_level, int): raise ValueError('Invalid log level: %s' % log_level) log_filename = "logs/pyfx_debug_{}-{}.log".format(strftime("%Y_%m_%d-%H_%M"), settings.ENVIRONMENT) logging.basicConfig(filename=log_filename, level=logging.DEBUG) logger = logging.getLogger('pyFx') formatter = logging.Formatter("[%(asctime)s/%(levelname)s] %(funcName)s():%(lineno)d\t%(message)s") handler = RainbowLoggingHandler(sys.stdout, color_funcName=('black', 'yellow', True)) handler.setFormatter(formatter) handler.setLevel(numeric_level) logger.addHandler(handler) start_date_ = start_date if start_date else settings.BACKTEST_START end_date_ = end_date if end_date else settings.BACKTEST_END BACKTEST_START = parser.parse(start_date_).replace(tzinfo=pytz.utc) BACKTEST_END = parser.parse(end_date_).replace(tzinfo=pytz.utc) if mode == 'backtest': api = oandapy.API( environment=settings.ENVIRONMENT, access_token=settings.ACCESS_TOKEN, ) broker = OandaBacktestBroker( api=api, account_id=settings.ACCOUNT_ID, initial_balance=decimal.Decimal(5000)) # Oanda 20:00, Local: 22:00, DailyFx: 16:00 clock = SimulatedClock( start=BACKTEST_START, stop=BACKTEST_END, interval=settings.CLOCK_INTERVAL, ) elif mode == 'live': api = oandapy.API( environment=settings.ENVIRONMENT, access_token=settings.ACCESS_TOKEN, ) clock = IntervalClock(interval=settings.CLOCK_INTERVAL) broker = OandaRealtimeBroker(api=api, account_id=settings.ACCOUNT_ID) else: raise NotImplementedError() # TODO Optimize load of instrument info instrument_list = set(instruments) for inst in instrument_list: inst.load(broker) # TODO We have to be able to instantiate strategies with custom args strategies = [settings.STRATEGY(instrument) for instrument in instrument_list] if mode == 'backtest': broker.init_backtest(BACKTEST_START, BACKTEST_END, strategies) pf = Portfolio(broker, mode='backtest') else: pf = Portfolio(broker, mode='live') controller = Controller(clock, broker, pf, strategies) controller.run_until_stopped()
class MultiProcessingLog(logging.Handler): def __init__(self, name, mode, maxsize, rotate): logging.Handler.__init__(self) #self._handler = RotatingFileHandler(name, mode, maxsize, rotate) formatter = logging.Formatter( "[%(asctime)s.%(msecs)03d] %(filename)16s Line %(lineno)3d %(funcName)s():\t %(message)s" ) self._handler = RainbowLoggingHandler(sys.stderr, color_funcName=('green', 'none', True)) self._handler.setFormatter(formatter) self.queue = multiprocessing.Queue(-1) t = threading.Thread(target=self.receive) t.daemon = True t.start() def setFormatter(self, fmt): logging.Handler.setFormatter(self, fmt) self._handler.setFormatter(fmt) def receive(self): while True: try: record = self.queue.get() self._handler.emit(record) except (KeyboardInterrupt, SystemExit): raise except EOFError: break except: traceback.print_exc(file=sys.stderr) def send(self, s): self.queue.put_nowait(s) def _format_record(self, record): # ensure that exc_info and args # have been stringified. Removes any chance of # unpickleable things inside and possibly reduces # message size sent over the pipe if record.args: record.msg = record.msg % record.args record.args = None if record.exc_info: dummy = self.format(record) record.exc_info = None return record def emit(self, record): try: s = self._format_record(record) self.send(s) except (KeyboardInterrupt, SystemExit): raise except: self.handleError(record) def close(self): self._handler.close() logging.Handler.close(self)