warnings.py 13.5 KB
Newer Older
1 2
"""Python part of the warnings subsystem."""

3 4 5 6
# Note: function level imports should *not* be used
# in this module as it may cause import lock deadlock.
# See bug 683658.
import linecache
Christian Heimes's avatar
Christian Heimes committed
7
import sys
8

9
__all__ = ["warn", "showwarning", "formatwarning", "filterwarnings",
10
           "resetwarnings", "catch_warnings"]
11

12

Christian Heimes's avatar
Christian Heimes committed
13
def showwarning(message, category, filename, lineno, file=None, line=None):
14 15 16
    """Hook to write a warning to a file; replace if you like."""
    if file is None:
        file = sys.stderr
17
    try:
Christian Heimes's avatar
Christian Heimes committed
18
        file.write(formatwarning(message, category, filename, lineno, line))
19 20
    except IOError:
        pass # the file (probably stderr) is invalid - this warning gets lost.
21

Christian Heimes's avatar
Christian Heimes committed
22
def formatwarning(message, category, filename, lineno, line=None):
23
    """Function to format a warning the standard way."""
24
    s =  "%s:%s: %s: %s\n" % (filename, lineno, category.__name__, message)
Christian Heimes's avatar
Christian Heimes committed
25
    line = linecache.getline(filename, lineno) if line is None else line
26
    if line:
Christian Heimes's avatar
Christian Heimes committed
27 28
        line = line.strip()
        s += "  %s\n" % line
29 30
    return s

31
def filterwarnings(action, message="", category=Warning, module="", lineno=0,
32
                   append=False):
33 34
    """Insert an entry into the list of warnings filters (at the front).

Georg Brandl's avatar
Georg Brandl committed
35 36 37 38 39 40 41 42
    'action' -- one of "error", "ignore", "always", "default", "module",
                or "once"
    '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
    """
43
    import re
44
    assert action in ("error", "ignore", "always", "default", "module",
45
                      "once"), "invalid action: %r" % (action,)
46
    assert isinstance(message, str), "message must be a string"
47
    assert isinstance(category, type), "category must be a class"
48
    assert issubclass(category, Warning), "category must be a Warning subclass"
49
    assert isinstance(module, str), "module must be a string"
50
    assert isinstance(lineno, int) and lineno >= 0, \
51
           "lineno must be an int >= 0"
52 53 54 55 56 57
    item = (action, re.compile(message, re.I), category,
            re.compile(module), lineno)
    if append:
        filters.append(item)
    else:
        filters.insert(0, item)
58

59
def simplefilter(action, category=Warning, lineno=0, append=False):
60 61 62
    """Insert a simple entry into the list of warnings filters (at the front).

    A simple filter matches all modules and messages.
Georg Brandl's avatar
Georg Brandl committed
63 64 65 66 67
    'action' -- one of "error", "ignore", "always", "default", "module",
                or "once"
    '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
68 69
    """
    assert action in ("error", "ignore", "always", "default", "module",
70
                      "once"), "invalid action: %r" % (action,)
71 72 73 74 75 76 77 78
    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)

79
def resetwarnings():
80
    """Clear the list of warning filters, so that no filters are active."""
81 82 83 84 85 86 87 88 89 90 91
    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)
92
        except _OptionError as msg:
93
            print("Invalid -W option ignored:", msg, file=sys.stderr)
94 95 96

# Helper for _processoptions()
def _setoption(arg):
97
    import re
98 99
    parts = arg.split(':')
    if len(parts) > 5:
100
        raise _OptionError("too many fields (max 5): %r" % (arg,))
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
    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):
117
            raise _OptionError("invalid lineno %r" % (lineno,))
118 119 120
    else:
        lineno = 0
    filterwarnings(action, message, category, module, lineno)
121 122 123 124 125 126

# Helper for _setoption()
def _getaction(action):
    if not action:
        return "default"
    if action == "all": return "always" # Alias
127
    for a in ('default', 'always', 'ignore', 'module', 'once', 'error'):
128 129
        if a.startswith(action):
            return a
