Merge branch 'raise_from' into v0.12.x

Author: edschofield

docs/notebooks/Writing Python 2-3 compatible code.ipynb

@@ -1,7 +1,7 @@
 {
  "metadata": {
   "name": "",
-  "signature": "sha256:a318d976dd8aacb67a39acbcafddb513645c61ae27874c0d32d4a64c1621ca35"
+  "signature": "sha256:f4ac8456d9c7976cb130d88556b7bbe2c3494a960d29e3eeffdca80a91b080e3"
  },
  "nbformat": 3,
  "nbformat_minor": 0,
@@ -294,6 +294,76 @@
      "metadata": {},
      "outputs": []
     },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Exception chaining (PEP 3134):"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "# Setup:\n",
+      "class DatabaseError(Exception):\n",
+      "    pass"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "# Python 3 only\n",
+      "class FileDatabase:\n",
+      "    def __init__(self, filename):\n",
+      "        try:\n",
+      "            self.file = open(filename)\n",
+      "        except IOError as exc:\n",
+      "            raise DatabaseError('failed to open') from exc"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": []
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "# Python 2 and 3:\n",
+      "from future.utils import raise_from\n",
+      "\n",
+      "class FileDatabase:\n",
+      "    def __init__(self, filename):\n",
+      "        try:\n",
+      "            self.file = open(filename)\n",
+      "        except IOError as exc:\n",
+      "            raise_from(DatabaseError('failed to open'), exc)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 16
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "# Testing the above:\n",
+      "try:\n",
+      "    fd = FileDatabase('non_existent_file.txt')\n",
+      "except Exception as e:\n",
+      "    assert isinstance(e.__cause__, IOError)    # FileNotFoundError on Py3.3+ inherits from IOError"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 17
+    },
     {
      "cell_type": "heading",
      "level": 3,

docs/whatsnew.rst

@@ -13,6 +13,7 @@ What's new in version 0.12.5
   (issue #81). It still converts ``obj.next()`` method calls to
   ``next(obj)`` correctly.
 - Add :ref:`compatible-idioms` from Ed Schofield's PyConAU 2014 talk.
+- Add ``future.utils.raise_from`` as an equivalent to Py3's ``raise ... from ...`` syntax (issue #86).
 
 
 .. whats-new-0.12.4:

future/tests/test_utils.py

@@ -8,7 +8,7 @@
 from future.builtins import *
 from future.utils import (old_div, istext, isbytes, native, PY2, PY3,
                          native_str, raise_, as_native_str, ensure_new_type,
-                         bytes_to_native_str)
+                         bytes_to_native_str, raise_from)
 
 from numbers import Integral
 from future.tests.base import unittest, skip26
@@ -141,7 +141,16 @@ def with_traceback():
         except IOError as e:
             self.assertEqual(str(e), "An error")
 
-
+    def test_raise_from_None(self):
+        try:
+            try:
+                raise TypeError("foo")
+            except:
+                raise_from(ValueError(), None)
+        except ValueError as e:
+            self.assertTrue(isinstance(e.__context__, TypeError))
+            self.assertIsNone(e.__cause__)
+    
     @skip26
     def test_as_native_str(self):
         """
@@ -190,5 +199,97 @@ def test_bytes_to_native_str(self):
         self.assertEqual(type(s), native_str)
 
 
+class TestCause(unittest.TestCase):
+    """
+    Except for the first method, these were adapted from Py3.3's
+    Lib/test/test_raise.py.
+    """
+    def test_normal_use(self):
+        """
+        Adapted from PEP 3134 docs
+        """
+        # Setup:
+        class DatabaseError(Exception):
+            pass
+
+        # Python 2 and 3:
+        from future.utils import raise_from
+        
+        class FileDatabase:
+            def __init__(self, filename):
+                try:
+                    self.file = open(filename)
+                except IOError as exc:
+                    raise_from(DatabaseError('failed to open'), exc)
+
+        # Testing the above:
+        try:
+            fd = FileDatabase('non_existent_file.txt')
+        except Exception as e:
+            assert isinstance(e.__cause__, IOError)   # FileNotFoundError on
+                                                      # Py3.3+ inherits from IOError        
+
+    def testCauseSyntax(self):
+        try:
+            try:
+                try:
+                    raise TypeError
+                except Exception:
+                    raise_from(ValueError, None)
+            except ValueError as exc:
+                self.assertIsNone(exc.__cause__)
+                self.assertTrue(exc.__suppress_context__)
+                exc.__suppress_context__ = False
+                raise exc
+        except ValueError as exc:
+            e = exc
+
+        self.assertIsNone(e.__cause__)
+        self.assertFalse(e.__suppress_context__)
+        self.assertIsInstance(e.__context__, TypeError)
+
+    def test_invalid_cause(self):
+        try:
+            raise_from(IndexError, 5)
+        except TypeError as e:
+            self.assertIn("exception cause", str(e))
+        else:
+            self.fail("No exception raised")
+
+    def test_class_cause(self):
+        try:
+            raise_from(IndexError, KeyError)
+        except IndexError as e:
+            self.assertIsInstance(e.__cause__, KeyError)
+        else:
+            self.fail("No exception raised")
+
+    @unittest.expectedFailure
+    def test_instance_cause(self):
+        cause = KeyError('blah')
+        try:
+            raise_from(IndexError, cause)
+        except IndexError as e:
+            # FAILS:
+            self.assertTrue(e.__cause__ is cause)
+            # Even this weaker version seems to fail, although repr(cause) looks correct.
+            # Is there something strange about testing exceptions for equality?
+            self.assertEqual(e.__cause__, cause)
+        else:
+            self.fail("No exception raised")
+
+    def test_erroneous_cause(self):
+        class MyException(Exception):
+            def __init__(self):
+                raise RuntimeError()
+
+        try:
+            raise_from(IndexError, MyException)
+        except RuntimeError:
+            pass
+        else:
+            self.fail("No exception raised")
+
+
 if __name__ == '__main__':
     unittest.main()

future/utils/__init__.py

@@ -74,6 +74,9 @@
 import sys
 import numbers
 import functools
+import copy
+import inspect
+
 
 PY3 = sys.version_info[0] == 3
 PY2 = sys.version_info[0] == 2
@@ -336,7 +339,49 @@ def getexception():
     return sys.exc_info()[1]
 
 
+def _get_caller_globals_and_locals():
+    """
+    Returns the globals and locals of the calling frame.
+
+    Is there an alternative to frame hacking here?
+    """
+    caller_frame = inspect.stack()[2]
+    myglobals = caller_frame[0].f_globals
+    mylocals = caller_frame[0].f_locals
+    return myglobals, mylocals
+
+
+def _repr_strip(mystring):
+    """
+    Returns the string without any initial or final quotes.
+    """
+    r = repr(mystring)
+    if r.startswith("'") and r.endswith("'"):
+        return r[1:-1]
+    else:
+        return r
+
+
 if PY3:
+    def raise_from(exc, cause):
+        """
+        Equivalent to:
+
+            raise EXCEPTION from CAUSE
+
+        on Python 3. (See PEP 3134).
+        """
+        # Is either arg an exception class (e.g. IndexError) rather than
+        # instance (e.g. IndexError('my message here')? If so, pass the
+        # name of the class undisturbed through to "raise ... from ...".
+        if isinstance(exc, type) and issubclass(exc, Exception):
+            exc = exc.__name__
+        if isinstance(cause, type) and issubclass(cause, Exception):
+            cause = cause.__name__
+        execstr = "raise " + _repr_strip(exc) + " from " + _repr_strip(cause)
+        myglobals, mylocals = _get_caller_globals_and_locals()
+        exec(execstr, myglobals, mylocals)
+
     def raise_(tp, value=None, tb=None):
         """
         A function that matches the Python 2.x ``raise`` statement. This
@@ -358,6 +403,40 @@ def raise_with_traceback(exc, traceback=Ellipsis):
         raise exc.with_traceback(traceback)
 
 else:
+    def raise_from(exc, cause):
+        """
+        Equivalent to:
+
+            raise EXCEPTION from CAUSE
+
+        on Python 3. (See PEP 3134).
+        """
+        # Is either arg an exception class (e.g. IndexError) rather than
+        # instance (e.g. IndexError('my message here')? If so, pass the
+        # name of the class undisturbed through to "raise ... from ...".
+        if isinstance(exc, type) and issubclass(exc, Exception):
+            e = exc()
+            # exc = exc.__name__
+            # execstr = "e = " + _repr_strip(exc) + "()"
+            # myglobals, mylocals = _get_caller_globals_and_locals()
+            # exec(execstr, myglobals, mylocals)
+        else:
+            e = exc
+        e.__suppress_context__ = False
+        if isinstance(cause, type) and issubclass(cause, Exception):
+            e.__cause__ = cause()
+            e.__suppress_context__ = True
+        elif cause is None:
+            e.__cause__ = None
+            e.__suppress_context__ = True
+        elif isinstance(cause, BaseException):
+            e.__cause__ = cause
+            e.__suppress_context__ = True
+        else:
+            raise TypeError("exception causes must derive from BaseException")
+        e.__context__ = sys.exc_info()[1]
+        raise e
+
     exec('''
 def raise_(tp, value=None, tb=None):
     raise tp, value, tb