mirror of
https://github.com/RustPython/RustPython.git
synced 2026-06-02 19:39:49 +09:00
Merge pull request #1130 from RustPython/re-kung-fu
Add default argument to dict.pop.
This commit is contained in:
coolreader18
GitHub
2115
Lib/logging/__init__.py
Normal file
2115
Lib/logging/__init__.py
Normal file
File diff suppressed because it is too large
Load Diff
935
Lib/logging/config.py
Normal file
935
Lib/logging/config.py
Normal file
@@ -0,0 +1,935 @@
|
||||
# Copyright 2001-2016 by Vinay Sajip. All Rights Reserved.
|
||||
#
|
||||
# Permission to use, copy, modify, and distribute this software and its
|
||||
# documentation for any purpose and without fee is hereby granted,
|
||||
# provided that the above copyright notice appear in all copies and that
|
||||
# both that copyright notice and this permission notice appear in
|
||||
# supporting documentation, and that the name of Vinay Sajip
|
||||
# not be used in advertising or publicity pertaining to distribution
|
||||
# of the software without specific, written prior permission.
|
||||
# VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
||||
# ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
|
||||
# VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
||||
# ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
|
||||
# IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
|
||||
# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
"""
|
||||
Configuration functions for the logging package for Python. The core package
|
||||
is based on PEP 282 and comments thereto in comp.lang.python, and influenced
|
||||
by Apache's log4j system.
|
||||
|
||||
Copyright (C) 2001-2016 Vinay Sajip. All Rights Reserved.
|
||||
|
||||
To use, simply 'import logging' and log away!
|
||||
"""
|
||||
|
||||
import errno
|
||||
import io
|
||||
import logging
|
||||
import logging.handlers
|
||||
import re
|
||||
import struct
|
||||
import sys
|
||||
import threading
|
||||
import traceback
|
||||
|
||||
from socketserver import ThreadingTCPServer, StreamRequestHandler
|
||||
|
||||
|
||||
DEFAULT_LOGGING_CONFIG_PORT = 9030
|
||||
|
||||
RESET_ERROR = errno.ECONNRESET
|
||||
|
||||
#
|
||||
# The following code implements a socket listener for on-the-fly
|
||||
# reconfiguration of logging.
|
||||
#
|
||||
# _listener holds the server object doing the listening
|
||||
_listener = None
|
||||
|
||||
def fileConfig(fname, defaults=None, disable_existing_loggers=True):
|
||||
"""
|
||||
Read the logging configuration from a ConfigParser-format file.
|
||||
|
||||
This can be called several times from an application, allowing an end user
|
||||
the ability to select from various pre-canned configurations (if the
|
||||
developer provides a mechanism to present the choices and load the chosen
|
||||
configuration).
|
||||
"""
|
||||
import configparser
|
||||
|
||||
if isinstance(fname, configparser.RawConfigParser):
|
||||
cp = fname
|
||||
else:
|
||||
cp = configparser.ConfigParser(defaults)
|
||||
if hasattr(fname, 'readline'):
|
||||
cp.read_file(fname)
|
||||
else:
|
||||
cp.read(fname)
|
||||
|
||||
formatters = _create_formatters(cp)
|
||||
|
||||
# critical section
|
||||
logging._acquireLock()
|
||||
try:
|
||||
_clearExistingHandlers()
|
||||
|
||||
# Handlers add themselves to logging._handlers
|
||||
handlers = _install_handlers(cp, formatters)
|
||||
_install_loggers(cp, handlers, disable_existing_loggers)
|
||||
finally:
|
||||
logging._releaseLock()
|
||||
|
||||
|
||||
def _resolve(name):
|
||||
"""Resolve a dotted name to a global object."""
|
||||
name = name.split('.')
|
||||
used = name.pop(0)
|
||||
found = __import__(used)
|
||||
for n in name:
|
||||
used = used + '.' + n
|
||||
try:
|
||||
found = getattr(found, n)
|
||||
except AttributeError:
|
||||
__import__(used)
|
||||
found = getattr(found, n)
|
||||
return found
|
||||
|
||||
def _strip_spaces(alist):
|
||||
return map(str.strip, alist)
|
||||
|
||||
def _create_formatters(cp):
|
||||
"""Create and return formatters"""
|
||||
flist = cp["formatters"]["keys"]
|
||||
if not len(flist):
|
||||
return {}
|
||||
flist = flist.split(",")
|
||||
flist = _strip_spaces(flist)
|
||||
formatters = {}
|
||||
for form in flist:
|
||||
sectname = "formatter_%s" % form
|
||||
fs = cp.get(sectname, "format", raw=True, fallback=None)
|
||||
dfs = cp.get(sectname, "datefmt", raw=True, fallback=None)
|
||||
stl = cp.get(sectname, "style", raw=True, fallback='%')
|
||||
c = logging.Formatter
|
||||
class_name = cp[sectname].get("class")
|
||||
if class_name:
|
||||
c = _resolve(class_name)
|
||||
f = c(fs, dfs, stl)
|
||||
formatters[form] = f
|
||||
return formatters
|
||||
|
||||
|
||||
def _install_handlers(cp, formatters):
|
||||
"""Install and return handlers"""
|
||||
hlist = cp["handlers"]["keys"]
|
||||
if not len(hlist):
|
||||
return {}
|
||||
hlist = hlist.split(",")
|
||||
hlist = _strip_spaces(hlist)
|
||||
handlers = {}
|
||||
fixups = [] #for inter-handler references
|
||||
for hand in hlist:
|
||||
section = cp["handler_%s" % hand]
|
||||
klass = section["class"]
|
||||
fmt = section.get("formatter", "")
|
||||
try:
|
||||
klass = eval(klass, vars(logging))
|
||||
except (AttributeError, NameError):
|
||||
klass = _resolve(klass)
|
||||
args = section.get("args", '()')
|
||||
args = eval(args, vars(logging))
|
||||
kwargs = section.get("kwargs", '{}')
|
||||
kwargs = eval(kwargs, vars(logging))
|
||||
h = klass(*args, **kwargs)
|
||||
if "level" in section:
|
||||
level = section["level"]
|
||||
h.setLevel(level)
|
||||
if len(fmt):
|
||||
h.setFormatter(formatters[fmt])
|
||||
if issubclass(klass, logging.handlers.MemoryHandler):
|
||||
target = section.get("target", "")
|
||||
if len(target): #the target handler may not be loaded yet, so keep for later...
|
||||
fixups.append((h, target))
|
||||
handlers[hand] = h
|
||||
#now all handlers are loaded, fixup inter-handler references...
|
||||
for h, t in fixups:
|
||||
h.setTarget(handlers[t])
|
||||
return handlers
|
||||
|
||||
def _handle_existing_loggers(existing, child_loggers, disable_existing):
|
||||
"""
|
||||
When (re)configuring logging, handle loggers which were in the previous
|
||||
configuration but are not in the new configuration. There's no point
|
||||
deleting them as other threads may continue to hold references to them;
|
||||
and by disabling them, you stop them doing any logging.
|
||||
|
||||
However, don't disable children of named loggers, as that's probably not
|
||||
what was intended by the user. Also, allow existing loggers to NOT be
|
||||
disabled if disable_existing is false.
|
||||
"""
|
||||
root = logging.root
|
||||
for log in existing:
|
||||
logger = root.manager.loggerDict[log]
|
||||
if log in child_loggers:
|
||||
logger.level = logging.NOTSET
|
||||
logger.handlers = []
|
||||
logger.propagate = True
|
||||
else:
|
||||
logger.disabled = disable_existing
|
||||
|
||||
def _install_loggers(cp, handlers, disable_existing):
|
||||
"""Create and install loggers"""
|
||||
|
||||
# configure the root first
|
||||
llist = cp["loggers"]["keys"]
|
||||
llist = llist.split(",")
|
||||
llist = list(_strip_spaces(llist))
|
||||
llist.remove("root")
|
||||
section = cp["logger_root"]
|
||||
root = logging.root
|
||||
log = root
|
||||
if "level" in section:
|
||||
level = section["level"]
|
||||
log.setLevel(level)
|
||||
for h in root.handlers[:]:
|
||||
root.removeHandler(h)
|
||||
hlist = section["handlers"]
|
||||
if len(hlist):
|
||||
hlist = hlist.split(",")
|
||||
hlist = _strip_spaces(hlist)
|
||||
for hand in hlist:
|
||||
log.addHandler(handlers[hand])
|
||||
|
||||
#and now the others...
|
||||
#we don't want to lose the existing loggers,
|
||||
#since other threads may have pointers to them.
|
||||
#existing is set to contain all existing loggers,
|
||||
#and as we go through the new configuration we
|
||||
#remove any which are configured. At the end,
|
||||
#what's left in existing is the set of loggers
|
||||
#which were in the previous configuration but
|
||||
#which are not in the new configuration.
|
||||
existing = list(root.manager.loggerDict.keys())
|
||||
#The list needs to be sorted so that we can
|
||||
#avoid disabling child loggers of explicitly
|
||||
#named loggers. With a sorted list it is easier
|
||||
#to find the child loggers.
|
||||
existing.sort()
|
||||
#We'll keep the list of existing loggers
|
||||
#which are children of named loggers here...
|
||||
child_loggers = []
|
||||
#now set up the new ones...
|
||||
for log in llist:
|
||||
section = cp["logger_%s" % log]
|
||||
qn = section["qualname"]
|
||||
propagate = section.getint("propagate", fallback=1)
|
||||
logger = logging.getLogger(qn)
|
||||
if qn in existing:
|
||||
i = existing.index(qn) + 1 # start with the entry after qn
|
||||
prefixed = qn + "."
|
||||
pflen = len(prefixed)
|
||||
num_existing = len(existing)
|
||||
while i < num_existing:
|
||||
if existing[i][:pflen] == prefixed:
|
||||
child_loggers.append(existing[i])
|
||||
i += 1
|
||||
existing.remove(qn)
|
||||
if "level" in section:
|
||||
level = section["level"]
|
||||
logger.setLevel(level)
|
||||
for h in logger.handlers[:]:
|
||||
logger.removeHandler(h)
|
||||
logger.propagate = propagate
|
||||
logger.disabled = 0
|
||||
hlist = section["handlers"]
|
||||
if len(hlist):
|
||||
hlist = hlist.split(",")
|
||||
hlist = _strip_spaces(hlist)
|
||||
for hand in hlist:
|
||||
logger.addHandler(handlers[hand])
|
||||
|
||||
#Disable any old loggers. There's no point deleting
|
||||
#them as other threads may continue to hold references
|
||||
#and by disabling them, you stop them doing any logging.
|
||||
#However, don't disable children of named loggers, as that's
|
||||
#probably not what was intended by the user.
|
||||
#for log in existing:
|
||||
# logger = root.manager.loggerDict[log]
|
||||
# if log in child_loggers:
|
||||
# logger.level = logging.NOTSET
|
||||
# logger.handlers = []
|
||||
# logger.propagate = 1
|
||||
# elif disable_existing_loggers:
|
||||
# logger.disabled = 1
|
||||
_handle_existing_loggers(existing, child_loggers, disable_existing)
|
||||
|
||||
|
||||
def _clearExistingHandlers():
|
||||
"""Clear and close existing handlers"""
|
||||
logging._handlers.clear()
|
||||
logging.shutdown(logging._handlerList[:])
|
||||
del logging._handlerList[:]
|
||||
|
||||
|
||||
IDENTIFIER = re.compile('^[a-z_][a-z0-9_]*$', re.I)
|
||||
|
||||
|
||||
def valid_ident(s):
|
||||
m = IDENTIFIER.match(s)
|
||||
if not m:
|
||||
raise ValueError('Not a valid Python identifier: %r' % s)
|
||||
return True
|
||||
|
||||
|
||||
class ConvertingMixin(object):
|
||||
"""For ConvertingXXX's, this mixin class provides common functions"""
|
||||
|
||||
def convert_with_key(self, key, value, replace=True):
|
||||
result = self.configurator.convert(value)
|
||||
#If the converted value is different, save for next time
|
||||
if value is not result:
|
||||
if replace:
|
||||
self[key] = result
|
||||
if type(result) in (ConvertingDict, ConvertingList,
|
||||
ConvertingTuple):
|
||||
result.parent = self
|
||||
result.key = key
|
||||
return result
|
||||
|
||||
def convert(self, value):
|
||||
result = self.configurator.convert(value)
|
||||
if value is not result:
|
||||
if type(result) in (ConvertingDict, ConvertingList,
|
||||
ConvertingTuple):
|
||||
result.parent = self
|
||||
return result
|
||||
|
||||
|
||||
# The ConvertingXXX classes are wrappers around standard Python containers,
|
||||
# and they serve to convert any suitable values in the container. The
|
||||
# conversion converts base dicts, lists and tuples to their wrapped
|
||||
# equivalents, whereas strings which match a conversion format are converted
|
||||
# appropriately.
|
||||
#
|
||||
# Each wrapper should have a configurator attribute holding the actual
|
||||
# configurator to use for conversion.
|
||||
|
||||
class ConvertingDict(dict, ConvertingMixin):
|
||||
"""A converting dictionary wrapper."""
|
||||
|
||||
def __getitem__(self, key):
|
||||
value = dict.__getitem__(self, key)
|
||||
return self.convert_with_key(key, value)
|
||||
|
||||
def get(self, key, default=None):
|
||||
value = dict.get(self, key, default)
|
||||
return self.convert_with_key(key, value)
|
||||
|
||||
def pop(self, key, default=None):
|
||||
value = dict.pop(self, key, default)
|
||||
return self.convert_with_key(key, value, replace=False)
|
||||
|
||||
class ConvertingList(list, ConvertingMixin):
|
||||
"""A converting list wrapper."""
|
||||
def __getitem__(self, key):
|
||||
value = list.__getitem__(self, key)
|
||||
return self.convert_with_key(key, value)
|
||||
|
||||
def pop(self, idx=-1):
|
||||
value = list.pop(self, idx)
|
||||
return self.convert(value)
|
||||
|
||||
class ConvertingTuple(tuple, ConvertingMixin):
|
||||
"""A converting tuple wrapper."""
|
||||
def __getitem__(self, key):
|
||||
value = tuple.__getitem__(self, key)
|
||||
# Can't replace a tuple entry.
|
||||
return self.convert_with_key(key, value, replace=False)
|
||||
|
||||
class BaseConfigurator(object):
|
||||
"""
|
||||
The configurator base class which defines some useful defaults.
|
||||
"""
|
||||
|
||||
CONVERT_PATTERN = re.compile(r'^(?P<prefix>[a-z]+)://(?P<suffix>.*)$')
|
||||
|
||||
WORD_PATTERN = re.compile(r'^\s*(\w+)\s*')
|
||||
DOT_PATTERN = re.compile(r'^\.\s*(\w+)\s*')
|
||||
INDEX_PATTERN = re.compile(r'^\[\s*(\w+)\s*\]\s*')
|
||||
DIGIT_PATTERN = re.compile(r'^\d+$')
|
||||
|
||||
value_converters = {
|
||||
'ext' : 'ext_convert',
|
||||
'cfg' : 'cfg_convert',
|
||||
}
|
||||
|
||||
# We might want to use a different one, e.g. importlib
|
||||
importer = staticmethod(__import__)
|
||||
|
||||
def __init__(self, config):
|
||||
self.config = ConvertingDict(config)
|
||||
self.config.configurator = self
|
||||
|
||||
def resolve(self, s):
|
||||
"""
|
||||
Resolve strings to objects using standard import and attribute
|
||||
syntax.
|
||||
"""
|
||||
name = s.split('.')
|
||||
used = name.pop(0)
|
||||
try:
|
||||
found = self.importer(used)
|
||||
for frag in name:
|
||||
used += '.' + frag
|
||||
try:
|
||||
found = getattr(found, frag)
|
||||
except AttributeError:
|
||||
self.importer(used)
|
||||
found = getattr(found, frag)
|
||||
return found
|
||||
except ImportError:
|
||||
e, tb = sys.exc_info()[1:]
|
||||
v = ValueError('Cannot resolve %r: %s' % (s, e))
|
||||
v.__cause__, v.__traceback__ = e, tb
|
||||
raise v
|
||||
|
||||
def ext_convert(self, value):
|
||||
"""Default converter for the ext:// protocol."""
|
||||
return self.resolve(value)
|
||||
|
||||
def cfg_convert(self, value):
|
||||
"""Default converter for the cfg:// protocol."""
|
||||
rest = value
|
||||
m = self.WORD_PATTERN.match(rest)
|
||||
if m is None:
|
||||
raise ValueError("Unable to convert %r" % value)
|
||||
else:
|
||||
rest = rest[m.end():]
|
||||
d = self.config[m.groups()[0]]
|
||||
#print d, rest
|
||||
while rest:
|
||||
m = self.DOT_PATTERN.match(rest)
|
||||
if m:
|
||||
d = d[m.groups()[0]]
|
||||
else:
|
||||
m = self.INDEX_PATTERN.match(rest)
|
||||
if m:
|
||||
idx = m.groups()[0]
|
||||
if not self.DIGIT_PATTERN.match(idx):
|
||||
d = d[idx]
|
||||
else:
|
||||
try:
|
||||
n = int(idx) # try as number first (most likely)
|
||||
d = d[n]
|
||||
except TypeError:
|
||||
d = d[idx]
|
||||
if m:
|
||||
rest = rest[m.end():]
|
||||
else:
|
||||
raise ValueError('Unable to convert '
|
||||
'%r at %r' % (value, rest))
|
||||
#rest should be empty
|
||||
return d
|
||||
|
||||
def convert(self, value):
|
||||
"""
|
||||
Convert values to an appropriate type. dicts, lists and tuples are
|
||||
replaced by their converting alternatives. Strings are checked to
|
||||
see if they have a conversion format and are converted if they do.
|
||||
"""
|
||||
if not isinstance(value, ConvertingDict) and isinstance(value, dict):
|
||||
value = ConvertingDict(value)
|
||||
value.configurator = self
|
||||
elif not isinstance(value, ConvertingList) and isinstance(value, list):
|
||||
value = ConvertingList(value)
|
||||
value.configurator = self
|
||||
elif not isinstance(value, ConvertingTuple) and\
|
||||
isinstance(value, tuple):
|
||||
value = ConvertingTuple(value)
|
||||
value.configurator = self
|
||||
elif isinstance(value, str): # str for py3k
|
||||
m = self.CONVERT_PATTERN.match(value)
|
||||
if m:
|
||||
d = m.groupdict()
|
||||
prefix = d['prefix']
|
||||
converter = self.value_converters.get(prefix, None)
|
||||
if converter:
|
||||
suffix = d['suffix']
|
||||
converter = getattr(self, converter)
|
||||
value = converter(suffix)
|
||||
return value
|
||||
|
||||
def configure_custom(self, config):
|
||||
"""Configure an object with a user-supplied factory."""
|
||||
c = config.pop('()')
|
||||
if not callable(c):
|
||||
c = self.resolve(c)
|
||||
props = config.pop('.', None)
|
||||
# Check for valid identifiers
|
||||
kwargs = {k: config[k] for k in config if valid_ident(k)}
|
||||
result = c(**kwargs)
|
||||
if props:
|
||||
for name, value in props.items():
|
||||
setattr(result, name, value)
|
||||
return result
|
||||
|
||||
def as_tuple(self, value):
|
||||
"""Utility function which converts lists to tuples."""
|
||||
if isinstance(value, list):
|
||||
value = tuple(value)
|
||||
return value
|
||||
|
||||
class DictConfigurator(BaseConfigurator):
|
||||
"""
|
||||
Configure logging using a dictionary-like object to describe the
|
||||
configuration.
|
||||
"""
|
||||
|
||||
def configure(self):
|
||||
"""Do the configuration."""
|
||||
|
||||
config = self.config
|
||||
if 'version' not in config:
|
||||
raise ValueError("dictionary doesn't specify a version")
|
||||
if config['version'] != 1:
|
||||
raise ValueError("Unsupported version: %s" % config['version'])
|
||||
incremental = config.pop('incremental', False)
|
||||
EMPTY_DICT = {}
|
||||
logging._acquireLock()
|
||||
try:
|
||||
if incremental:
|
||||
handlers = config.get('handlers', EMPTY_DICT)
|
||||
for name in handlers:
|
||||
if name not in logging._handlers:
|
||||
raise ValueError('No handler found with '
|
||||
'name %r' % name)
|
||||
else:
|
||||
try:
|
||||
handler = logging._handlers[name]
|
||||
handler_config = handlers[name]
|
||||
level = handler_config.get('level', None)
|
||||
if level:
|
||||
handler.setLevel(logging._checkLevel(level))
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to configure handler '
|
||||
'%r' % name) from e
|
||||
loggers = config.get('loggers', EMPTY_DICT)
|
||||
for name in loggers:
|
||||
try:
|
||||
self.configure_logger(name, loggers[name], True)
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to configure logger '
|
||||
'%r' % name) from e
|
||||
root = config.get('root', None)
|
||||
if root:
|
||||
try:
|
||||
self.configure_root(root, True)
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to configure root '
|
||||
'logger') from e
|
||||
else:
|
||||
disable_existing = config.pop('disable_existing_loggers', True)
|
||||
|
||||
_clearExistingHandlers()
|
||||
|
||||
# Do formatters first - they don't refer to anything else
|
||||
formatters = config.get('formatters', EMPTY_DICT)
|
||||
for name in formatters:
|
||||
try:
|
||||
formatters[name] = self.configure_formatter(
|
||||
formatters[name])
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to configure '
|
||||
'formatter %r' % name) from e
|
||||
# Next, do filters - they don't refer to anything else, either
|
||||
filters = config.get('filters', EMPTY_DICT)
|
||||
for name in filters:
|
||||
try:
|
||||
filters[name] = self.configure_filter(filters[name])
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to configure '
|
||||
'filter %r' % name) from e
|
||||
|
||||
# Next, do handlers - they refer to formatters and filters
|
||||
# As handlers can refer to other handlers, sort the keys
|
||||
# to allow a deterministic order of configuration
|
||||
handlers = config.get('handlers', EMPTY_DICT)
|
||||
deferred = []
|
||||
for name in sorted(handlers):
|
||||
try:
|
||||
handler = self.configure_handler(handlers[name])
|
||||
handler.name = name
|
||||
handlers[name] = handler
|
||||
except Exception as e:
|
||||
if 'target not configured yet' in str(e.__cause__):
|
||||
deferred.append(name)
|
||||
else:
|
||||
raise ValueError('Unable to configure handler '
|
||||
'%r' % name) from e
|
||||
|
||||
# Now do any that were deferred
|
||||
for name in deferred:
|
||||
try:
|
||||
handler = self.configure_handler(handlers[name])
|
||||
handler.name = name
|
||||
handlers[name] = handler
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to configure handler '
|
||||
'%r' % name) from e
|
||||
|
||||
# Next, do loggers - they refer to handlers and filters
|
||||
|
||||
#we don't want to lose the existing loggers,
|
||||
#since other threads may have pointers to them.
|
||||
#existing is set to contain all existing loggers,
|
||||
#and as we go through the new configuration we
|
||||
#remove any which are configured. At the end,
|
||||
#what's left in existing is the set of loggers
|
||||
#which were in the previous configuration but
|
||||
#which are not in the new configuration.
|
||||
root = logging.root
|
||||
existing = list(root.manager.loggerDict.keys())
|
||||
#The list needs to be sorted so that we can
|
||||
#avoid disabling child loggers of explicitly
|
||||
#named loggers. With a sorted list it is easier
|
||||
#to find the child loggers.
|
||||
existing.sort()
|
||||
#We'll keep the list of existing loggers
|
||||
#which are children of named loggers here...
|
||||
child_loggers = []
|
||||
#now set up the new ones...
|
||||
loggers = config.get('loggers', EMPTY_DICT)
|
||||
for name in loggers:
|
||||
if name in existing:
|
||||
i = existing.index(name) + 1 # look after name
|
||||
prefixed = name + "."
|
||||
pflen = len(prefixed)
|
||||
num_existing = len(existing)
|
||||
while i < num_existing:
|
||||
if existing[i][:pflen] == prefixed:
|
||||
child_loggers.append(existing[i])
|
||||
i += 1
|
||||
existing.remove(name)
|
||||
try:
|
||||
self.configure_logger(name, loggers[name])
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to configure logger '
|
||||
'%r' % name) from e
|
||||
|
||||
#Disable any old loggers. There's no point deleting
|
||||
#them as other threads may continue to hold references
|
||||
#and by disabling them, you stop them doing any logging.
|
||||
#However, don't disable children of named loggers, as that's
|
||||
#probably not what was intended by the user.
|
||||
#for log in existing:
|
||||
# logger = root.manager.loggerDict[log]
|
||||
# if log in child_loggers:
|
||||
# logger.level = logging.NOTSET
|
||||
# logger.handlers = []
|
||||
# logger.propagate = True
|
||||
# elif disable_existing:
|
||||
# logger.disabled = True
|
||||
_handle_existing_loggers(existing, child_loggers,
|
||||
disable_existing)
|
||||
|
||||
# And finally, do the root logger
|
||||
root = config.get('root', None)
|
||||
if root:
|
||||
try:
|
||||
self.configure_root(root)
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to configure root '
|
||||
'logger') from e
|
||||
finally:
|
||||
logging._releaseLock()
|
||||
|
||||
def configure_formatter(self, config):
|
||||
"""Configure a formatter from a dictionary."""
|
||||
if '()' in config:
|
||||
factory = config['()'] # for use in exception handler
|
||||
try:
|
||||
result = self.configure_custom(config)
|
||||
except TypeError as te:
|
||||
if "'format'" not in str(te):
|
||||
raise
|
||||
#Name of parameter changed from fmt to format.
|
||||
#Retry with old name.
|
||||
#This is so that code can be used with older Python versions
|
||||
#(e.g. by Django)
|
||||
config['fmt'] = config.pop('format')
|
||||
config['()'] = factory
|
||||
result = self.configure_custom(config)
|
||||
else:
|
||||
fmt = config.get('format', None)
|
||||
dfmt = config.get('datefmt', None)
|
||||
style = config.get('style', '%')
|
||||
cname = config.get('class', None)
|
||||
if not cname:
|
||||
c = logging.Formatter
|
||||
else:
|
||||
c = _resolve(cname)
|
||||
result = c(fmt, dfmt, style)
|
||||
return result
|
||||
|
||||
def configure_filter(self, config):
|
||||
"""Configure a filter from a dictionary."""
|
||||
if '()' in config:
|
||||
result = self.configure_custom(config)
|
||||
else:
|
||||
name = config.get('name', '')
|
||||
result = logging.Filter(name)
|
||||
return result
|
||||
|
||||
def add_filters(self, filterer, filters):
|
||||
"""Add filters to a filterer from a list of names."""
|
||||
for f in filters:
|
||||
try:
|
||||
filterer.addFilter(self.config['filters'][f])
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to add filter %r' % f) from e
|
||||
|
||||
def configure_handler(self, config):
|
||||
"""Configure a handler from a dictionary."""
|
||||
config_copy = dict(config) # for restoring in case of error
|
||||
formatter = config.pop('formatter', None)
|
||||
if formatter:
|
||||
try:
|
||||
formatter = self.config['formatters'][formatter]
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to set formatter '
|
||||
'%r' % formatter) from e
|
||||
level = config.pop('level', None)
|
||||
filters = config.pop('filters', None)
|
||||
if '()' in config:
|
||||
c = config.pop('()')
|
||||
if not callable(c):
|
||||
c = self.resolve(c)
|
||||
factory = c
|
||||
else:
|
||||
cname = config.pop('class')
|
||||
klass = self.resolve(cname)
|
||||
#Special case for handler which refers to another handler
|
||||
if issubclass(klass, logging.handlers.MemoryHandler) and\
|
||||
'target' in config:
|
||||
try:
|
||||
th = self.config['handlers'][config['target']]
|
||||
if not isinstance(th, logging.Handler):
|
||||
config.update(config_copy) # restore for deferred cfg
|
||||
raise TypeError('target not configured yet')
|
||||
config['target'] = th
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to set target handler '
|
||||
'%r' % config['target']) from e
|
||||
elif issubclass(klass, logging.handlers.SMTPHandler) and\
|
||||
'mailhost' in config:
|
||||
config['mailhost'] = self.as_tuple(config['mailhost'])
|
||||
elif issubclass(klass, logging.handlers.SysLogHandler) and\
|
||||
'address' in config:
|
||||
config['address'] = self.as_tuple(config['address'])
|
||||
factory = klass
|
||||
props = config.pop('.', None)
|
||||
kwargs = {k: config[k] for k in config if valid_ident(k)}
|
||||
try:
|
||||
result = factory(**kwargs)
|
||||
except TypeError as te:
|
||||
if "'stream'" not in str(te):
|
||||
raise
|
||||
#The argument name changed from strm to stream
|
||||
#Retry with old name.
|
||||
#This is so that code can be used with older Python versions
|
||||
#(e.g. by Django)
|
||||
kwargs['strm'] = kwargs.pop('stream')
|
||||
result = factory(**kwargs)
|
||||
if formatter:
|
||||
result.setFormatter(formatter)
|
||||
if level is not None:
|
||||
result.setLevel(logging._checkLevel(level))
|
||||
if filters:
|
||||
self.add_filters(result, filters)
|
||||
if props:
|
||||
for name, value in props.items():
|
||||
setattr(result, name, value)
|
||||
return result
|
||||
|
||||
def add_handlers(self, logger, handlers):
|
||||
"""Add handlers to a logger from a list of names."""
|
||||
for h in handlers:
|
||||
try:
|
||||
logger.addHandler(self.config['handlers'][h])
|
||||
except Exception as e:
|
||||
raise ValueError('Unable to add handler %r' % h) from e
|
||||
|
||||
def common_logger_config(self, logger, config, incremental=False):
|
||||
"""
|
||||
Perform configuration which is common to root and non-root loggers.
|
||||
"""
|
||||
level = config.get('level', None)
|
||||
if level is not None:
|
||||
logger.setLevel(logging._checkLevel(level))
|
||||
if not incremental:
|
||||
#Remove any existing handlers
|
||||
for h in logger.handlers[:]:
|
||||
logger.removeHandler(h)
|
||||
handlers = config.get('handlers', None)
|
||||
if handlers:
|
||||
self.add_handlers(logger, handlers)
|
||||
filters = config.get('filters', None)
|
||||
if filters:
|
||||
self.add_filters(logger, filters)
|
||||
|
||||
def configure_logger(self, name, config, incremental=False):
|
||||
"""Configure a non-root logger from a dictionary."""
|
||||
logger = logging.getLogger(name)
|
||||
self.common_logger_config(logger, config, incremental)
|
||||
propagate = config.get('propagate', None)
|
||||
if propagate is not None:
|
||||
logger.propagate = propagate
|
||||
|
||||
def configure_root(self, config, incremental=False):
|
||||
"""Configure a root logger from a dictionary."""
|
||||
root = logging.getLogger()
|
||||
self.common_logger_config(root, config, incremental)
|
||||
|
||||
dictConfigClass = DictConfigurator
|
||||
|
||||
def dictConfig(config):
|
||||
"""Configure logging using a dictionary."""
|
||||
dictConfigClass(config).configure()
|
||||
|
||||
|
||||
def listen(port=DEFAULT_LOGGING_CONFIG_PORT, verify=None):
|
||||
"""
|
||||
Start up a socket server on the specified port, and listen for new
|
||||
configurations.
|
||||
|
||||
These will be sent as a file suitable for processing by fileConfig().
|
||||
Returns a Thread object on which you can call start() to start the server,
|
||||
and which you can join() when appropriate. To stop the server, call
|
||||
stopListening().
|
||||
|
||||
Use the ``verify`` argument to verify any bytes received across the wire
|
||||
from a client. If specified, it should be a callable which receives a
|
||||
single argument - the bytes of configuration data received across the
|
||||
network - and it should return either ``None``, to indicate that the
|
||||
passed in bytes could not be verified and should be discarded, or a
|
||||
byte string which is then passed to the configuration machinery as
|
||||
normal. Note that you can return transformed bytes, e.g. by decrypting
|
||||
the bytes passed in.
|
||||
"""
|
||||
|
||||
class ConfigStreamHandler(StreamRequestHandler):
|
||||
"""
|
||||
Handler for a logging configuration request.
|
||||
|
||||
It expects a completely new logging configuration and uses fileConfig
|
||||
to install it.
|
||||
"""
|
||||
def handle(self):
|
||||
"""
|
||||
Handle a request.
|
||||
|
||||
Each request is expected to be a 4-byte length, packed using
|
||||
struct.pack(">L", n), followed by the config file.
|
||||
Uses fileConfig() to do the grunt work.
|
||||
"""
|
||||
try:
|
||||
conn = self.connection
|
||||
chunk = conn.recv(4)
|
||||
if len(chunk) == 4:
|
||||
slen = struct.unpack(">L", chunk)[0]
|
||||
chunk = self.connection.recv(slen)
|
||||
while len(chunk) < slen:
|
||||
chunk = chunk + conn.recv(slen - len(chunk))
|
||||
if self.server.verify is not None:
|
||||
chunk = self.server.verify(chunk)
|
||||
if chunk is not None: # verified, can process
|
||||
chunk = chunk.decode("utf-8")
|
||||
try:
|
||||
import json
|
||||
d =json.loads(chunk)
|
||||
assert isinstance(d, dict)
|
||||
dictConfig(d)
|
||||
except Exception:
|
||||
#Apply new configuration.
|
||||
|
||||
file = io.StringIO(chunk)
|
||||
try:
|
||||
fileConfig(file)
|
||||
except Exception:
|
||||
traceback.print_exc()
|
||||
if self.server.ready:
|
||||
self.server.ready.set()
|
||||
except OSError as e:
|
||||
if e.errno != RESET_ERROR:
|
||||
raise
|
||||
|
||||
class ConfigSocketReceiver(ThreadingTCPServer):
|
||||
"""
|
||||
A simple TCP socket-based logging config receiver.
|
||||
"""
|
||||
|
||||
allow_reuse_address = 1
|
||||
|
||||
def __init__(self, host='localhost', port=DEFAULT_LOGGING_CONFIG_PORT,
|
||||
handler=None, ready=None, verify=None):
|
||||
ThreadingTCPServer.__init__(self, (host, port), handler)
|
||||
logging._acquireLock()
|
||||
self.abort = 0
|
||||
logging._releaseLock()
|
||||
self.timeout = 1
|
||||
self.ready = ready
|
||||
self.verify = verify
|
||||
|
||||
def serve_until_stopped(self):
|
||||
import select
|
||||
abort = 0
|
||||
while not abort:
|
||||
rd, wr, ex = select.select([self.socket.fileno()],
|
||||
[], [],
|
||||
self.timeout)
|
||||
if rd:
|
||||
self.handle_request()
|
||||
logging._acquireLock()
|
||||
abort = self.abort
|
||||
logging._releaseLock()
|
||||
self.server_close()
|
||||
|
||||
class Server(threading.Thread):
|
||||
|
||||
def __init__(self, rcvr, hdlr, port, verify):
|
||||
super(Server, self).__init__()
|
||||
self.rcvr = rcvr
|
||||
self.hdlr = hdlr
|
||||
self.port = port
|
||||
self.verify = verify
|
||||
self.ready = threading.Event()
|
||||
|
||||
def run(self):
|
||||
server = self.rcvr(port=self.port, handler=self.hdlr,
|
||||
ready=self.ready,
|
||||
verify=self.verify)
|
||||
if self.port == 0:
|
||||
self.port = server.server_address[1]
|
||||
self.ready.set()
|
||||
global _listener
|
||||
logging._acquireLock()
|
||||
_listener = server
|
||||
logging._releaseLock()
|
||||
server.serve_until_stopped()
|
||||
|
||||
return Server(ConfigSocketReceiver, ConfigStreamHandler, port, verify)
|
||||
|
||||
def stopListening():
|
||||
"""
|
||||
Stop the listening server which was created with a call to listen().
|
||||
"""
|
||||
global _listener
|
||||
logging._acquireLock()
|
||||
try:
|
||||
if _listener:
|
||||
_listener.abort = 1
|
||||
_listener = None
|
||||
finally:
|
||||
logging._releaseLock()
|
||||
1504
Lib/logging/handlers.py
Normal file
1504
Lib/logging/handlers.py
Normal file
File diff suppressed because it is too large
Load Diff
611
Lib/traceback.py
Normal file
611
Lib/traceback.py
Normal file
@@ -0,0 +1,611 @@
|
||||
"""Extract, format and print information about Python stack traces."""
|
||||
|
||||
import collections
|
||||
import itertools
|
||||
import linecache
|
||||
import sys
|
||||
|
||||
__all__ = ['extract_stack', 'extract_tb', 'format_exception',
|
||||
'format_exception_only', 'format_list', 'format_stack',
|
||||
'format_tb', 'print_exc', 'format_exc', 'print_exception',
|
||||
'print_last', 'print_stack', 'print_tb', 'clear_frames',
|
||||
'FrameSummary', 'StackSummary', 'TracebackException',
|
||||
'walk_stack', 'walk_tb']
|
||||
|
||||
#
|
||||
# Formatting and printing lists of traceback lines.
|
||||
#
|
||||
|
||||
def print_list(extracted_list, file=None):
|
||||
"""Print the list of tuples as returned by extract_tb() or
|
||||
extract_stack() as a formatted stack trace to the given file."""
|
||||
if file is None:
|
||||
file = sys.stderr
|
||||
for item in StackSummary.from_list(extracted_list).format():
|
||||
print(item, file=file, end="")
|
||||
|
||||
def format_list(extracted_list):
|
||||
"""Format a list of tuples or FrameSummary objects for printing.
|
||||
|
||||
Given a list of tuples or FrameSummary objects as returned by
|
||||
extract_tb() or extract_stack(), return a list of strings ready
|
||||
for printing.
|
||||
|
||||
Each string in the resulting list corresponds to the item with the
|
||||
same index in the argument list. Each string ends in a newline;
|
||||
the strings may contain internal newlines as well, for those items
|
||||
whose source text line is not None.
|
||||
"""
|
||||
return StackSummary.from_list(extracted_list).format()
|
||||
|
||||
#
|
||||
# Printing and Extracting Tracebacks.
|
||||
#
|
||||
|
||||
def print_tb(tb, limit=None, file=None):
|
||||
"""Print up to 'limit' stack trace entries from the traceback 'tb'.
|
||||
|
||||
If 'limit' is omitted or None, all entries are printed. If 'file'
|
||||
is omitted or None, the output goes to sys.stderr; otherwise
|
||||
'file' should be an open file or file-like object with a write()
|
||||
method.
|
||||
"""
|
||||
print_list(extract_tb(tb, limit=limit), file=file)
|
||||
|
||||
def format_tb(tb, limit=None):
|
||||
"""A shorthand for 'format_list(extract_tb(tb, limit))'."""
|
||||
return extract_tb(tb, limit=limit).format()
|
||||
|
||||
def extract_tb(tb, limit=None):
|
||||
"""
|
||||
Return a StackSummary object representing a list of
|
||||
pre-processed entries from traceback.
|
||||
|
||||
This is useful for alternate formatting of stack traces. If
|
||||
'limit' is omitted or None, all entries are extracted. A
|
||||
pre-processed stack trace entry is a FrameSummary object
|
||||
containing attributes filename, lineno, name, and line
|
||||
representing the information that is usually printed for a stack
|
||||
trace. The line is a string with leading and trailing
|
||||
whitespace stripped; if the source is not available it is None.
|
||||
"""
|
||||
return StackSummary.extract(walk_tb(tb), limit=limit)
|
||||
|
||||
#
|
||||
# Exception formatting and output.
|
||||
#
|
||||
|
||||
_cause_message = (
|
||||
"\nThe above exception was the direct cause "
|
||||
"of the following exception:\n\n")
|
||||
|
||||
_context_message = (
|
||||
"\nDuring handling of the above exception, "
|
||||
"another exception occurred:\n\n")
|
||||
|
||||
|
||||
def print_exception(etype, value, tb, limit=None, file=None, chain=True):
|
||||
"""Print exception up to 'limit' stack trace entries from 'tb' to 'file'.
|
||||
|
||||
This differs from print_tb() in the following ways: (1) if
|
||||
traceback is not None, it prints a header "Traceback (most recent
|
||||
call last):"; (2) it prints the exception type and value after the
|
||||
stack trace; (3) if type is SyntaxError and value has the
|
||||
appropriate format, it prints the line where the syntax error
|
||||
occurred with a caret on the next line indicating the approximate
|
||||
position of the error.
|
||||
"""
|
||||
# format_exception has ignored etype for some time, and code such as cgitb
|
||||
# passes in bogus values as a result. For compatibility with such code we
|
||||
# ignore it here (rather than in the new TracebackException API).
|
||||
if file is None:
|
||||
file = sys.stderr
|
||||
for line in TracebackException(
|
||||
type(value), value, tb, limit=limit).format(chain=chain):
|
||||
print(line, file=file, end="")
|
||||
|
||||
|
||||
def format_exception(etype, value, tb, limit=None, chain=True):
|
||||
"""Format a stack trace and the exception information.
|
||||
|
||||
The arguments have the same meaning as the corresponding arguments
|
||||
to print_exception(). The return value is a list of strings, each
|
||||
ending in a newline and some containing internal newlines. When
|
||||
these lines are concatenated and printed, exactly the same text is
|
||||
printed as does print_exception().
|
||||
"""
|
||||
# format_exception has ignored etype for some time, and code such as cgitb
|
||||
# passes in bogus values as a result. For compatibility with such code we
|
||||
# ignore it here (rather than in the new TracebackException API).
|
||||
return list(TracebackException(
|
||||
type(value), value, tb, limit=limit).format(chain=chain))
|
||||
|
||||
|
||||
def format_exception_only(etype, value):
|
||||
"""Format the exception part of a traceback.
|
||||
|
||||
The arguments are the exception type and value such as given by
|
||||
sys.last_type and sys.last_value. The return value is a list of
|
||||
strings, each ending in a newline.
|
||||
|
||||
Normally, the list contains a single string; however, for
|
||||
SyntaxError exceptions, it contains several lines that (when
|
||||
printed) display detailed information about where the syntax
|
||||
error occurred.
|
||||
|
||||
The message indicating which exception occurred is always the last
|
||||
string in the list.
|
||||
|
||||
"""
|
||||
return list(TracebackException(etype, value, None).format_exception_only())
|
||||
|
||||
|
||||
# -- not official API but folk probably use these two functions.
|
||||
|
||||
def _format_final_exc_line(etype, value):
|
||||
valuestr = _some_str(value)
|
||||
if value is None or not valuestr:
|
||||
line = "%s\n" % etype
|
||||
else:
|
||||
line = "%s: %s\n" % (etype, valuestr)
|
||||
return line
|
||||
|
||||
def _some_str(value):
|
||||
try:
|
||||
return str(value)
|
||||
except:
|
||||
return '<unprintable %s object>' % type(value).__name__
|
||||
|
||||
# --
|
||||
|
||||
def print_exc(limit=None, file=None, chain=True):
|
||||
"""Shorthand for 'print_exception(*sys.exc_info(), limit, file)'."""
|
||||
print_exception(*sys.exc_info(), limit=limit, file=file, chain=chain)
|
||||
|
||||
def format_exc(limit=None, chain=True):
|
||||
"""Like print_exc() but return a string."""
|
||||
return "".join(format_exception(*sys.exc_info(), limit=limit, chain=chain))
|
||||
|
||||
def print_last(limit=None, file=None, chain=True):
|
||||
"""This is a shorthand for 'print_exception(sys.last_type,
|
||||
sys.last_value, sys.last_traceback, limit, file)'."""
|
||||
if not hasattr(sys, "last_type"):
|
||||
raise ValueError("no last exception")
|
||||
print_exception(sys.last_type, sys.last_value, sys.last_traceback,
|
||||
limit, file, chain)
|
||||
|
||||
#
|
||||
# Printing and Extracting Stacks.
|
||||
#
|
||||
|
||||
def print_stack(f=None, limit=None, file=None):
|
||||
"""Print a stack trace from its invocation point.
|
||||
|
||||
The optional 'f' argument can be used to specify an alternate
|
||||
stack frame at which to start. The optional 'limit' and 'file'
|
||||
arguments have the same meaning as for print_exception().
|
||||
"""
|
||||
if f is None:
|
||||
f = sys._getframe().f_back
|
||||
print_list(extract_stack(f, limit=limit), file=file)
|
||||
|
||||
|
||||
def format_stack(f=None, limit=None):
|
||||
"""Shorthand for 'format_list(extract_stack(f, limit))'."""
|
||||
if f is None:
|
||||
f = sys._getframe().f_back
|
||||
return format_list(extract_stack(f, limit=limit))
|
||||
|
||||
|
||||
def extract_stack(f=None, limit=None):
|
||||
"""Extract the raw traceback from the current stack frame.
|
||||
|
||||
The return value has the same format as for extract_tb(). The
|
||||
optional 'f' and 'limit' arguments have the same meaning as for
|
||||
print_stack(). Each item in the list is a quadruple (filename,
|
||||
line number, function name, text), and the entries are in order
|
||||
from oldest to newest stack frame.
|
||||
"""
|
||||
if f is None:
|
||||
f = sys._getframe().f_back
|
||||
stack = StackSummary.extract(walk_stack(f), limit=limit)
|
||||
stack.reverse()
|
||||
return stack
|
||||
|
||||
|
||||
def clear_frames(tb):
|
||||
"Clear all references to local variables in the frames of a traceback."
|
||||
while tb is not None:
|
||||
try:
|
||||
tb.tb_frame.clear()
|
||||
except RuntimeError:
|
||||
# Ignore the exception raised if the frame is still executing.
|
||||
pass
|
||||
tb = tb.tb_next
|
||||
|
||||
|
||||
class FrameSummary:
|
||||
"""A single frame from a traceback.
|
||||
|
||||
- :attr:`filename` The filename for the frame.
|
||||
- :attr:`lineno` The line within filename for the frame that was
|
||||
active when the frame was captured.
|
||||
- :attr:`name` The name of the function or method that was executing
|
||||
when the frame was captured.
|
||||
- :attr:`line` The text from the linecache module for the
|
||||
of code that was running when the frame was captured.
|
||||
- :attr:`locals` Either None if locals were not supplied, or a dict
|
||||
mapping the name to the repr() of the variable.
|
||||
"""
|
||||
|
||||
__slots__ = ('filename', 'lineno', 'name', '_line', 'locals')
|
||||
|
||||
def __init__(self, filename, lineno, name, *, lookup_line=True,
|
||||
locals=None, line=None):
|
||||
"""Construct a FrameSummary.
|
||||
|
||||
:param lookup_line: If True, `linecache` is consulted for the source
|
||||
code line. Otherwise, the line will be looked up when first needed.
|
||||
:param locals: If supplied the frame locals, which will be captured as
|
||||
object representations.
|
||||
:param line: If provided, use this instead of looking up the line in
|
||||
the linecache.
|
||||
"""
|
||||
self.filename = filename
|
||||
self.lineno = lineno
|
||||
self.name = name
|
||||
self._line = line
|
||||
if lookup_line:
|
||||
self.line
|
||||
self.locals = {k: repr(v) for k, v in locals.items()} if locals else None
|
||||
|
||||
def __eq__(self, other):
|
||||
if isinstance(other, FrameSummary):
|
||||
return (self.filename == other.filename and
|
||||
self.lineno == other.lineno and
|
||||
self.name == other.name and
|
||||
self.locals == other.locals)
|
||||
if isinstance(other, tuple):
|
||||
return (self.filename, self.lineno, self.name, self.line) == other
|
||||
return NotImplemented
|
||||
|
||||
def __getitem__(self, pos):
|
||||
return (self.filename, self.lineno, self.name, self.line)[pos]
|
||||
|
||||
def __iter__(self):
|
||||
return iter([self.filename, self.lineno, self.name, self.line])
|
||||
|
||||
def __repr__(self):
|
||||
return "<FrameSummary file {filename}, line {lineno} in {name}>".format(
|
||||
filename=self.filename, lineno=self.lineno, name=self.name)
|
||||
|
||||
@property
|
||||
def line(self):
|
||||
if self._line is None:
|
||||
self._line = linecache.getline(self.filename, self.lineno).strip()
|
||||
return self._line
|
||||
|
||||
|
||||
def walk_stack(f):
|
||||
"""Walk a stack yielding the frame and line number for each frame.
|
||||
|
||||
This will follow f.f_back from the given frame. If no frame is given, the
|
||||
current stack is used. Usually used with StackSummary.extract.
|
||||
"""
|
||||
if f is None:
|
||||
f = sys._getframe().f_back.f_back
|
||||
while f is not None:
|
||||
yield f, f.f_lineno
|
||||
f = f.f_back
|
||||
|
||||
|
||||
def walk_tb(tb):
|
||||
"""Walk a traceback yielding the frame and line number for each frame.
|
||||
|
||||
This will follow tb.tb_next (and thus is in the opposite order to
|
||||
walk_stack). Usually used with StackSummary.extract.
|
||||
"""
|
||||
while tb is not None:
|
||||
yield tb.tb_frame, tb.tb_lineno
|
||||
tb = tb.tb_next
|
||||
|
||||
|
||||
_RECURSIVE_CUTOFF = 3 # Also hardcoded in traceback.c.
|
||||
|
||||
class StackSummary(list):
|
||||
"""A stack of frames."""
|
||||
|
||||
@classmethod
|
||||
def extract(klass, frame_gen, *, limit=None, lookup_lines=True,
|
||||
capture_locals=False):
|
||||
"""Create a StackSummary from a traceback or stack object.
|
||||
|
||||
:param frame_gen: A generator that yields (frame, lineno) tuples to
|
||||
include in the stack.
|
||||
:param limit: None to include all frames or the number of frames to
|
||||
include.
|
||||
:param lookup_lines: If True, lookup lines for each frame immediately,
|
||||
otherwise lookup is deferred until the frame is rendered.
|
||||
:param capture_locals: If True, the local variables from each frame will
|
||||
be captured as object representations into the FrameSummary.
|
||||
"""
|
||||
if limit is None:
|
||||
limit = getattr(sys, 'tracebacklimit', None)
|
||||
if limit is not None and limit < 0:
|
||||
limit = 0
|
||||
if limit is not None:
|
||||
if limit >= 0:
|
||||
frame_gen = itertools.islice(frame_gen, limit)
|
||||
else:
|
||||
frame_gen = collections.deque(frame_gen, maxlen=-limit)
|
||||
|
||||
result = klass()
|
||||
fnames = set()
|
||||
for f, lineno in frame_gen:
|
||||
co = f.f_code
|
||||
filename = co.co_filename
|
||||
name = co.co_name
|
||||
|
||||
fnames.add(filename)
|
||||
linecache.lazycache(filename, f.f_globals)
|
||||
# Must defer line lookups until we have called checkcache.
|
||||
if capture_locals:
|
||||
f_locals = f.f_locals
|
||||
else:
|
||||
f_locals = None
|
||||
result.append(FrameSummary(
|
||||
filename, lineno, name, lookup_line=False, locals=f_locals))
|
||||
for filename in fnames:
|
||||
linecache.checkcache(filename)
|
||||
# If immediate lookup was desired, trigger lookups now.
|
||||
if lookup_lines:
|
||||
for f in result:
|
||||
f.line
|
||||
return result
|
||||
|
||||
@classmethod
|
||||
def from_list(klass, a_list):
|
||||
"""
|
||||
Create a StackSummary object from a supplied list of
|
||||
FrameSummary objects or old-style list of tuples.
|
||||
"""
|
||||
# While doing a fast-path check for isinstance(a_list, StackSummary) is
|
||||
# appealing, idlelib.run.cleanup_traceback and other similar code may
|
||||
# break this by making arbitrary frames plain tuples, so we need to
|
||||
# check on a frame by frame basis.
|
||||
result = StackSummary()
|
||||
for frame in a_list:
|
||||
if isinstance(frame, FrameSummary):
|
||||
result.append(frame)
|
||||
else:
|
||||
filename, lineno, name, line = frame
|
||||
result.append(FrameSummary(filename, lineno, name, line=line))
|
||||
return result
|
||||
|
||||
def format(self):
|
||||
"""Format the stack ready for printing.
|
||||
|
||||
Returns a list of strings ready for printing. Each string in the
|
||||
resulting list corresponds to a single frame from the stack.
|
||||
Each string ends in a newline; the strings may contain internal
|
||||
newlines as well, for those items with source text lines.
|
||||
|
||||
For long sequences of the same frame and line, the first few
|
||||
repetitions are shown, followed by a summary line stating the exact
|
||||
number of further repetitions.
|
||||
"""
|
||||
result = []
|
||||
last_file = None
|
||||
last_line = None
|
||||
last_name = None
|
||||
count = 0
|
||||
for frame in self:
|
||||
if (last_file is None or last_file != frame.filename or
|
||||
last_line is None or last_line != frame.lineno or
|
||||
last_name is None or last_name != frame.name):
|
||||
if count > _RECURSIVE_CUTOFF:
|
||||
count -= _RECURSIVE_CUTOFF
|
||||
result.append(
|
||||
f' [Previous line repeated {count} more '
|
||||
f'time{"s" if count > 1 else ""}]\n'
|
||||
)
|
||||
last_file = frame.filename
|
||||
last_line = frame.lineno
|
||||
last_name = frame.name
|
||||
count = 0
|
||||
count += 1
|
||||
if count > _RECURSIVE_CUTOFF:
|
||||
continue
|
||||
row = []
|
||||
row.append(' File "{}", line {}, in {}\n'.format(
|
||||
frame.filename, frame.lineno, frame.name))
|
||||
if frame.line:
|
||||
row.append(' {}\n'.format(frame.line.strip()))
|
||||
if frame.locals:
|
||||
for name, value in sorted(frame.locals.items()):
|
||||
row.append(' {name} = {value}\n'.format(name=name, value=value))
|
||||
result.append(''.join(row))
|
||||
if count > _RECURSIVE_CUTOFF:
|
||||
count -= _RECURSIVE_CUTOFF
|
||||
result.append(
|
||||
f' [Previous line repeated {count} more '
|
||||
f'time{"s" if count > 1 else ""}]\n'
|
||||
)
|
||||
return result
|
||||
|
||||
|
||||
class TracebackException:
|
||||
"""An exception ready for rendering.
|
||||
|
||||
The traceback module captures enough attributes from the original exception
|
||||
to this intermediary form to ensure that no references are held, while
|
||||
still being able to fully print or format it.
|
||||
|
||||
Use `from_exception` to create TracebackException instances from exception
|
||||
objects, or the constructor to create TracebackException instances from
|
||||
individual components.
|
||||
|
||||
- :attr:`__cause__` A TracebackException of the original *__cause__*.
|
||||
- :attr:`__context__` A TracebackException of the original *__context__*.
|
||||
- :attr:`__suppress_context__` The *__suppress_context__* value from the
|
||||
original exception.
|
||||
- :attr:`stack` A `StackSummary` representing the traceback.
|
||||
- :attr:`exc_type` The class of the original traceback.
|
||||
- :attr:`filename` For syntax errors - the filename where the error
|
||||
occurred.
|
||||
- :attr:`lineno` For syntax errors - the linenumber where the error
|
||||
occurred.
|
||||
- :attr:`text` For syntax errors - the text where the error
|
||||
occurred.
|
||||
- :attr:`offset` For syntax errors - the offset into the text where the
|
||||
error occurred.
|
||||
- :attr:`msg` For syntax errors - the compiler error message.
|
||||
"""
|
||||
|
||||
def __init__(self, exc_type, exc_value, exc_traceback, *, limit=None,
|
||||
lookup_lines=True, capture_locals=False, _seen=None):
|
||||
# NB: we need to accept exc_traceback, exc_value, exc_traceback to
|
||||
# permit backwards compat with the existing API, otherwise we
|
||||
# need stub thunk objects just to glue it together.
|
||||
# Handle loops in __cause__ or __context__.
|
||||
if _seen is None:
|
||||
_seen = set()
|
||||
_seen.add(id(exc_value))
|
||||
# Gracefully handle (the way Python 2.4 and earlier did) the case of
|
||||
# being called with no type or value (None, None, None).
|
||||
if (exc_value and exc_value.__cause__ is not None
|
||||
and id(exc_value.__cause__) not in _seen):
|
||||
cause = TracebackException(
|
||||
type(exc_value.__cause__),
|
||||
exc_value.__cause__,
|
||||
exc_value.__cause__.__traceback__,
|
||||
limit=limit,
|
||||
lookup_lines=False,
|
||||
capture_locals=capture_locals,
|
||||
_seen=_seen)
|
||||
else:
|
||||
cause = None
|
||||
if (exc_value and exc_value.__context__ is not None
|
||||
and id(exc_value.__context__) not in _seen):
|
||||
context = TracebackException(
|
||||
type(exc_value.__context__),
|
||||
exc_value.__context__,
|
||||
exc_value.__context__.__traceback__,
|
||||
limit=limit,
|
||||
lookup_lines=False,
|
||||
capture_locals=capture_locals,
|
||||
_seen=_seen)
|
||||
else:
|
||||
context = None
|
||||
self.exc_traceback = exc_traceback
|
||||
self.__cause__ = cause
|
||||
self.__context__ = context
|
||||
self.__suppress_context__ = \
|
||||
exc_value.__suppress_context__ if exc_value else False
|
||||
# TODO: locals.
|
||||
self.stack = StackSummary.extract(
|
||||
walk_tb(exc_traceback), limit=limit, lookup_lines=lookup_lines,
|
||||
capture_locals=capture_locals)
|
||||
self.exc_type = exc_type
|
||||
# Capture now to permit freeing resources: only complication is in the
|
||||
# unofficial API _format_final_exc_line
|
||||
self._str = _some_str(exc_value)
|
||||
if exc_type and issubclass(exc_type, SyntaxError):
|
||||
# Handle SyntaxError's specially
|
||||
self.filename = exc_value.filename
|
||||
self.lineno = str(exc_value.lineno)
|
||||
self.text = exc_value.text
|
||||
self.offset = exc_value.offset
|
||||
self.msg = exc_value.msg
|
||||
if lookup_lines:
|
||||
self._load_lines()
|
||||
|
||||
@classmethod
|
||||
def from_exception(cls, exc, *args, **kwargs):
|
||||
"""Create a TracebackException from an exception."""
|
||||
return cls(type(exc), exc, exc.__traceback__, *args, **kwargs)
|
||||
|
||||
def _load_lines(self):
|
||||
"""Private API. force all lines in the stack to be loaded."""
|
||||
for frame in self.stack:
|
||||
frame.line
|
||||
if self.__context__:
|
||||
self.__context__._load_lines()
|
||||
if self.__cause__:
|
||||
self.__cause__._load_lines()
|
||||
|
||||
def __eq__(self, other):
|
||||
return self.__dict__ == other.__dict__
|
||||
|
||||
def __str__(self):
|
||||
return self._str
|
||||
|
||||
def format_exception_only(self):
|
||||
"""Format the exception part of the traceback.
|
||||
|
||||
The return value is a generator of strings, each ending in a newline.
|
||||
|
||||
Normally, the generator emits a single string; however, for
|
||||
SyntaxError exceptions, it emites several lines that (when
|
||||
printed) display detailed information about where the syntax
|
||||
error occurred.
|
||||
|
||||
The message indicating which exception occurred is always the last
|
||||
string in the output.
|
||||
"""
|
||||
if self.exc_type is None:
|
||||
yield _format_final_exc_line(None, self._str)
|
||||
return
|
||||
|
||||
stype = self.exc_type.__qualname__
|
||||
smod = self.exc_type.__module__
|
||||
if smod not in ("__main__", "builtins"):
|
||||
stype = smod + '.' + stype
|
||||
|
||||
if not issubclass(self.exc_type, SyntaxError):
|
||||
yield _format_final_exc_line(stype, self._str)
|
||||
return
|
||||
|
||||
# It was a syntax error; show exactly where the problem was found.
|
||||
filename = self.filename or "<string>"
|
||||
lineno = str(self.lineno) or '?'
|
||||
yield ' File "{}", line {}\n'.format(filename, lineno)
|
||||
|
||||
badline = self.text
|
||||
offset = self.offset
|
||||
if badline is not None:
|
||||
yield ' {}\n'.format(badline.strip())
|
||||
if offset is not None:
|
||||
caretspace = badline.rstrip('\n')
|
||||
offset = min(len(caretspace), offset) - 1
|
||||
caretspace = caretspace[:offset].lstrip()
|
||||
# non-space whitespace (likes tabs) must be kept for alignment
|
||||
caretspace = ((c.isspace() and c or ' ') for c in caretspace)
|
||||
yield ' {}^\n'.format(''.join(caretspace))
|
||||
msg = self.msg or "<no detail available>"
|
||||
yield "{}: {}\n".format(stype, msg)
|
||||
|
||||
def format(self, *, chain=True):
|
||||
"""Format the exception.
|
||||
|
||||
If chain is not *True*, *__cause__* and *__context__* will not be formatted.
|
||||
|
||||
The return value is a generator of strings, each ending in a newline and
|
||||
some containing internal newlines. `print_exception` is a wrapper around
|
||||
this method which just prints the lines to a file.
|
||||
|
||||
The message indicating which exception occurred is always the last
|
||||
string in the output.
|
||||
"""
|
||||
if chain:
|
||||
if self.__cause__ is not None:
|
||||
yield from self.__cause__.format(chain=chain)
|
||||
yield _cause_message
|
||||
elif (self.__context__ is not None and
|
||||
not self.__suppress_context__):
|
||||
yield from self.__context__.format(chain=chain)
|
||||
yield _context_message
|
||||
if self.exc_traceback is not None:
|
||||
yield 'Traceback (most recent call last):\n'
|
||||
yield from self.stack.format()
|
||||
yield from self.format_exception_only()
|
||||
@@ -240,13 +240,13 @@ impl<T: Clone> Dict<T> {
|
||||
}
|
||||
|
||||
/// Retrieve and delete a key
|
||||
pub fn pop(&mut self, vm: &VirtualMachine, key: &PyObjectRef) -> PyResult<T> {
|
||||
pub fn pop(&mut self, vm: &VirtualMachine, key: &PyObjectRef) -> PyResult<Option<T>> {
|
||||
if let LookupResult::Existing(index) = self.lookup(vm, key)? {
|
||||
let value = self.unchecked_get(index);
|
||||
self.unchecked_delete(index);
|
||||
Ok(value)
|
||||
Ok(Some(value))
|
||||
} else {
|
||||
Err(vm.new_key_error(key.clone()))
|
||||
Ok(None)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -257,8 +257,19 @@ impl PyDictRef {
|
||||
PyDictRef::merge(&self.entries, dict_obj, kwargs, vm)
|
||||
}
|
||||
|
||||
fn pop(self, key: PyObjectRef, vm: &VirtualMachine) -> PyResult {
|
||||
self.entries.borrow_mut().pop(vm, &key)
|
||||
fn pop(
|
||||
self,
|
||||
key: PyObjectRef,
|
||||
default: OptionalArg<PyObjectRef>,
|
||||
vm: &VirtualMachine,
|
||||
) -> PyResult {
|
||||
match self.entries.borrow_mut().pop(vm, &key)? {
|
||||
Some(value) => Ok(value),
|
||||
None => match default {
|
||||
OptionalArg::Present(default) => Ok(default),
|
||||
OptionalArg::Missing => Err(vm.new_key_error(key.clone())),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn popitem(self, vm: &VirtualMachine) -> PyResult {
|
||||
|
||||
Reference in New Issue
Block a user