1 """Python part of the warnings subsystem.""" 2 3 # Note: function level imports should *not* be used 4 # in this module as it may cause import lock deadlock. 5 # See bug 683658. 6 import linecache 7 import sys 8 import types 9 10 __all__ = ["warn", "showwarning", "formatwarning", "filterwarnings", 11 "resetwarnings", "catch_warnings"] 12 13 14 def warnpy3k(message, category=None, stacklevel=1): 15 """Issue a deprecation warning for Python 3.x related changes. 16 17 Warnings are omitted unless Python is started with the -3 option. 18 """ 19 if sys.py3kwarning: 20 if category is None: 21 category = DeprecationWarning 22 warn(message, category, stacklevel+1) 23 24 def _show_warning(message, category, filename, lineno, file=None, line=None): 25 """Hook to write a warning to a file; replace if you like.""" 26 if file is None: 27 file = sys.stderr 28 try: 29 file.write(formatwarning(message, category, filename, lineno, line)) 30 except IOError: 31 pass # the file (probably stderr) is invalid - this warning gets lost. 32 # Keep a working version around in case the deprecation of the old API is 33 # triggered. 34 showwarning = _show_warning 35 36 def formatwarning(message, category, filename, lineno, line=None): 37 """Function to format a warning the standard way.""" 38 s = "%s:%s: %s: %s\n" % (filename, lineno, category.__name__, message) 39 line = linecache.getline(filename, lineno) if line is None else line 40 if line: 41 line = line.strip() 42 s += " %s\n" % line 43 return s 44 45 def filterwarnings(action, message="", category=Warning, module="", lineno=0, 46 append=0): 47 """Insert an entry into the list of warnings filters (at the front). 48 49 'action' -- one of "error", "ignore", "always", "default", "module", 50 or "once" 51 'message' -- a regex that the warning message must match 52 'category' -- a class that the warning must be a subclass of 53 'module' -- a regex that the module name must match 54 'lineno' -- an integer line number, 0 matches all warnings 55 'append' -- if true, append to the list of filters 56 """ 57 import re 58 assert action in ("error", "ignore", "always", "default", "module", 59 "once"), "invalid action: %r" % (action,) 60 assert isinstance(message, basestring), "message must be a string" 61 assert isinstance(category, (type, types.ClassType)), \ 62 "category must be a class" 63 assert issubclass(category, Warning), "category must be a Warning subclass" 64 assert isinstance(module, basestring), "module must be a string" 65 assert isinstance(lineno, int) and lineno >= 0, \ 66 "lineno must be an int >= 0" 67 item = (action, re.compile(message, re.I), category, 68 re.compile(module), lineno) 69 if append: 70 filters.append(item) 71 else: 72 filters.insert(0, item) 73 74 def simplefilter(action, category=Warning, lineno=0, append=0): 75 """Insert a simple entry into the list of warnings filters (at the front). 76 77 A simple filter matches all modules and messages. 78 'action' -- one of "error", "ignore", "always", "default", "module", 79 or "once" 80 'category' -- a class that the warning must be a subclass of 81 'lineno' -- an integer line number, 0 matches all warnings 82 'append' -- if true, append to the list of filters 83 """ 84 assert action in ("error", "ignore", "always", "default", "module", 85 "once"), "invalid action: %r" % (action,) 86 assert isinstance(lineno, int) and lineno >= 0, \ 87 "lineno must be an int >= 0" 88 item = (action, None, category, None, lineno) 89 if append: 90 filters.append(item) 91 else: 92 filters.insert(0, item) 93 94 def resetwarnings(): 95 """Clear the list of warning filters, so that no filters are active.""" 96 filters[:] = [] 97 98 class _OptionError(Exception): 99 """Exception used by option processing helpers.""" 100 pass 101 102 # Helper to process -W options passed via sys.warnoptions 103 def _processoptions(args): 104 for arg in args: 105 try: 106 _setoption(arg) 107 except _OptionError, msg: 108 print >>sys.stderr, "Invalid -W option ignored:", msg 109 110 # Helper for _processoptions() 111 def _setoption(arg): 112 import re 113 parts = arg.split(':') 114 if len(parts) > 5: 115 raise _OptionError("too many fields (max 5): %r" % (arg,)) 116 while len(parts) < 5: 117 parts.append('') 118 action, message, category, module, lineno = [s.strip() 119 for s in parts] 120 action = _getaction(action) 121 message = re.escape(message) 122 category = _getcategory(category) 123 module = re.escape(module) 124 if module: 125 module = module + '$' 126 if lineno: 127 try: 128 lineno = int(lineno) 129 if lineno < 0: 130 raise ValueError 131 except (ValueError, OverflowError): 132 raise _OptionError("invalid lineno %r" % (lineno,)) 133 else: 134 lineno = 0 135 filterwarnings(action, message, category, module, lineno) 136 137 # Helper for _setoption() 138 def _getaction(action): 139 if not action: 140 return "default" 141 if action == "all": return "always" # Alias 142 for a in ('default', 'always', 'ignore', 'module', 'once', 'error'): 143 if a.startswith(action): 144 return a 145 raise _OptionError("invalid action: %r" % (action,)) 146 147 # Helper for _setoption() 148 def _getcategory(category): 149 import re 150 if not category: 151 return Warning 152 if re.match("^[a-zA-Z0-9_]+$", category): 153 try: 154 cat = eval(category) 155 except NameError: 156 raise _OptionError("unknown warning category: %r" % (category,)) 157 else: 158 i = category.rfind(".") 159 module = category[:i] 160 klass = category[i+1:] 161 try: 162 m = __import__(module, None, None, [klass]) 163 except ImportError: 164 raise _OptionError("invalid module name: %r" % (module,)) 165 try: 166 cat = getattr(m, klass) 167 except AttributeError: 168 raise _OptionError("unknown warning category: %r" % (category,)) 169 if not issubclass(cat, Warning): 170 raise _OptionError("invalid warning category: %r" % (category,)) 171 return cat 172 173 174 # Code typically replaced by _warnings 175 def warn(message, category=None, stacklevel=1): 176 """Issue a warning, or maybe ignore it or raise an exception.""" 177 # Check if message is already a Warning object 178 if isinstance(message, Warning): 179 category = message.__class__ 180 # Check category argument 181 if category is None: 182 category = UserWarning 183 assert issubclass(category, Warning) 184 # Get context information 185 try: 186 caller = sys._getframe(stacklevel) 187 except ValueError: 188 globals = sys.__dict__ 189 lineno = 1 190 else: 191 globals = caller.f_globals 192 lineno = caller.f_lineno 193 if '__name__' in globals: 194 module = globals['__name__'] 195 else: 196 module = "<string>" 197 filename = globals.get('__file__') 198 if filename: 199 fnl = filename.lower() 200 if fnl.endswith((".pyc", ".pyo")): 201 filename = filename[:-1] 202 else: 203 if module == "__main__": 204 try: 205 filename = sys.argv[0] 206 except AttributeError: 207 # embedded interpreters don't have sys.argv, see bug #839151 208 filename = '__main__' 209 if not filename: 210 filename = module 211 registry = globals.setdefault("__warningregistry__", {}) 212 warn_explicit(message, category, filename, lineno, module, registry, 213 globals) 214 215 def warn_explicit(message, category, filename, lineno, 216 module=None, registry=None, module_globals=None): 217 lineno = int(lineno) 218 if module is None: 219 module = filename or "<unknown>" 220 if module[-3:].lower() == ".py": 221 module = module[:-3] # XXX What about leading pathname? 222 if registry is None: 223 registry = {} 224 if isinstance(message, Warning): 225 text = str(message) 226 category = message.__class__ 227 else: 228 text = message 229 message = category(message) 230 key = (text, category, lineno) 231 # Quick test for common case 232 if registry.get(key): 233 return 234 # Search the filters 235 for item in filters: 236 action, msg, cat, mod, ln = item 237 if ((msg is None or msg.match(text)) and 238 issubclass(category, cat) and 239 (mod is None or mod.match(module)) and 240 (ln == 0 or lineno == ln)): 241 break 242 else: 243 action = defaultaction 244 # Early exit actions 245 if action == "ignore": 246 registry[key] = 1 247 return 248 249 # Prime the linecache for formatting, in case the 250 # "file" is actually in a zipfile or something. 251 linecache.getlines(filename, module_globals) 252 253 if action == "error": 254 raise message 255 # Other actions 256 if action == "once": 257 registry[key] = 1 258 oncekey = (text, category) 259 if onceregistry.get(oncekey): 260 return 261 onceregistry[oncekey] = 1 262 elif action == "always": 263 pass 264 elif action == "module": 265 registry[key] = 1 266 altkey = (text, category, 0) 267 if registry.get(altkey): 268 return 269 registry[altkey] = 1 270 elif action == "default": 271 registry[key] = 1 272 else: 273 # Unrecognized actions are errors 274 raise RuntimeError( 275 "Unrecognized action (%r) in warnings.filters:\n %s" % 276 (action, item)) 277 # Print message and context 278 showwarning(message, category, filename, lineno) 279 280 281 class WarningMessage(object): 282 283 """Holds the result of a single showwarning() call.""" 284 285 _WARNING_DETAILS = ("message", "category", "filename", "lineno", "file", 286 "line") 287 288 def __init__(self, message, category, filename, lineno, file=None, 289 line=None): 290 local_values = locals() 291 for attr in self._WARNING_DETAILS: 292 setattr(self, attr, local_values[attr]) 293 self._category_name = category.__name__ if category else None 294 295 def __str__(self): 296 return ("{message : %r, category : %r, filename : %r, lineno : %s, " 297 "line : %r}" % (self.message, self._category_name, 298 self.filename, self.lineno, self.line)) 299 300 301 class catch_warnings(object): 302 303 """A context manager that copies and restores the warnings filter upon 304 exiting the context. 305 306 The 'record' argument specifies whether warnings should be captured by a 307 custom implementation of warnings.showwarning() and be appended to a list 308 returned by the context manager. Otherwise None is returned by the context 309 manager. The objects appended to the list are arguments whose attributes 310 mirror the arguments to showwarning(). 311 312 The 'module' argument is to specify an alternative module to the module 313 named 'warnings' and imported under that name. This argument is only useful 314 when testing the warnings module itself. 315 316 """ 317 318 def __init__(self, record=False, module=None): 319 """Specify whether to record warnings and if an alternative module 320 should be used other than sys.modules['warnings']. 321 322 For compatibility with Python 3.0, please consider all arguments to be 323 keyword-only. 324 325 """ 326 self._record = record 327 self._module = sys.modules['warnings'] if module is None else module 328 self._entered = False 329 330 def __repr__(self): 331 args = [] 332 if self._record: 333 args.append("record=True") 334 if self._module is not sys.modules['warnings']: 335 args.append("module=%r" % self._module) 336 name = type(self).__name__ 337 return "%s(%s)" % (name, ", ".join(args)) 338 339 def __enter__(self): 340 if self._entered: 341 raise RuntimeError("Cannot enter %r twice" % self) 342 self._entered = True 343 self._filters = self._module.filters 344 self._module.filters = self._filters[:] 345 self._showwarning = self._module.showwarning 346 if self._record: 347 log = [] 348 def showwarning(*args, **kwargs): 349 log.append(WarningMessage(*args, **kwargs)) 350 self._module.showwarning = showwarning 351 return log 352 else: 353 return None 354 355 def __exit__(self, *exc_info): 356 if not self._entered: 357 raise RuntimeError("Cannot exit %r without entering first" % self) 358 self._module.filters = self._filters 359 self._module.showwarning = self._showwarning 360 361 362 # filters contains a sequence of filter 5-tuples 363 # The components of the 5-tuple are: 364 # - an action: error, ignore, always, default, module, or once 365 # - a compiled regex that must match the warning message 366 # - a class representing the warning category 367 # - a compiled regex that must match the module that is being warned 368 # - a line number for the line being warning, or 0 to mean any line 369 # If either if the compiled regexs are None, match anything. 370 _warnings_defaults = False 371 try: 372 from _warnings import (filters, default_action, once_registry, 373 warn, warn_explicit) 374 defaultaction = default_action 375 onceregistry = once_registry 376 _warnings_defaults = True 377 except ImportError: 378 filters = [] 379 defaultaction = "default" 380 onceregistry = {} 381 382 383 # Module initialization 384 _processoptions(sys.warnoptions) 385 if not _warnings_defaults: 386 silence = [ImportWarning, PendingDeprecationWarning] 387 # Don't silence DeprecationWarning if -3 or -Q was used. 388 if not sys.py3kwarning and not sys.flags.division_warning: 389 silence.append(DeprecationWarning) 390 for cls in silence: 391 simplefilter("ignore", category=cls) 392 bytes_warning = sys.flags.bytes_warning 393 if bytes_warning > 1: 394 bytes_action = "error" 395 elif bytes_warning: 396 bytes_action = "default" 397 else: 398 bytes_action = "ignore" 399 simplefilter(bytes_action, category=BytesWarning, append=1) 400 del _warnings_defaults 401
