[RFC] Throw a special exceptions in Julia callbacks (Fix #770) (#772)

* Throw a special exceptions in julia callbacks

* Address issues raised by @stevengj

* move pyerror() below @pycheckn definition + address test failure

* fix errors

Author: PhilipVinc

src/PyCall.jl

@@ -494,7 +494,7 @@ function pyimport(name::AbstractString)
     o = _pyimport(name)
     if ispynull(o)
         if pyerr_occurred()
-            e = PyError("PyImport_ImportModule")
+            e = pyerror("PyImport_ImportModule")
             if pyisinstance(e.val, @pyglobalobjptr(:PyExc_ImportError))
                 # Expand message to help with common user confusions.
                 msg = """
@@ -540,7 +540,7 @@ or alternatively you can use the Conda package directly (via
 `using Conda` followed by `Conda.add` etcetera).
 """
                 end
-                e = PyError(string(e.msg, "\n\n", msg, "\n"), e)
+                e = pyerror(string(e.msg, "\n\n", msg, "\n"), e)
             end
             throw(e)
         else
@@ -862,7 +862,7 @@ if pyversion >= v"3.3"
 else
     function empty!(o::PyObject)
         p = _getproperty(o, "clear")
-        if p != NULL # for dict, set, etc.
+        if p != PyNULL() # for dict, set, etc.
             pydecref(pycall(PyObject(o)."clear", PyObject))
         else
             for i = length(o)-1:-1:0

src/exception.jl

@@ -1,3 +1,17 @@
+#########################################################################
+# A wrapper around an error that happened in a Julia callback
+
+struct PyJlError <: Exception
+    err
+    trace
+end
+
+function show(io::IO, e::PyJlError)
+    println(io, "An error occured in a Julia function called from Python:")
+    _showerror_string(io, e.err, e.trace)
+end
+
+
 #########################################################################
 # Wrapper around Python exceptions
 
@@ -12,15 +26,6 @@ struct PyError <: Exception
     # generate a PyError object.  Should normally only be called when
     # PyErr_Occurred returns non-NULL, and clears the Python error
     # indicator.
-    function PyError(msg::AbstractString)
-        ptype, pvalue, ptraceback = Ref{PyPtr}(), Ref{PyPtr}(), Ref{PyPtr}()
-        # equivalent of passing C pointers &exc[1], &exc[2], &exc[3]:
-        ccall((@pysym :PyErr_Fetch), Cvoid, (Ref{PyPtr},Ref{PyPtr},Ref{PyPtr}), ptype, pvalue, ptraceback)
-        ccall((@pysym :PyErr_NormalizeException), Cvoid, (Ref{PyPtr},Ref{PyPtr},Ref{PyPtr}), ptype, pvalue, ptraceback)
-        new(msg, PyObject(ptype[]), PyObject(pvalue[]), PyObject(ptraceback[]))
-    end
-
-    PyError(msg::AbstractString, e::PyError) = new(msg, e.T, e.val, e.traceback)
 end
 
 function show(io::IO, e::PyError)
@@ -54,7 +59,7 @@ pyerr_occurred() = ccall((@pysym :PyErr_Occurred), PyPtr, ()) != C_NULL
 pyerr_clear() = ccall((@pysym :PyErr_Clear), Cvoid, ())
 
 function pyerr_check(msg::AbstractString, val::Any)
-    pyerr_occurred() && throw(PyError(msg))
+    pyerr_occurred() && throw(pyerror(msg))
     val # the val argument is there just to pass through to the return value
 end
 
@@ -101,6 +106,37 @@ macro pycheckz(ex)
     :(@pycheckv $(esc(ex)) -1)
 end
 
+function pyerror(msg::AbstractString)
+    ptype, pvalue, ptraceback = Ref{PyPtr}(), Ref{PyPtr}(), Ref{PyPtr}()
+    # equivalent of passing C pointers &exc[1], &exc[2], &exc[3]:
+    ccall((@pysym :PyErr_Fetch), Cvoid, (Ref{PyPtr},Ref{PyPtr},Ref{PyPtr}), ptype, pvalue, ptraceback)
+    ccall((@pysym :PyErr_NormalizeException), Cvoid, (Ref{PyPtr},Ref{PyPtr},Ref{PyPtr}), ptype, pvalue, ptraceback)
+    pyerror(msg, PyObject(ptype[]), PyObject(pvalue[]), PyObject(ptraceback[]))
+end
+
+function pyerror(msg::AbstractString, e::PyError)
+    pyerror(msg, e.T, e.val, e.traceback)
+end
+
+function pyerror(msg::AbstractString, ptype::PyObject, pvalue::PyObject, ptraceback::PyObject)
+    pargs = _getproperty(pvalue, "args")
+
+    # If the value of the error is a PyJlError, it was generated in a pyjlwrap callback, and
+    # we forward it.
+    if pargs != C_NULL
+        args = PyObject(pargs)
+        if length(args) > 0
+            arg = PyObject(@pycheckn ccall((@pysym :PySequence_GetItem), PyPtr, (PyPtr,Int), args, 0))
+            if is_pyjlwrap(arg)
+                jarg = unsafe_pyjlwrap_to_objref(arg)
+                jarg isa PyJlError && return jarg
+            end
+        end
+    end
+
+    return PyError(msg, ptype, pvalue, ptraceback)
+end
+
 #########################################################################
 # Mapping of Julia Exception types to Python exceptions
 
@@ -178,8 +214,9 @@ end
 function pyraise(e, bt = nothing)
     eT = typeof(e)
     pyeT = haskey(pyexc::Dict, eT) ? pyexc[eT] : pyexc[Exception]
-    ccall((@pysym :PyErr_SetString), Cvoid, (PyPtr, Cstring),
-          pyeT, string("Julia exception: ", showerror_string(e, bt)))
+    err = PyJlError(e, bt)
+    ccall((@pysym :PyErr_SetObject), Cvoid, (PyPtr, PyPtr),
+          pyeT, PyObject(err))
 end
 
 # Second argument allows for backtraces passed to `pyraise` to be ignored.