130
    raise _OptionError("invalid action: %r" % (action,))
131 132 133

# Helper for _setoption()
def _getcategory(category):
134
    import re
135 136 137 138 139
    if not category:
        return Warning
    if re.match("^[a-zA-Z0-9_]+$", category):
        try:
            cat = eval(category)
140
        except NameError:
141
            raise _OptionError("unknown warning category: %r" % (category,))
142 143 144 145
    else:
        i = category.rfind(".")
        module = category[:i]
        klass = category[i+1:]
146 147 148
        try:
            m = __import__(module, None, None, [klass])
        except ImportError:
149
            raise _OptionError("invalid module name: %r" % (module,))
150 151 152
        try:
            cat = getattr(m, klass)
        except AttributeError:
153
            raise _OptionError("unknown warning category: %r" % (category,))
154
    if not issubclass(cat, Warning):
155
        raise _OptionError("invalid warning category: %r" % (category,))
156 157
    return cat

Christian Heimes's avatar
Christian Heimes committed
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201

# 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):
202
    lineno = int(lineno)
Christian Heimes's avatar
Christian Heimes committed
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261
    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))
262
    if not callable(showwarning):
263 264
        raise TypeError("warnings.showwarning() must be set to a "
                        "function or method")
Christian Heimes's avatar
Christian Heimes committed
265 266 267 268
    # Print message and context
    showwarning(message, category, filename, lineno)


269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
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):

291 292 293 294 295 296 297 298
    """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().
299

300 301 302
    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.
303 304 305 306 307 308 309 310 311 312 313

    """

    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.

        """
314
        self._record = record
315
        self._module = sys.modules['warnings'] if module is None else module
Benjamin Peterson's avatar
Benjamin Peterson committed
316 317 318 319 320 321 322 323 324 325
        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))
326 327

    def __enter__(self):
Benjamin Peterson's avatar
Benjamin Peterson committed
328 329 330
        if self._entered:
            raise RuntimeError("Cannot enter %r twice" % self)
        self._entered = True
331 332 333
        self._filters = self._module.filters
        self._module.filters = self._filters[:]
        self._showwarning = self._module.showwarning
334 335 336 337 338 339 340 341
        if self._record:
            log = []
            def showwarning(*args, **kwargs):
                log.append(WarningMessage(*args, **kwargs))
            self._module.showwarning = showwarning
            return log
        else:
            return None
342 343

    def __exit__(self, *exc_info):
Benjamin Peterson's avatar
Benjamin Peterson committed
344 345
        if not self._entered:
            raise RuntimeError("Cannot exit %r without entering first" % self)
346 347 348 349
        self._module.filters = self._filters
        self._module.showwarning = self._showwarning


Christian Heimes's avatar
Christian Heimes committed
350 351 352 353 354 355 356 357 358 359
# 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:
360
    from _warnings import (filters, _defaultaction, _onceregistry,
Christian Heimes's avatar
Christian Heimes committed
361
                            warn, warn_explicit)
362 363
    defaultaction = _defaultaction
    onceregistry = _onceregistry
Christian Heimes's avatar
Christian Heimes committed
364 365 366 367 368 369 370
    _warnings_defaults = True
except ImportError:
    filters = []
    defaultaction = "default"
    onceregistry = {}


371
# Module initialization
372
_processoptions(sys.warnoptions)
Christian Heimes's avatar
Christian Heimes committed
373
if not _warnings_defaults:
374 375 376 377
    silence = [ImportWarning, PendingDeprecationWarning]
    silence.append(DeprecationWarning)
    for cls in silence:
        simplefilter("ignore", category=cls)
Christian Heimes's avatar
Christian Heimes committed
378 379 380 381 382 383 384 385
    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)
386 387 388 389 390 391 392
    # resource usage warnings are enabled by default in pydebug mode
    if hasattr(sys, 'gettotalrefcount'):
        resource_action = "always"
    else:
        resource_action = "ignore"
    simplefilter(resource_action, category=ResourceWarning, append=1)

Christian Heimes's avatar
Christian Heimes committed
393
del _warnings_defaults