mirror of
git://projects.qi-hardware.com/openwrt-packages.git
synced 2024-11-23 09:10:38 +02:00
403 lines
14 KiB
Python
403 lines
14 KiB
Python
"""Python part of the warnings subsystem."""
|
|
|
|
# Note: function level imports should *not* be used
|
|
# in this module as it may cause import lock deadlock.
|
|
# See bug 683658.
|
|
import linecache
|
|
import sys
|
|
import types
|
|
|
|
__all__ = ["warn", "showwarning", "formatwarning", "filterwarnings",
|
|
"resetwarnings", "catch_warnings"]
|
|
|
|
|
|
def warnpy3k(message, category=None, stacklevel=1):
|
|
"""Issue a deprecation warning for Python 3.x related changes.
|
|
|
|
Warnings are omitted unless Python is started with the -3 option.
|
|
"""
|
|
if sys.py3kwarning:
|
|
if category is None:
|
|
category = DeprecationWarning
|
|
warn(message, category, stacklevel+1)
|
|
|
|
def _show_warning(message, category, filename, lineno, file=None, line=None):
|
|
"""Hook to write a warning to a file; replace if you like."""
|
|
if file is None:
|
|
file = sys.stderr
|
|
try:
|
|
file.write(formatwarning(message, category, filename, lineno, line))
|
|
except IOError:
|
|
pass # the file (probably stderr) is invalid - this warning gets lost.
|
|
# Keep a worrking version around in case the deprecation of the old API is
|
|
# triggered.
|
|
showwarning = _show_warning
|
|
|
|
def formatwarning(message, category, filename, lineno, line=None):
|
|
"""Function to format a warning the standard way."""
|
|
s = "%s:%s: %s: %s\n" % (filename, lineno, category.__name__, message)
|
|
line = linecache.getline(filename, lineno) if line is None else line
|
|
if line:
|
|
line = line.strip()
|
|
s += " %s\n" % line
|
|
return s
|
|
|
|
def filterwarnings(action, message="", category=Warning, module="", lineno=0,
|
|
append=0):
|
|
"""Insert an entry into the list of warnings filters (at the front).
|
|
|
|
Use assertions to check that all arguments have the right type."""
|
|
import re
|
|
assert action in ("error", "ignore", "always", "default", "module",
|
|
"once"), "invalid action: %r" % (action,)
|
|
assert isinstance(message, basestring), "message must be a string"
|
|
assert isinstance(category, (type, types.ClassType)), \
|
|
"category must be a class"
|
|
assert issubclass(category, Warning), "category must be a Warning subclass"
|
|
assert isinstance(module, basestring), "module must be a string"
|
|
assert isinstance(lineno, int) and lineno >= 0, \
|
|
"lineno must be an int >= 0"
|
|
item = (action, re.compile(message, re.I), category,
|
|
re.compile(module), lineno)
|
|
if append:
|
|
filters.append(item)
|
|
else:
|
|
filters.insert(0, item)
|
|
|
|
def simplefilter(action, category=Warning, lineno=0, append=0):
|
|
"""Insert a simple entry into the list of warnings filters (at the front).
|
|
|
|
A simple filter matches all modules and messages.
|
|
"""
|
|
assert action in ("error", "ignore", "always", "default", "module",
|
|
"once"), "invalid action: %r" % (action,)
|
|
assert isinstance(lineno, int) and lineno >= 0, \
|
|
"lineno must be an int >= 0"
|
|
item = (action, None, category, None, lineno)
|
|
if append:
|
|
filters.append(item)
|
|
else:
|
|
filters.insert(0, item)
|
|
|
|
def resetwarnings():
|
|
"""Clear the list of warning filters, so that no filters are active."""
|
|
filters[:] = []
|
|
|
|
class _OptionError(Exception):
|
|
"""Exception used by option processing helpers."""
|
|
pass
|
|
|
|
# Helper to process -W options passed via sys.warnoptions
|
|
def _processoptions(args):
|
|
for arg in args:
|
|
try:
|
|
_setoption(arg)
|
|
except _OptionError, msg:
|
|
print >>sys.stderr, "Invalid -W option ignored:", msg
|
|
|
|
# Helper for _processoptions()
|
|
def _setoption(arg):
|
|
import re
|
|
parts = arg.split(':')
|
|
if len(parts) > 5:
|
|
raise _OptionError("too many fields (max 5): %r" % (arg,))
|
|
while len(parts) < 5:
|
|
parts.append('')
|
|
action, message, category, module, lineno = [s.strip()
|
|
for s in parts]
|
|
action = _getaction(action)
|
|
message = re.escape(message)
|
|
category = _getcategory(category)
|
|
module = re.escape(module)
|
|
if module:
|
|
module = module + '$'
|
|
if lineno:
|
|
try:
|
|
lineno = int(lineno)
|
|
if lineno < 0:
|
|
raise ValueError
|
|
except (ValueError, OverflowError):
|
|
raise _OptionError("invalid lineno %r" % (lineno,))
|
|
else:
|
|
lineno = 0
|
|
filterwarnings(action, message, category, module, lineno)
|
|
|
|
# Helper for _setoption()
|
|
def _getaction(action):
|
|
if not action:
|
|
return "default"
|
|
if action == "all": return "always" # Alias
|
|
for a in ('default', 'always', 'ignore', 'module', 'once', 'error'):
|
|
if a.startswith(action):
|
|
return a
|
|
raise _OptionError("invalid action: %r" % (action,))
|
|
|
|
# Helper for _setoption()
|
|
def _getcategory(category):
|
|
import re
|
|
if not category:
|
|
return Warning
|
|
if re.match("^[a-zA-Z0-9_]+$", category):
|
|
try:
|
|
cat = eval(category)
|
|
except NameError:
|
|
raise _OptionError("unknown warning category: %r" % (category,))
|
|
else:
|
|
i = category.rfind(".")
|
|
module = category[:i]
|
|
klass = category[i+1:]
|
|
try:
|
|
m = __import__(module, None, None, [klass])
|
|
except ImportError:
|
|
raise _OptionError("invalid module name: %r" % (module,))
|
|
try:
|
|
cat = getattr(m, klass)
|
|
except AttributeError:
|
|
raise _OptionError("unknown warning category: %r" % (category,))
|
|
if not issubclass(cat, Warning):
|
|
raise _OptionError("invalid warning category: %r" % (category,))
|
|
return cat
|
|
|
|
|
|
# Code typically replaced by _warnings
|
|
def warn(message, category=None, stacklevel=1):
|
|
"""Issue a warning, or maybe ignore it or raise an exception."""
|
|
# Check if message is already a Warning object
|
|
if isinstance(message, Warning):
|
|
category = message.__class__
|
|
# Check category argument
|
|
if category is None:
|
|
category = UserWarning
|
|
assert issubclass(category, Warning)
|
|
# Get context information
|
|
try:
|
|
caller = sys._getframe(stacklevel)
|
|
except ValueError:
|
|
globals = sys.__dict__
|
|
lineno = 1
|
|
else:
|
|
globals = caller.f_globals
|
|
lineno = caller.f_lineno
|
|
if '__name__' in globals:
|
|
module = globals['__name__']
|
|
else:
|
|
module = "<string>"
|
|
filename = globals.get('__file__')
|
|
if filename:
|
|
fnl = filename.lower()
|
|
if fnl.endswith((".pyc", ".pyo")):
|
|
filename = filename[:-1]
|
|
else:
|
|
if module == "__main__":
|
|
try:
|
|
filename = sys.argv[0]
|
|
except AttributeError:
|
|
# embedded interpreters don't have sys.argv, see bug #839151
|
|
filename = '__main__'
|
|
if not filename:
|
|
filename = module
|
|
registry = globals.setdefault("__warningregistry__", {})
|
|
warn_explicit(message, category, filename, lineno, module, registry,
|
|
globals)
|
|
|
|
def warn_explicit(message, category, filename, lineno,
|
|
module=None, registry=None, module_globals=None):
|
|
lineno = int(lineno)
|
|
if module is None:
|
|
module = filename or "<unknown>"
|
|
if module[-3:].lower() == ".py":
|
|
module = module[:-3] # XXX What about leading pathname?
|
|
if registry is None:
|
|
registry = {}
|
|
if isinstance(message, Warning):
|
|
text = str(message)
|
|
category = message.__class__
|
|
else:
|
|
text = message
|
|
message = category(message)
|
|
key = (text, category, lineno)
|
|
# Quick test for common case
|
|
if registry.get(key):
|
|
return
|
|
# Search the filters
|
|
for item in filters:
|
|
action, msg, cat, mod, ln = item
|
|
if ((msg is None or msg.match(text)) and
|
|
issubclass(category, cat) and
|
|
(mod is None or mod.match(module)) and
|
|
(ln == 0 or lineno == ln)):
|
|
break
|
|
else:
|
|
action = defaultaction
|
|
# Early exit actions
|
|
if action == "ignore":
|
|
registry[key] = 1
|
|
return
|
|
|
|
# Prime the linecache for formatting, in case the
|
|
# "file" is actually in a zipfile or something.
|
|
linecache.getlines(filename, module_globals)
|
|
|
|
if action == "error":
|
|
raise message
|
|
# Other actions
|
|
if action == "once":
|
|
registry[key] = 1
|
|
oncekey = (text, category)
|
|
if onceregistry.get(oncekey):
|
|
return
|
|
onceregistry[oncekey] = 1
|
|
elif action == "always":
|
|
pass
|
|
elif action == "module":
|
|
registry[key] = 1
|
|
altkey = (text, category, 0)
|
|
if registry.get(altkey):
|
|
return
|
|
registry[altkey] = 1
|
|
elif action == "default":
|
|
registry[key] = 1
|
|
else:
|
|
# Unrecognized actions are errors
|
|
raise RuntimeError(
|
|
"Unrecognized action (%r) in warnings.filters:\n %s" %
|
|
(action, item))
|
|
# Warn if showwarning() does not support the 'line' argument.
|
|
# Don't use 'inspect' as it relies on an extension module, which break the
|
|
# build thanks to 'warnings' being imported by setup.py.
|
|
fxn_code = None
|
|
if hasattr(showwarning, 'func_code'):
|
|
fxn_code = showwarning.func_code
|
|
elif hasattr(showwarning, '__func__'):
|
|
fxn_code = showwarning.__func__.func_code
|
|
if fxn_code:
|
|
args = fxn_code.co_varnames[:fxn_code.co_argcount]
|
|
CO_VARARGS = 0x4
|
|
if 'line' not in args and not fxn_code.co_flags & CO_VARARGS:
|
|
showwarning_msg = ("functions overriding warnings.showwarning() "
|
|
"must support the 'line' argument")
|
|
if message == showwarning_msg:
|
|
_show_warning(message, category, filename, lineno)
|
|
else:
|
|
warn(showwarning_msg, DeprecationWarning)
|
|
# Print message and context
|
|
showwarning(message, category, filename, lineno)
|
|
|
|
|
|
class WarningMessage(object):
|
|
|
|
"""Holds the result of a single showwarning() call."""
|
|
|
|
_WARNING_DETAILS = ("message", "category", "filename", "lineno", "file",
|
|
"line")
|
|
|
|
def __init__(self, message, category, filename, lineno, file=None,
|
|
line=None):
|
|
local_values = locals()
|
|
for attr in self._WARNING_DETAILS:
|
|
setattr(self, attr, local_values[attr])
|
|
self._category_name = category.__name__ if category else None
|
|
|
|
def __str__(self):
|
|
return ("{message : %r, category : %r, filename : %r, lineno : %s, "
|
|
"line : %r}" % (self.message, self._category_name,
|
|
self.filename, self.lineno, self.line))
|
|
|
|
|
|
class catch_warnings(object):
|
|
|
|
"""A context manager that copies and restores the warnings filter upon
|
|
exiting the context.
|
|
|
|
The 'record' argument specifies whether warnings should be captured by a
|
|
custom implementation of warnings.showwarning() and be appended to a list
|
|
returned by the context manager. Otherwise None is returned by the context
|
|
manager. The objects appended to the list are arguments whose attributes
|
|
mirror the arguments to showwarning().
|
|
|
|
The 'module' argument is to specify an alternative module to the module
|
|
named 'warnings' and imported under that name. This argument is only useful
|
|
when testing the warnings module itself.
|
|
|
|
"""
|
|
|
|
def __init__(self, record=False, module=None):
|
|
"""Specify whether to record warnings and if an alternative module
|
|
should be used other than sys.modules['warnings'].
|
|
|
|
For compatibility with Python 3.0, please consider all arguments to be
|
|
keyword-only.
|
|
|
|
"""
|
|
self._record = record
|
|
self._module = sys.modules['warnings'] if module is None else module
|
|
self._entered = False
|
|
|
|
def __repr__(self):
|
|
args = []
|
|
if self._record:
|
|
args.append("record=True")
|
|
if self._module is not sys.modules['warnings']:
|
|
args.append("module=%r" % self._module)
|
|
name = type(self).__name__
|
|
return "%s(%s)" % (name, ", ".join(args))
|
|
|
|
def __enter__(self):
|
|
if self._entered:
|
|
raise RuntimeError("Cannot enter %r twice" % self)
|
|
self._entered = True
|
|
self._filters = self._module.filters
|
|
self._module.filters = self._filters[:]
|
|
self._showwarning = self._module.showwarning
|
|
if self._record:
|
|
log = []
|
|
def showwarning(*args, **kwargs):
|
|
log.append(WarningMessage(*args, **kwargs))
|
|
self._module.showwarning = showwarning
|
|
return log
|
|
else:
|
|
return None
|
|
|
|
def __exit__(self, *exc_info):
|
|
if not self._entered:
|
|
raise RuntimeError("Cannot exit %r without entering first" % self)
|
|
self._module.filters = self._filters
|
|
self._module.showwarning = self._showwarning
|
|
|
|
|
|
# filters contains a sequence of filter 5-tuples
|
|
# The components of the 5-tuple are:
|
|
# - an action: error, ignore, always, default, module, or once
|
|
# - a compiled regex that must match the warning message
|
|
# - a class representing the warning category
|
|
# - a compiled regex that must match the module that is being warned
|
|
# - a line number for the line being warning, or 0 to mean any line
|
|
# If either if the compiled regexs are None, match anything.
|
|
_warnings_defaults = False
|
|
try:
|
|
from _warnings import (filters, default_action, once_registry,
|
|
warn, warn_explicit)
|
|
defaultaction = default_action
|
|
onceregistry = once_registry
|
|
_warnings_defaults = True
|
|
except ImportError:
|
|
filters = []
|
|
defaultaction = "default"
|
|
onceregistry = {}
|
|
|
|
|
|
# Module initialization
|
|
_processoptions(sys.warnoptions)
|
|
if not _warnings_defaults:
|
|
simplefilter("ignore", category=PendingDeprecationWarning, append=1)
|
|
simplefilter("ignore", category=ImportWarning, append=1)
|
|
bytes_warning = sys.flags.bytes_warning
|
|
if bytes_warning > 1:
|
|
bytes_action = "error"
|
|
elif bytes_warning:
|
|
bytes_action = "default"
|
|
else:
|
|
bytes_action = "ignore"
|
|
simplefilter(bytes_action, category=BytesWarning, append=1)
|
|
del _warnings_defaults
|