"""Python part of the warnings subsystem."""
# Note: function level imports should *not* be used
# in this module as it may cause import lock deadlock.
__all__ = ["warn", "warn_explicit", "showwarning",
"formatwarning", "filterwarnings", "simplefilter",
"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.
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."""
# sys.stderr is None - warnings get lost
file.write(formatwarning(message, category, filename, lineno, line))
except (IOError, UnicodeError):
pass # the file (probably stderr) is invalid - this warning gets lost.
# Keep a working version around in case the deprecation of the old API is
showwarning = _show_warning
def formatwarning(message, category, filename, lineno, line=None):
"""Function to format a warning the standard way."""
except UnicodeEncodeError:
s = "%s: %s: %s\n" % (lineno, category.__name__, message)
line = linecache.getline(filename, lineno) if line is None else line
if isinstance(s, unicodetype) and isinstance(line, str):
line = unicode(line, 'latin1')
if isinstance(s, unicodetype) and isinstance(filename, str):
enc = sys.getfilesystemencoding()
filename = unicode(filename, enc)
except UnicodeDecodeError:
s = "%s:%s" % (filename, s)
def filterwarnings(action, message="", category=Warning, module="", lineno=0,
"""Insert an entry into the list of warnings filters (at the front).
'action' -- one of "error", "ignore", "always", "default", "module",
'message' -- a regex that the warning message must match
'category' -- a class that the warning must be a subclass of
'module' -- a regex that the module name must match
'lineno' -- an integer line number, 0 matches all warnings
'append' -- if true, append to the list of filters
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)
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.
'action' -- one of "error", "ignore", "always", "default", "module",
'category' -- a class that the warning must be a subclass of
'lineno' -- an integer line number, 0 matches all warnings
'append' -- if true, append to the list of filters
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)
"""Clear the list of warning filters, so that no filters are active."""
class _OptionError(Exception):
"""Exception used by option processing helpers."""
# Helper to process -W options passed via sys.warnoptions
def _processoptions(args):
except _OptionError, msg:
print >>sys.stderr, "Invalid -W option ignored:", msg
# Helper for _processoptions()
raise _OptionError("too many fields (max 5): %r" % (arg,))
action, message, category, module, lineno = [s.strip()
action = _getaction(action)
message = re.escape(message)
category = _getcategory(category)
module = re.escape(module)
except (ValueError, OverflowError):
raise _OptionError("invalid lineno %r" % (lineno,))
filterwarnings(action, message, category, module, lineno)
# Helper for _setoption()
if action == "all": return "always" # Alias
for a in ('default', 'always', 'ignore', 'module', 'once', 'error'):
raise _OptionError("invalid action: %r" % (action,))
# Helper for _setoption()
def _getcategory(category):
if re.match("^[a-zA-Z0-9_]+$", category):
raise _OptionError("unknown warning category: %r" % (category,))
m = __import__(module, None, None, [klass])
raise _OptionError("invalid module name: %r" % (module,))
raise _OptionError("unknown warning category: %r" % (category,))
if not issubclass(cat, Warning):
raise _OptionError("invalid warning category: %r" % (category,))
# 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
assert issubclass(category, Warning)
# Get context information
caller = sys._getframe(stacklevel)
globals = caller.f_globals
if '__name__' in globals:
module = globals['__name__']
filename = globals.get('__file__')
if fnl.endswith((".pyc", ".pyo")):
# embedded interpreters don't have sys.argv, see bug #839151
registry = globals.setdefault("__warningregistry__", {})
warn_explicit(message, category, filename, lineno, module, registry,
def warn_explicit(message, category, filename, lineno,
module=None, registry=None, module_globals=None):
module = filename or "<unknown>"
if module[-3:].lower() == ".py":
module = module[:-3] # XXX What about leading pathname?
if isinstance(message, Warning):
category = message.__class__
message = category(message)
key = (text, category, lineno)
# Quick test for common case
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)):
# Prime the linecache for formatting, in case the
# "file" is actually in a zipfile or something.
linecache.getlines(filename, module_globals)
oncekey = (text, category)
if onceregistry.get(oncekey):
onceregistry[oncekey] = 1
altkey = (text, category, 0)
elif action == "default":
# Unrecognized actions are errors
"Unrecognized action (%r) in warnings.filters:\n %s" %
# 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",
def __init__(self, message, category, filename, lineno, file=None,
for attr in self._WARNING_DETAILS:
setattr(self, attr, local_values[attr])
self._category_name = category.__name__ if category else None
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
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
self._module = sys.modules['warnings'] if module is None else module
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))
raise RuntimeError("Cannot enter %r twice" % self)
self._filters = self._module.filters
self._module.filters = self._filters[:]
self._showwarning = self._module.showwarning
def showwarning(*args, **kwargs):
log.append(WarningMessage(*args, **kwargs))
self._module.showwarning = showwarning
def __exit__(self, *exc_info):
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
from _warnings import (filters, default_action, once_registry,
defaultaction = default_action
onceregistry = once_registry
_warnings_defaults = True
defaultaction = "default"
_processoptions(sys.warnoptions)
if not _warnings_defaults:
silence = [ImportWarning, PendingDeprecationWarning]
# Don't silence DeprecationWarning if -3 or -Q was used.
if not sys.py3kwarning and not sys.flags.division_warning:
silence.append(DeprecationWarning)
simplefilter("ignore", category=cls)
bytes_warning = sys.flags.bytes_warning
simplefilter(bytes_action, category=BytesWarning, append=1)
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
