[Jython-checkins] jython: Update warnings for 2.7.
frank.wierzbicki
jython-checkins at python.org
Tue May 29 03:00:53 CEST 2012
http://hg.python.org/jython/rev/b5cfa63c8967
changeset: 6670:b5cfa63c8967
user: Miki Tebeka <miki.tebeka at gmail.com>
date: Fri May 25 12:58:21 2012 -0700
summary:
Update warnings for 2.7.
files:
ACKNOWLEDGMENTS | 1 +
Lib/_warnings.py | 363 ++++++++++++++++++++
Lib/test/test_warnings.py | 89 ++-
Lib/warnings.py | 3 +-
src/org/python/util/jython.java | 55 ++-
5 files changed, 470 insertions(+), 41 deletions(-)
diff --git a/ACKNOWLEDGMENTS b/ACKNOWLEDGMENTS
--- a/ACKNOWLEDGMENTS
+++ b/ACKNOWLEDGMENTS
@@ -94,6 +94,7 @@
Alex Groenholm
Anselm Kruis
Dmitry Jemerov
+ Miki Tebeka
Local Variables:
mode: indented-text
diff --git a/Lib/_warnings.py b/Lib/_warnings.py
new file mode 100644
--- /dev/null
+++ b/Lib/_warnings.py
@@ -0,0 +1,363 @@
+"""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"]
+
+onceregistry = {}
+
+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 working 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).
+
+ '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
+ """
+ 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.
+ '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
+ """
+ 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
+
+onceregistry = {}
+
+# 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]
+ elif fnl.endswith("$py.class"):
+ filename = filename[:-9] + '.py'
+ else:
+ if module == "__main__":
+ try:
+ filename = sys.argv[0]
+ except (AttributeError, TypeError):
+ # 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))
+ # 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
diff --git a/Lib/test/test_warnings.py b/Lib/test/test_warnings.py
--- a/Lib/test/test_warnings.py
+++ b/Lib/test/test_warnings.py
@@ -1,4 +1,5 @@
from contextlib import contextmanager
+import marshal
import linecache
import os
import StringIO
@@ -10,6 +11,9 @@
import warning_tests
+warning_tests_file = os.path.splitext(warning_tests.__file__)[0] + '.py'
+warning_tests_file = warning_tests_file.replace('$py', '') # Jython
+
import warnings as original_warnings
py_warnings = test_support.import_fresh_module('warnings', blocked=['_warnings'])
@@ -519,7 +523,7 @@
self.assertEqual(result.count('\n'), 2,
"Too many newlines in %r" % result)
first_line, second_line = result.split('\n', 1)
- expected_file = os.path.splitext(warning_tests.__file__)[0] + '.py'
+ expected_file = warning_tests_file
first_line_parts = first_line.rsplit(':', 3)
path, line, warning_class, message = first_line_parts
line = int(line)
@@ -551,7 +555,7 @@
def test_formatwarning(self):
message = "msg"
category = Warning
- file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
+ file_name = warning_tests_file
line_num = 3
file_line = linecache.getline(file_name, line_num).strip()
format = "%s:%s: %s: %s\n %s\n"
@@ -567,7 +571,7 @@
category, file_name, line_num, file_line))
def test_showwarning(self):
- file_name = os.path.splitext(warning_tests.__file__)[0] + '.py'
+ file_name = warning_tests_file
line_num = 3
expected_file_line = linecache.getline(file_name, line_num).strip()
message = 'msg'
@@ -706,35 +710,42 @@
class EnvironmentVariableTests(BaseTest):
+ def check_child(self, env, cmdline, expected):
+ newenv = os.environ.copy()
+ newenv["PYTHONWARNINGS"] = env
+
+ cmd = [sys.executable]
+ if cmdline:
+ cmd.extend(["-W", cmdline])
+
+ cmd.extend([
+ "-c",
+ "import sys, marshal; marshal.dump(sys.warnoptions, sys.stdout)",
+ ])
+
+ p = subprocess.Popen(cmd, stdout=subprocess.PIPE, env=newenv)
+ self.assertEqual(p.wait(), 0)
+ child_opts = marshal.load(p.stdout)
+ self.assertEqual(set(child_opts), set(expected))
+
def test_single_warning(self):
- newenv = os.environ.copy()
- newenv["PYTHONWARNINGS"] = "ignore::DeprecationWarning"
- p = subprocess.Popen([sys.executable,
- "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
- stdout=subprocess.PIPE, env=newenv)
- self.assertEqual(p.communicate()[0], "['ignore::DeprecationWarning']")
- self.assertEqual(p.wait(), 0)
+ self.check_child(
+ "ignore::DeprecationWarning",
+ None,
+ ["ignore::DeprecationWarning"])
def test_comma_separated_warnings(self):
- newenv = os.environ.copy()
- newenv["PYTHONWARNINGS"] = ("ignore::DeprecationWarning,"
- "ignore::UnicodeWarning")
- p = subprocess.Popen([sys.executable,
- "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
- stdout=subprocess.PIPE, env=newenv)
- self.assertEqual(p.communicate()[0],
- "['ignore::DeprecationWarning', 'ignore::UnicodeWarning']")
- self.assertEqual(p.wait(), 0)
+ self.check_child(
+ "ignore::DeprecationWarning,ignore::UnicodeWarning",
+ None,
+ ['ignore::DeprecationWarning', 'ignore::UnicodeWarning'])
def test_envvar_and_command_line(self):
- newenv = os.environ.copy()
- newenv["PYTHONWARNINGS"] = "ignore::DeprecationWarning"
- p = subprocess.Popen([sys.executable, "-W" "ignore::UnicodeWarning",
- "-c", "import sys; sys.stdout.write(str(sys.warnoptions))"],
- stdout=subprocess.PIPE, env=newenv)
- self.assertEqual(p.communicate()[0],
- "['ignore::UnicodeWarning', 'ignore::DeprecationWarning']")
- self.assertEqual(p.wait(), 0)
+ self.check_child(
+ "ignore::DeprecationWarning",
+ "ignore::UnicodeWarning",
+ ['ignore::UnicodeWarning', 'ignore::DeprecationWarning'])
+
class CEnvironmentVariableTests(EnvironmentVariableTests):
module = c_warnings
@@ -746,15 +757,21 @@
def test_main():
py_warnings.onceregistry.clear()
c_warnings.onceregistry.clear()
- test_support.run_unittest(CFilterTests, PyFilterTests,
- CWarnTests, PyWarnTests,
- CWCmdLineTests, PyWCmdLineTests,
- _WarningsTests,
- CWarningsDisplayTests, PyWarningsDisplayTests,
- CCatchWarningTests, PyCatchWarningTests,
- CEnvironmentVariableTests,
- PyEnvironmentVariableTests
- )
+ test_support.run_unittest(
+ CFilterTests,
+ PyFilterTests,
+ CWarnTests,
+ PyWarnTests,
+ CWCmdLineTests,
+ PyWCmdLineTests,
+ _WarningsTests,
+ CWarningsDisplayTests,
+ PyWarningsDisplayTests,
+ CCatchWarningTests,
+ PyCatchWarningTests,
+ CEnvironmentVariableTests,
+ PyEnvironmentVariableTests
+ )
if __name__ == "__main__":
diff --git a/Lib/warnings.py b/Lib/warnings.py
--- a/Lib/warnings.py
+++ b/Lib/warnings.py
@@ -10,6 +10,7 @@
__all__ = ["warn", "showwarning", "formatwarning", "filterwarnings",
"resetwarnings", "catch_warnings"]
+onceregistry = {}
def warnpy3k(message, category=None, stacklevel=1):
"""Issue a deprecation warning for Python 3.x related changes.
@@ -205,7 +206,7 @@
if module == "__main__":
try:
filename = sys.argv[0]
- except AttributeError:
+ except (AttributeError, TypeError):
# embedded interpreters don't have sys.argv, see bug #839151
filename = '__main__'
if not filename:
diff --git a/src/org/python/util/jython.java b/src/org/python/util/jython.java
--- a/src/org/python/util/jython.java
+++ b/src/org/python/util/jython.java
@@ -7,6 +7,8 @@
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import java.util.zip.ZipEntry;
@@ -136,6 +138,45 @@
} while (shouldRestart);
}
+ private static List<String> warnOptionsFromEnv() {
+ ArrayList<String> opts = new ArrayList<String>();
+
+ try {
+ String envVar = System.getenv("PYTHONWARNINGS");
+ if (envVar == null) {
+ return opts;
+ }
+
+
+ for (String opt : envVar.split(",")) {
+ opt = opt.trim();
+ if (opt.length() == 0) {
+ continue;
+ }
+ opts.add(opt);
+ }
+ } catch (SecurityException e) {
+ }
+
+ return opts;
+ }
+
+ private static List<String> validWarnActions = Arrays.asList(
+ "error", "ignore", "always", "default", "module", "once",
+ "i");
+
+ private static void addWarnings(List<String> from, PyList to) {
+ for (String opt : from) {
+ String action = opt.split(":")[0];
+ if (!validWarnActions.contains(action)) {
+ System.err.println(String.format(
+ "Invalid -W option ignored: invalid action: '%s'", action));
+ continue;
+ }
+ to.append(Py.newString(opt));
+ }
+ }
+
public static void run(String[] args) {
// Parse the command line options
CommandLineOptions opts = new CommandLineOptions();
@@ -157,14 +198,20 @@
// Setup the basic python system state from these options
PySystemState.initialize(PySystemState.getBaseProperties(), opts.properties, opts.argv);
+ PySystemState systemState = Py.getSystemState();
PyList warnoptions = new PyList();
- for (String wopt : opts.warnoptions) {
- warnoptions.append(new PyString(wopt));
+ addWarnings(opts.warnoptions, warnoptions);
+ addWarnings(warnOptionsFromEnv(), warnoptions);
+ systemState.setWarnoptions(warnoptions);
+
+ // Make sure warnings module is loaded if there are warning options
+ // Not sure this is needed, but test_warnings.py expects this
+ if (warnoptions.size() > 0) {
+ imp.load("warnings");
}
- Py.getSystemState().setWarnoptions(warnoptions);
- PySystemState systemState = Py.getSystemState();
+
// Decide if stdin is interactive
if (!opts.fixInteractive || opts.interactive) {
opts.interactive = ((PyFile)Py.defaultSystemState.stdin).isatty();
--
Repository URL: http://hg.python.org/jython
More information about the Jython-checkins
mailing list