def _dequeue(self, parent):
self._ttl_timeout = gevent.Timeout.start_new(timeout=self._ttl, exception=ActorTTLError)
self._max_idle_timeout = gevent.Timeout.start_new(timeout=self._max_idle, exception=ActorMaxIdleError)
self._stopped = False
self._crashed = False
try:
while True:
try:
for task in self._mailbox:
gevent.idle()
self._max_idle_timeout.close()
if self._max_idle:
self._logger.trace("{me} has canceled timeout of {max_idle} seconds".format(me=self, max_idle=self._max_idle))
if isinstance(task, Task) and not task.canceled:
self._logger.trace("{me} took {task} from mailbox".format(me=self, task=task))
self._handle(task)
elif task is self._poisoned_pill:
self._logger.trace("{me} is processing the poisoned pill.".format(me=self))
raise ActorStoppedError
elif task is self._ping_pill:
self._logger.debug("{me} is processing a ping.".format(me=self))
elif isinstance(task, Task) and task.canceled:
self._logger.trace("{me} took canceled {task} from mailbox, dismissing".format(me=self, task=task))
continue
self._max_idle_timeout = gevent.Timeout.start_new(timeout=self._max_idle, exception=ActorMaxIdleError)
except ActorMaxIdleError as e:
self._logger.trace("{me} has reached max_idle timeout of {sec} seconds.".format(me=self, sec=self._max_idle))
self.stop(wait=False) # FIXME!!!!
except ActorTTLError as e:
self._logger.trace("{me} has reached ttl timeout of {sec} seconds.".format(me=self, sec=self._ttl))
self.stop(wait=False) # FIXME!!!!
except ActorStoppedError as e:
self._stopped = True
except Exception as e:
self._stopped = True
self._crashed = True
formatted_exc = "".join(better_exceptions.format_exception(*sys.exc_info()))
self._logger.error(("{me} crashed with:\n{exc}").format(me=self, exc=formatted_exc))
finally:
self._logger.trace("{me} is executing on_stop() handler".format(me=self))
try:
self.on_stop()
except Exception as err:
self._crashed = True
formatted_exc = "".join(better_exceptions.format_exception(*sys.exc_info()))
self._logger.error(("{me} crashed while executing on_stop() handler with:\n{exc}").format(me=self, exc=formatted_exc))
self._logger.trace("{me} has finished on_stop() handler".format(me=self))
self._ttl_timeout.close()
self._max_idle_timeout.close()
if hasattr(self, "_parent"):
self._parent._handle_child(self, "crashed" if self._crashed else "stopped")
def exception_thunk(
self,
exc_tuple: Tuple[Any, ...] = None,
filename: Optional[str] = None,
tb_offset: Optional[int] = None,
exception_only: bool = False,
**kwargs: Any
):
notuple = False
if exc_tuple is None:
notuple = True
exc_tuple = sys.exc_info()
etype, value, tb = self._get_exc_info(exc_tuple)
use_better = not any(
[filename, tb_offset, exception_only, issubclass(etype, SyntaxError)]
)
if use_better:
return print(*better_exceptions.format_exception(etype, value, tb), sep="")
return old_show_tb(
None if notuple else exc_tuple,
filename,
tb_offset,
exception_only,
**kwargs
)
def patched_handle_exception(self, e):
"""
a new handler for ptpython repl exceptions
it will call excepthook after ommitting all this framework's calls from traceback
for the original, see ptpython.repl.PythonInput._handle_exception
"""
output = self.app.output
t, v, tb = sys.exc_info()
# Required for pdb.post_mortem() to work.
sys.last_type, sys.last_value, sys.last_traceback = t, v, tb
# loop until getting actual traceback
last_stdin_tb = tb
while tb:
if tb.tb_frame.f_code.co_filename == "<stdin>":
last_stdin_tb = tb
tb = tb.tb_next
# except hook does not work as expected
sys.excepthook(t, v, last_stdin_tb)
# just print formatted exception for now
formatted = better_exceptions.format_exception(t, v, last_stdin_tb)
print_formatted_text(ANSI(formatted))
output.write("%s\n" % e)
output.flush()
def _get_stack(exception, engine="better_exceptions"):
assert engine in ["stackprinter", "better_exceptions"]
if engine == "better_exceptions":
return "".join(better_exceptions.format_exception(*exception))
elif engine == "stackprinter":
return stackprinter.format(exception)
def main(argv: Optional[List[str]] = None) -> int:
parser = argument_parser()
args = parser.parse_args(argv)
try:
query = parse(args.query, "fasta")
reference = parse(args.reference, "fasta")
print(orthoani(query, reference, threads=args.jobs))
return 0
except KeyboardInterrupt:
print("Interrupted.", file=sys.stderr)
return -signal.SIGINT
except Exception as e:
if args.traceback:
print(
"".join(
better_exceptions.format_exception(type(e), e,
e.__traceback__)),
file=sys.stderr,
)
else:
print(e, file=sys.stderr)
return typing.cast(int, getattr(e, "errno", 1))
def get_logger(name,
path="",
log_level="DEBUG",
is_write_to_file=False,
is_write_to_stdout=True):
"""
@summary: 获取log
---------
@param name: log名
@param path: log文件存储路径 如 D://xxx.log
@param log_level: log等级 CRITICAL/ERROR/WARNING/INFO/DEBUG
@param is_write_to_file: 是否写入到文件 默认否
---------
@result:
"""
name = name.split(os.sep)[-1].split(".")[0] # 取文件名
logger = logging.getLogger(name)
logger.setLevel(log_level)
formatter = logging.Formatter(LOG_FORMAT)
if PRINT_EXCEPTION_DETAILS:
formatter.formatException = lambda exc_info: format_exception(*exc_info
)
# 定义一个RotatingFileHandler，最多备份5个日志文件，每个日志文件最大10M
if is_write_to_file:
if path and not os.path.exists(os.path.dirname(path)):
os.makedirs(os.path.dirname(path))
rf_handler = RotatingFileHandler(path,
mode="w",
maxBytes=10 * 1024 * 1024,
backupCount=20,
encoding="utf8")
rf_handler.setFormatter(formatter)
logger.addHandler(rf_handler)
if is_write_to_stdout:
stream_handler = logging.StreamHandler()
stream_handler.stream = sys.stdout
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
_handler_list = []
_handler_name_list = []
# 检查是否存在重复handler
for _handler in logger.handlers:
if str(_handler) not in _handler_name_list:
_handler_name_list.append(str(_handler))
_handler_list.append(_handler)
logger.handlers = _handler_list
return logger
def build_exception_details():
import sys
import better_exceptions
et, ev, tb = sys.exc_info()
return ExceptionDetails(
**{
'errorType':
et.__name__,
'errorMessage':
str(ev),
'message':
"An unexpected exception has occurred",
'help':
"\n".join(better_exceptions.format_exception(*sys.exc_info()))
})
def _execute(self, method, args, kwargs):
response = {}
try:
response["result"] = method(*args, **kwargs)
except TypeError as e:
response["error"] = str(e)
response["error_type"] = GedisErrorTypes.BAD_REQUEST.value
except:
ttype, tvalue, tb = sys.exc_info()
response["error"] = better_exceptions.format_exception(
ttype, tvalue, tb)
response["error_type"] = GedisErrorTypes.ACTOR_ERROR.value
return response
def spawn_child(self, target, name=None, msg=None):
if not name:
name = "{tpl}-{target}".format(tpl=self._worker_name_tpl
or str(self._worker_cls),
target=target)
try:
kwargs = self._worker_args_func(
msg) if msg and self._worker_args_func else {}
child = self._worker_cls(name=name, target=target, **kwargs)
except Exception as err:
formatted_exc = better_exceptions.format_exception(*sys.exc_info())
self._logger.error(
"Spawning child failed with {e}".format(e=formatted_exc))
raise SpawningChildFailedError(err)
child._target = target
self.register_child(child, target)
return child
def patch():
import logging
from better_exceptions import format_exception
logging_format_exception = lambda exc_info: format_exception(*exc_info)
if hasattr(logging, '_defaultFormatter'):
logging._defaultFormatter.format_exception = logging_format_exception
patchables = [
handler() for handler in logging._handlerList
if isinstance(handler(), StreamHandler)
]
patchables = [
handler for handler in patchables if handler.stream == sys.stderr
]
patchables = [
handler for handler in patchables if handler.formatter is not None
]
for handler in patchables:
handler.formatter.formatException = logging_format_exception
def formatException(self, ei):
return format_exception(*ei)
def get_logger(
name=None,
path=None,
log_level=None,
is_write_to_console=None,
is_write_to_file=None,
color=None,
mode=None,
max_bytes=None,
backup_count=None,
encoding=None,
):
"""
@summary: 获取log
---------
@param name: log名
@param path: log文件存储路径 如 D://xxx.log
@param log_level: log等级 CRITICAL/ERROR/WARNING/INFO/DEBUG
@param is_write_to_console: 是否输出到控制台
@param is_write_to_file: 是否写入到文件 默认否
@param color：是否有颜色
@param mode：写文件模式
@param max_bytes： 每个日志文件的最大字节数
@param backup_count：日志文件保留数量
@param encoding：日志文件编码
---------
@result:
"""
# 加载setting里最新的值
name = name or setting.LOG_NAME
path = path or setting.LOG_PATH
log_level = log_level or setting.LOG_LEVEL
is_write_to_console = (is_write_to_console if is_write_to_console
is not None else setting.LOG_IS_WRITE_TO_CONSOLE)
is_write_to_file = (is_write_to_file if is_write_to_file is not None else
setting.LOG_IS_WRITE_TO_FILE)
color = color if color is not None else setting.LOG_COLOR
mode = mode or setting.LOG_MODE
max_bytes = max_bytes or setting.LOG_MAX_BYTES
backup_count = backup_count or setting.LOG_BACKUP_COUNT
encoding = encoding or setting.LOG_ENCODING
# logger 配置
name = name.split(os.sep)[-1].split(".")[0] # 取文件名
logger = logging.getLogger(name)
logger.setLevel(log_level)
formatter = logging.Formatter(setting.LOG_FORMAT)
if setting.PRINT_EXCEPTION_DETAILS:
formatter.formatException = lambda exc_info: format_exception(*exc_info
)
# 定义一个RotatingFileHandler，最多备份5个日志文件，每个日志文件最大10M
if is_write_to_file:
if path and not os.path.exists(os.path.dirname(path)):
os.makedirs(os.path.dirname(path))
rf_handler = RotatingFileHandler(
path,
mode=mode,
max_bytes=max_bytes,
backup_count=backup_count,
encoding=encoding,
)
rf_handler.setFormatter(formatter)
logger.addHandler(rf_handler)
if color and is_write_to_console:
loguru_handler = InterceptHandler()
loguru_handler.setFormatter(formatter)
# logging.basicConfig(handlers=[loguru_handler], level=0)
logger.addHandler(loguru_handler)
elif is_write_to_console:
stream_handler = logging.StreamHandler()
stream_handler.stream = sys.stdout
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
_handler_list = []
_handler_name_list = []
# 检查是否存在重复handler
for _handler in logger.handlers:
if str(_handler) not in _handler_name_list:
_handler_name_list.append(str(_handler))
_handler_list.append(_handler)
logger.handlers = _handler_list
return logger
def get_traceback():
tb = format_exception(*sys.exc_info())
if isinstance(tb, list):
tb = "".join(tb)
return tb
def log_exception(args: threading.ExceptHookArgs):
description = f"Failure in {args.thread.name}: {repr(args.exc_value)}"
FAILURES.append(description)
LOG.error(description + "\n" + "\n".join(
better_exceptions.format_exception(args.exc_type, args.exc_value,
args.exc_traceback)))
# -*- encoding: utf-8 -*-
import logging
import better_exceptions
from better_exceptions import format_exception
logger = logging.getLogger()
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
formatter.formatException = lambda exc_info: format_exception(*exc_info)
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.DEBUG)
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
file_handler = logging.FileHandler("test.log")
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
def get_student_infos(logs):
student_infos = []
for log in logs:
name, catgory, grade = log.split(' ')
student_infos.append({
'name': name,
def patch(self, err, test):
lines = better_exceptions.format_exception(*err)
if sys.version_info[0] == 2:
return u"".join(lines).encode("utf-8")
else:
return u"".join(lines)
