cpython/Lib/warnings.py

275 lines
8.6 KiB
Python
Raw Normal View History

2000-12-15 17:59:53 -04:00
"""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 sys, types
import linecache
2000-12-15 17:59:53 -04:00
__all__ = ["warn", "showwarning", "formatwarning", "filterwarnings",
"resetwarnings"]
2000-12-15 17:59:53 -04:00
defaultaction = "default"
filters = []
onceregistry = {}
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):
2002-04-15 22:38:40 -03:00
category = message.__class__
2000-12-15 17:59:53 -04:00
# 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>"
2000-12-15 17:59:53 -04:00
filename = globals.get('__file__')
if filename:
fnl = filename.lower()
if fnl.endswith(".pyc") or fnl.endswith(".pyo"):
filename = filename[:-1]
else:
if module == "__main__":
filename = sys.argv[0]
if not filename:
filename = module
registry = globals.setdefault("__warningregistry__", {})
warn_explicit(message, category, filename, lineno, module, registry)
def warn_explicit(message, category, filename, lineno,
module=None, registry=None):
if module is None:
module = filename
if module[-3:].lower() == ".py":
module = module[:-3] # XXX What about leading pathname?
if registry is None:
registry = {}
if isinstance(message, Warning):
2002-04-15 22:38:40 -03:00
text = str(message)
category = message.__class__
else:
2002-04-15 22:38:40 -03:00
text = message
message = category(message)
key = (text, category, lineno)
# Quick test for common case
2000-12-15 17:59:53 -04:00
if registry.get(key):
return
# Search the filters
for item in filters:
action, msg, cat, mod, ln = item
if (msg.match(text) and
2000-12-15 17:59:53 -04:00
issubclass(category, cat) and
mod.match(module) and
(ln == 0 or lineno == ln)):
break
else:
action = defaultaction
# Early exit actions
if action == "ignore":
registry[key] = 1
return
if action == "error":
raise message
2000-12-15 17:59:53 -04:00
# Other actions
if action == "once":
registry[key] = 1
oncekey = (text, category)
2000-12-15 17:59:53 -04:00
if onceregistry.get(oncekey):
return
onceregistry[oncekey] = 1
elif action == "always":
pass
elif action == "module":
registry[key] = 1
altkey = (text, category, 0)
2000-12-15 17:59:53 -04:00
if registry.get(altkey):
return
registry[altkey] = 1
elif action == "default":
registry[key] = 1
else:
# Unrecognized actions are errors
raise RuntimeError(
"Unrecognized action (%s) in warnings.filters:\n %s" %
(`action`, str(item)))
# Print message and context
showwarning(message, category, filename, lineno)
def showwarning(message, category, filename, lineno, file=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))
except IOError:
pass # the file (probably stderr) is invalid - this warning gets lost.
2000-12-15 17:59:53 -04:00
def formatwarning(message, category, filename, lineno):
"""Function to format a warning the standard way."""
2000-12-15 17:59:53 -04:00
s = "%s:%s: %s: %s\n" % (filename, lineno, category.__name__, message)
line = linecache.getline(filename, lineno).strip()
if line:
s = s + " " + line + "\n"
return s
def filterwarnings(action, message="", category=Warning, module="", lineno=0,
append=0):
2000-12-15 17:59:53 -04:00
"""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
2000-12-15 17:59:53 -04:00
assert action in ("error", "ignore", "always", "default", "module",
"once"), "invalid action: %s" % `action`
assert isinstance(message, basestring), "message must be a string"
2000-12-15 17:59:53 -04:00
assert isinstance(category, 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, \
2000-12-15 17:59:53 -04:00
"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)
2000-12-15 17:59:53 -04:00
def resetwarnings():
"""Clear the list of warning filters, so that no filters are active."""
2000-12-15 17:59:53 -04:00
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): %s" % `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 %s" % `lineno`)
else:
lineno = 0
filterwarnings(action, message, category, module, lineno)
2000-12-15 17:59:53 -04:00
# 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: %s" % `action`)
# Helper for _setoption()
def _getcategory(category):
import re
2000-12-15 17:59:53 -04:00
if not category:
return Warning
if re.match("^[a-zA-Z0-9_]+$", category):
try:
cat = eval(category)
except NameError:
raise _OptionError("unknown warning category: %s" % `category`)
2000-12-15 17:59:53 -04:00
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: %s" % `module`)
try:
cat = getattr(m, klass)
except AttributeError:
raise _OptionError("unknown warning category: %s" % `category`)
2000-12-15 17:59:53 -04:00
if (not isinstance(cat, types.ClassType) or
not issubclass(cat, Warning)):
raise _OptionError("invalid warning category: %s" % `category`)
return cat
# Self-test
def _test():
import getopt
testoptions = []
try:
opts, args = getopt.getopt(sys.argv[1:], "W:")
except getopt.error, msg:
print >>sys.stderr, msg
return
for o, a in opts:
testoptions.append(a)
try:
_processoptions(testoptions)
except _OptionError, msg:
print >>sys.stderr, msg
return
for item in filters: print item
hello = "hello world"
warn(hello); warn(hello); warn(hello); warn(hello)
warn(hello, UserWarning)
warn(hello, DeprecationWarning)
for i in range(3):
warn(hello)
filterwarnings("error", "", Warning, "", 0)
try:
warn(hello)
except Exception, msg:
print "Caught", msg.__class__.__name__ + ":", msg
else:
print "No exception"
resetwarnings()
try:
filterwarnings("booh", "", Warning, "", 0)
except Exception, msg:
print "Caught", msg.__class__.__name__ + ":", msg
else:
print "No exception"
# Module initialization
if __name__ == "__main__":
import __main__
sys.modules['warnings'] = __main__
_test()
else:
_processoptions(sys.warnoptions)
filterwarnings("ignore", category=OverflowWarning, append=1)
filterwarnings("ignore", category=PendingDeprecationWarning, append=1)