def init_logger(self, args):
level = logging.INFO
if args.verbose:
level = logging.VERBOSE
if args.debug:
level = logging.DEBUG
logging.basicConfig(format='%(asctime)s [%(levelname)s] %(message)s',
level=level)
Rthandler = RotatingFileHandler('arbitrage.log', maxBytes=100*1024*1024,backupCount=10)
Rthandler.setLevel(level)
formatter = logging.Formatter('%(asctime)-12s [%(levelname)s] %(message)s')
Rthandler.setFormatter(formatter)
logging.getLogger('').addHandler(Rthandler)
logging.getLogger("requests").setLevel(logging.WARNING)
logging.getLogger("urllib3").setLevel(logging.WARNING)
python类VERBOSE的实例源码
def checked(self, message, *args, **kws):
# checked messages have level VERBOSE, but when is requested the command
# rapydo check their level is increase to INFO
level = logging.VERBOSE
if hasattr(mem, 'action'):
if mem.action == "check":
level = logging.INFO
if self.isEnabledFor(level):
# Yes, logger takes its '*args' as 'args'.
# message = "\u2713 %s" % message
if self.disable_unicode:
message = "(CHECKED) %s" % message
elif self.colors_enabled:
message = "\033[0;32m\u2713\033[0m %s" % message
else:
message = "\u2713 %s" % message
self._log( # pylint:disable=protected-access
level, message, args, **kws
)
def prepare_logging():
global umap2_logger
global stdio_handler
if umap2_logger is None:
def add_debug_level(num, name):
def fn(self, message, *args, **kwargs):
if self.isEnabledFor(num):
self._log(num, message, args, **kwargs)
logging.addLevelName(num, name)
setattr(logging, name, num)
return fn
logging.Logger.verbose = add_debug_level(5, 'VERBOSE')
logging.Logger.always = add_debug_level(100, 'ALWAYS')
FORMAT = '[%(levelname)-6s] %(message)s'
stdio_handler = logging.StreamHandler()
stdio_handler.setLevel(logging.INFO)
formatter = logging.Formatter(FORMAT)
stdio_handler.setFormatter(formatter)
umap2_logger = logging.getLogger('umap2')
umap2_logger.addHandler(stdio_handler)
umap2_logger.setLevel(logging.VERBOSE)
return umap2_logger
def get_logger(self):
levels = {
0: logging.INFO,
1: logging.DEBUG,
# verbose is added by umap2.__init__ module
2: logging.VERBOSE,
}
verbose = self.options.get('--verbose', 0)
logger = logging.getLogger('umap2')
if verbose in levels:
set_default_handler_level(levels[verbose])
else:
set_default_handler_level(logging.VERBOSE)
if self.options.get('--quiet', False):
set_default_handler_level(logging.WARNING)
return logger
def fuzzy_search(self, *filters):
"""
Perform a "fuzzy" search that matches the given characters in the given order.
:param filters: The pattern(s) to search for.
:returns: The matched password names (a list of strings).
"""
matches = []
logger.verbose("Performing fuzzy search on %s (%s) ..",
pluralize(len(filters), "pattern"),
concatenate(map(repr, filters)))
patterns = list(map(create_fuzzy_pattern, filters))
for entry in self.entries:
if all(p.search(entry.name) for p in patterns):
matches.append(entry)
logger.log(logging.INFO if matches else logging.VERBOSE,
"Matched %s using fuzzy search.", pluralize(len(matches), "password"))
return matches
def simple_search(self, *keywords):
"""
Perform a simple search for case insensitive substring matches.
:param keywords: The string(s) to search for.
:returns: The matched password names (a generator of strings).
Only passwords whose names matches *all* of the given keywords are
returned.
"""
matches = []
keywords = [kw.lower() for kw in keywords]
logger.verbose("Performing simple search on %s (%s) ..",
pluralize(len(keywords), "keyword"),
concatenate(map(repr, keywords)))
for entry in self.entries:
normalized = entry.name.lower()
if all(kw in normalized for kw in keywords):
matches.append(entry)
logger.log(logging.INFO if matches else logging.VERBOSE,
"Matched %s using simple search.", pluralize(len(matches), "password"))
return matches
def test_log():
# No handlers by default
mylog = getLogger("test")
assert isinstance(mylog, logger.Logger)
assert mylog.name == "test"
assert len(mylog.handlers) == 0
pkglog = getLogger("nicfit")
assert isinstance(mylog, logger.Logger)
assert pkglog.name == "nicfit"
for log in [mylog, pkglog]:
assert(log.propagate)
assert(isinstance(log, logger.Logger))
with patch.object(log, "log") as mock_log:
log.verbose("Honey's Dead")
mock_log.assert_called_with(logging.VERBOSE, "Honey's Dead")
def init_logger(self, args):
level = logging.INFO
if args.verbose:
level = logging.VERBOSE
if args.debug:
level = logging.DEBUG
logging.basicConfig(format='%(asctime)s [%(levelname)s] %(message)s',
level=level)
Rthandler = RotatingFileHandler('arbitrage.log', maxBytes=100*1024*1024,backupCount=10)
Rthandler.setLevel(level)
formatter = logging.Formatter('%(asctime)-12s [%(levelname)s] %(message)s')
Rthandler.setFormatter(formatter)
logging.getLogger('').addHandler(Rthandler)
logging.getLogger("requests").setLevel(logging.WARNING)
logging.getLogger("urllib3").setLevel(logging.WARNING)
def cx(self, circuit, control_qubit, target_qubit, control, target):
if target in self.__coupling_map[control]:
logger.log(logging.VERBOSE, 'cx() - cnot: (%s, %s)', str(control), str(target))
circuit.cx(control_qubit, target_qubit)
elif control in self.__coupling_map[target]:
logger.log(logging.VERBOSE, 'cx() - inverse-cnot: (%s, %s)', str(control), str(target))
circuit.h(control_qubit)
circuit.h(target_qubit)
circuit.cx(target_qubit, control_qubit)
circuit.h(control_qubit)
circuit.h(target_qubit)
else:
logger.critical('cx() - Cannot connect qubit %s to qubit %s', str(control), str(target))
exit(3)
# place cnot gates based on the path created in create_path method
def place_cx_(self, circuit, quantum_r, oracle='11'):
if not oracle == '00':
logger.log(logging.VERBOSE, 'place_cx() - oracle != 00')
stop = self.__n_qubits // 2
for qubit in self.__connected:
if self.__connected[qubit] != -1:
if oracle == '11':
logger.log(logging.VERBOSE, 'place_cx() - oracle = 11')
self.cx(circuit, quantum_r[qubit], quantum_r[self.__connected[qubit]], qubit,
self.__connected[qubit])
elif oracle == '10':
logger.log(logging.VERBOSE, 'place_cx() - oracle = 10')
if stop > 0:
self.cx(circuit, quantum_r[qubit], quantum_r[self.__connected[qubit]], qubit,
self.__connected[qubit])
stop -= 1
# place Hadamard gates
def place_x(self, circuit, quantum_r):
sorted_c = sorted(self.__connected.items(), key=operator.itemgetter(0))
logger.log(logging.VERBOSE, 'place_x() - sorted_c:\n%s', str(sorted_c))
s_0 = self.__n_qubits // 2
i = 0
count = self.__n_qubits - 1
for qubit in sorted_c:
if count <= 0:
break
if i >= s_0:
circuit.x(quantum_r[qubit[0]])
else:
circuit.iden(quantum_r[qubit[0]])
i += 1
i = 0
for qubit in sorted_c:
if i >= s_0:
circuit.iden(quantum_r[qubit[0]])
else:
circuit.x(quantum_r[qubit[0]])
i += 1
# final measure
def inject_verbose_info(self):
logging.VERBOSE = 15
logging.verbose = lambda x: logging.log(logging.VERBOSE, x)
logging.addLevelName(logging.VERBOSE, "VERBOSE")
def logger_init(level = logging.INFO):
logging.basicConfig(format = '%(name)s: %(levelname)s: %(message)s', level = level)
logging.addLevelName(logging.VERBOSE, 'VERBOSE')
def log_verbose(self, message, *args, **kws):
if self.isEnabledFor(logging.VERBOSE):
self.log(logging.VERBOSE, message, *args, **kws)
def verbose(self, msg, *args, **kwargs):
'''Log \a msg at 'verbose' level, debug < verbose < info'''
self.log(logging.VERBOSE, msg, *args, **kwargs)
def verbose(self, message, *args, **kws):
# Yes, logger takes its '*args' as 'args'.
if self.isEnabledFor(VERBOSE):
self._log( # pylint:disable=protected-access
VERBOSE, message, args, **kws
)
def checked_simple(self, message, *args, **kws):
# checked messages have level VERBOSE, but when is requested the command
# rapydo check their level is increase to INFO
level = logging.VERBOSE
if hasattr(mem, 'action'):
if mem.action == "check":
level = logging.INFO
if self.isEnabledFor(level):
message = "(CHECKED)\t%s" % message
self._log( # pylint:disable=protected-access
level, message, args, **kws
)
arbitrage.py 文件源码
项目:Bitcoin-arbitrage---opportunity-detector
作者: yoshi717
项目源码
文件源码
阅读 33
收藏 0
点赞 0
评论 0
def inject_verbose_info(self):
logging.VERBOSE = 15
logging.verbose = lambda x: logging.log(logging.VERBOSE, x)
logging.addLevelName(logging.VERBOSE, "VERBOSE")
arbitrage.py 文件源码
项目:Bitcoin-arbitrage---opportunity-detector
作者: yoshi717
项目源码
文件源码
阅读 39
收藏 0
点赞 0
评论 0
def init_logger(self, args):
level = logging.INFO
if args.verbose:
level = logging.VERBOSE
if args.debug:
level = logging.DEBUG
logging.basicConfig(format='%(asctime)s [%(levelname)s] %(message)s',
level=level)
def instantiate( cls, streamType = "SCREEN", logLevel = "INFO" ):
try:
logging.VERBOSE = 5
logging.addLevelName(logging.VERBOSE, "VERBOSE")
logging.Logger.verbose = lambda inst, msg, *args, **kwargs: inst.log(logging.VERBOSE, msg, *args, **kwargs)
logging.verbose = lambda msg, *args, **kwargs: logging.log(logging.VERBOSE, msg, *args, **kwargs)
cls.logger = logging.getLogger()
if logLevel not in logging._levelNames:
raise Exception( 'Invalid file level' )
cls.logger.setLevel( logging._levelNames[logLevel] )
streamType = app.config['STREAMTYPE']
if streamType == "SCREEN":
stream = logging.StreamHandler()
else:
stream = logging.FileHandler( app.config['LOGFILE'] )
formatter = logging.Formatter( '[%(levelname)-7s - %(asctime)s] %(message)s' )
stream.setFormatter( formatter )
cls.logger.addHandler( stream )
except Exception, e:
print( 'Unable to get/set log configurations. Error: %s'%( e ) )
cls.logger = None
##
# Records a message in a file and/or displays it in the screen.
# @param level - String containing the name of the log message.
# @param message - String containing the message to be recorded.
#
def verbose( cls, message ):
cls.log("VERBOSE", message, Log.getCallers( inspect.stack() ))
##
# Gets the data about the caller of the log method.
# @param stack Array containing the system calling stack.
# @return Array containing the caller class name and the caller method, respectively.
#
def test_logLevelArguments():
p = ArgumentParser(add_log_args=True)
# Invalids
for args, Exc in [(["-l"], SystemExit), (["--log-level"], SystemExit),
(["-l", "Vision-InTheBlinkOfAnEye"], ValueError),
(["-l", "debug:TheOnlyOne"], ValueError),
]:
with pytest.raises(Exc):
p.parse_args(args)
# Level sets on root logger.
for args, level in [(["-l", "debug"], logging.DEBUG),
(["-lerror"], logging.ERROR),
(["--log-level", "warning"], logging.WARN),
(["--log-level=critical"], logging.CRITICAL),
(["--log-level=verbose"], logging.VERBOSE),
]:
p.parse_args(args)
logger = getLogger()
assert logger.getEffectiveLevel() == level
# Level sets on other logger.
for args, level, log in [
(["-l", "Venom:debug"], logging.DEBUG, "Venom"),
(["-lWatain:eRroR"], logging.ERROR, "Watain"),
(["--log-level", "l1:WARNING"], logging.WARN, "l1"),
(["--log-level=nicfit:critical"], logging.CRITICAL, "nicfit"),
(["--log-level=eyeD3:verbose"], logging.VERBOSE, "eyeD3"),
]:
logger = getLogger(log)
with patch.object(logger, "setLevel") as mock_log:
p.parse_args(args)
mock_log.assert_called_with(level)
def verbose(self, msg, *args, **kwargs):
"""Log msg at 'verbose' level, debug < verbose < info"""
self.log(logging.VERBOSE, msg, *args, **kwargs)
def inject_verbose_info(self):
logging.VERBOSE = 15
logging.verbose = lambda x: logging.log(logging.VERBOSE, x)
logging.addLevelName(logging.VERBOSE, "VERBOSE")
def __init__(self):
logging.StreamHandler.__init__(self)
logging.addLevelName(logging.VERBOSE, "VERBOSE")
formatter = logging.Formatter('%(filename)s - %(levelname)s - %(message)s')
self.setFormatter(formatter)
def verbose(self, msg, *args, **kwargs):
'''Log \a msg at 'verbose' level, debug < verbose < info'''
self.log(logging.VERBOSE, msg, *args, **kwargs)
def test_verbose_hack(self):
self.logger.verbose("foo")
logging.verbose("foo")
self.assertEqual(logging.VERBOSE, 15)
if six.PY2:
# There is no _levelNames attribute in Python 3
self.assertTrue("VERBOSE" in logging._levelNames)
self.assertEqual(logging.getLevelName(15), "VERBOSE")
def verbose(self, msg, *args, **kwargs):
"""
Log 'msg % args' with severity 'VERBOSE'.
To pass exception information, use the keyword argument exc_info with
a true value, e.g.
logger.info("Houston, we have a %s", "interesting problem", exc_info=1)
"""
if self.manager.disable >= logging.VERBOSE:
return
if logging.VERBOSE >= self.getEffectiveLevel():
self._log(*(logging.VERBOSE, msg, args), **kwargs)
def verbose(msg, *args, **kwargs):
"""
Log a message with severity 'VERBOSE' on the root logger.
"""
if len(logging.root.handlers) == 0:
logging.basicConfig()
logging.root.verbose(*((msg, ) + args), **kwargs)
def log_verbose(self, msg, *args, **kwargs):
self.__log(logging.VERBOSE, msg, *args, **kwargs)