dev

Author: Christopher Doris

juliapy/julia/__init__.py

@@ -33,10 +33,15 @@ def _init_():
     lib.jl_eval_string.restype = c.c_void_p
     res = lib.jl_eval_string(
         '''
-        ENV["PYTHONJL_LIBPTR"] = "{}"
-        import Python
-        Python.with_gil() do
-            Python.pyimport("sys").modules["julia"].Main = Python.pyjl(Main)
+        try
+            ENV["PYTHONJL_LIBPTR"] = "{}"
+            import Python
+            Python.with_gil() do
+                Python.pyimport("sys").modules["julia"].Main = Python.pyjlraw(Main)
+            end
+        catch err
+            @error "Error loading Python.jl" err=err
+            rethrow()
         end
         '''.format(c.pythonapi._handle).encode('utf8'))
     if res is None:

src/old/PyBuffer.jl renamed to src/PyBuffer.jl

@@ -1,5 +1,5 @@
 """
-    PyBuffer(o)
+    PyBuffer(o, [flags=C.PyBUF_FULL_RO])
 
 A reference to the underlying buffer of `o`, if it satisfies the buffer protocol.
 
@@ -20,16 +20,15 @@ Has the following properties:
 """
 mutable struct PyBuffer
     info :: Array{C.Py_buffer, 0}
-    function PyBuffer(o::PyObject, flags::Integer=C.PyBUF_FULL_RO)
+    function PyBuffer(o, flags::Integer=C.PyBUF_FULL_RO)
         info = fill(C.Py_buffer())
         check(C.PyObject_GetBuffer(o, pointer(info), flags))
         b = new(info)
         finalizer(b) do b
             if CONFIG.isinitialized
-                err = with_gil(false) do
+                with_gil(false) do
                     C.PyBuffer_Release(pointer(b.info))
                 end
-                check(err)
             end
         end
         b

src/PyException.jl

@@ -7,7 +7,7 @@ mutable struct PyException <: Exception
 end
 export PyException
 
-pythrow() = throw(PyException(Val(:new), C.PyErr_FetchTuple()...))
+pythrow() = throw(PyException(Val(:new), C.PyErr_FetchTuple(true)...))
 
 """
     check(x)
@@ -81,36 +81,47 @@ function Base.showerror(io::IO, e::PyException)
         end
     end
 
-    # # if this is a Julia exception then recursively print it and its stacktrace
-    # if pyerrmatches(e.t, pyjlexception)
-    #     try
-    #         jp = pyjlgetvalue(e.v.args[0])
-    #         if jp !== nothing
-    #             je, jb = jp
-    #             print(io, "Python: Julia: ")
-    #             showerror(io, je)
-    #             if jb === nothing
-    #                 println(io)
-    #                 print(io, "Stacktrace: none")
-    #             else
-    #                 io2 = IOBuffer()
-    #                 Base.show_backtrace(IOContext(io2, :color=>true, :displaysize=>displaysize(io)), jb)
-    #                 printstyled(io, String(take!(io2)))
-    #             end
-    #         end
-    #         if pyisnone(e.b)
-    #             println(io)
-    #             printstyled(io, "Python stacktrace: none")
-    #             return
-    #         else
-    #             @goto pystacktrace
-    #         end
-    #     catch err
-    #         println(io, "<error while printing Julia excpetion inside Python exception: $(err)>")
-    #     end
-    # end
-
-    # otherwise, print the Python exception ****** TODO ******
+    # if this is a Julia exception then recursively print it and its stacktrace
+    if C.PyErr_GivenExceptionMatches(e.tref, C.PyExc_JuliaError()) != 0
+        try
+            # Extract error value
+            vo = @pyv `$(e.vref).args[0]`::Any
+            if vo isa Tuple{Exception, Any}
+                je, jb = vo
+            else
+                je = vo
+                jb = nothing
+            end
+            print(io, "Python: Julia: ")
+            # Show exception
+            if je isa Exception
+                showerror(io, je)
+            else
+                print(io, je)
+            end
+            # Show backtrace
+            if jb === nothing
+                println(io)
+                print(io, "Stacktrace: none")
+            else
+                io2 = IOBuffer()
+                Base.show_backtrace(IOContext(io2, :color=>true, :displaysize=>displaysize(io)), jb)
+                printstyled(io, String(take!(io2)))
+            end
+            # Show Python backtrace
+            if isnull(e.bref)
+                println(io)
+                printstyled(io, "Python stacktrace: none")
+                return
+            else
+                @goto pystacktrace
+            end
+        catch err
+            println("<error while printing Julia exception inside Python exception>")
+        end
+    end
+
+    # otherwise, print the Python exception
     print(io, "Python: ")
 
     # print the type name

src/PyRef.jl

@@ -14,7 +14,7 @@ mutable struct PyRef
         x = new(CPyPtr(ptr))
         borrowed && C.Py_IncRef(ptr)
         finalizer(x) do x
-            if !CONFIG.isinitialized
+            if CONFIG.isinitialized
                 ptr = x.ptr
                 if !isnull(ptr)
                     with_gil(false) do

src/Python.jl

@@ -93,9 +93,12 @@ include("PyList.jl")
 include("PySet.jl")
 include("PyIterable.jl")
 include("PyIO.jl")
+include("PyBuffer.jl")
 include("PyPandasDataFrame.jl")
 
+include("julia.jl")
 include("gui.jl")
+include("matplotlib.jl")
 
 include("init.jl")
 

src/builtins.jl

@@ -640,12 +640,6 @@ pyinv(::Type{T}, x) where {T} = cpyop(T, C.PyNumber_Invert, x)
 pyinv(x) = pyinv(typeof(x), x)
 export pyinv
 
-# pycollist(x::AbstractArray{T,N}) where {T,N} = N==0 ? pyobject(x[]) : pylist_fromiter(pycollist(y) for y in eachslice(x; dims=N))
-# export pycollist
-
-# pyrowlist(x::AbstractArray{T,N}) where {T,N} = N==0 ? pyobject(x[]) : pylist_fromiter(pyrowlist(y) for y in eachslice(x; dims=1))
-# export pyrowlist
-
 """
     pyiter([T=PyObject] x) :: T
 
@@ -688,6 +682,101 @@ function pywith(f, _o, d=nothing)
 end
 export pywith
 
+"""
+    pytuple([T=PyObject,] [x]) :: T
+
+Create a Python `tuple` from the elements of `x`.
+"""
+pytuple(::Type{T}, x) where {T} = checknullconvert(T, ispyreftype(typeof(x)) ? C.PyObject_CallNice(C.PyTuple_Type(), x) : C.PyTuple_FromIter(x))
+pytuple(::Type{T}) where {T} = checknullconvert(T, C.PyTuple_New(0))
+pytuple(x) = pytuple(PyObject, x)
+pytuple() = pytuple(PyObject)
+export pytuple
+
+"""
+    pylist([T=PyObject,] [x]) :: T
+
+Create a Python `list` from the elements of `x`.
+"""
+pylist(::Type{T}, x) where {T} = checknullconvert(T, ispyreftype(typeof(x)) ? C.PyObject_CallNice(C.PyList_Type(), x) : C.PyList_FromIter(x))
+pylist(::Type{T}) where {T} = checknullconvert(T, C.PyList_New(0))
+pylist(x) = pylist(PyObject, x)
+pylist() = pylist(PyObject)
+export pylist
+
+"""
+    pycollist([T=PyObject,] x::AbstractArray) :: T
+
+Create a nested Python `list`-of-`list`s from the elements of `x`. For matrices, this is a list of columns.
+"""
+pycollist(::Type{T}, x::AbstractArray) where {T} = ndims(x)==0 ? pyconvert(T, x[]) : pylist(T, pycollist(PyRef, y) for y in eachslice(x; dims=ndims(x)))
+pycollist(x::AbstractArray) = pycollist(PyObject, x)
+export pycollist
+
+"""
+    pyrowlist([T=PyObject,] x::AbstractArray) :: T
+
+Create a nested Python `list`-of-`list`s from the elements of `x`. For matrices, this is a list of rows.
+"""
+pyrowlist(::Type{T}, x::AbstractArray) where {T} = ndims(x)==0 ? pyconvert(T, x[]) : pylist(T, pyrowlist(PyRef, y) for y in eachslice(x; dims=1))
+pyrowlist(x::AbstractArray) = pyrowlist(PyObject, x)
+export pyrowlist
+
+"""
+    pyset([T=PyObject,] [x]) :: T
+
+Create a Python `set` from the elements of `x`.
+"""
+pyset(::Type{T}, x) where {T} = checknullconvert(T, ispyreftype(typeof(x)) ? C.PyObject_CallNice(C.PySet_Type(), x) : C.PySet_FromIter(x))
+pyset(::Type{T}) where {T} = checknullconvert(T, C.PySet_New(C_NULL))
+pyset(x) = pyset(PyObject, x)
+pyset() = pyset(PyObject)
+export pyset
+
+"""
+    pyfrozenset([T=PyObject,] [x]) :: T
+
+Create a Python `frozenset` from the elements of `x`.
+"""
+pyfrozenset(::Type{T}, x) where {T} = checknullconvert(T, ispyreftype(typeof(x)) ? C.PyObject_CallNice(C.PyFrozenSet_Type(), x) : C.PyFrozenSet_FromIter(x))
+pyfrozenset(::Type{T}) where {T} = checknullconvert(T, C.PyFrozenSet_New(C_NULL))
+pyfrozenset(x) = pyfrozenset(PyObject, x)
+pyfrozenset() = pyfrozenset(PyObject)
+export pyfrozenset
+
+"""
+    pydict([T=PyObject,] [x]) :: T
+
+Create a Python `dict` from the key-value pairs in `x`.
+"""
+pydict(::Type{T}, x) where {T} = checknullconvert(T, ispyreftype(typeof(x)) ? C.PyObject_CallNice(C.PyDict_Type(), x) : C.PyDict_FromPairs(x))
+pydict(::Type{T}) where {T} = checknullconvert(T, C.PyDict_New())
+pydict(x) = pydict(PyObject, x)
+pydict() = pydict(PyObject)
+export pydict
+
+"""
+    pyslice([T=PyObject,] [start,] stop, [step]) :: T
+
+Equivalent to `slice(start, stop, step)` in Python (or `start:stop:step` while indexing).
+"""
+pyslice(::Type{T}, x) where {T} = cpyop(T, x->C.PySlice_New(C_NULL, x, C_NULL), x)
+pyslice(::Type{T}, x, y) where {T} = cpyop(T, (x,y)->C.PySlice_New(x, y, C_NULL), x, y)
+pyslice(::Type{T}, x, y, z) where {T} = cpyop(T, C.PySlice_New, x, y, z)
+pyslice(x) = pyslice(PyObject, x)
+pyslice(x, y) = pyslice(PyObject, x, y)
+pyslice(x, y, z) = pyslice(PyObject, x, y, z)
+export pyslice
+
+"""
+    pyellipsis([T=PyObject])
+
+Equivalent to `Ellipsis` in Python (or `...` while indexing).
+"""
+pyellipsis(::Type{T}) where {T} = checknullconvert(T, C.PyEllipsis_New())
+pyellipsis() = pyellipsis(PyObject)
+export pyellipsis
+
 ### MULTIMEDIA DISPLAY
 
 for (mime, method) in [

src/cpython/CPython.jl

@@ -50,6 +50,13 @@ include("collections.jl")
 include("range.jl")
 include("ctypes.jl")
 include("numpy.jl")
+include("slice.jl")
+include("fraction.jl")
+include("newtype.jl")
+include("juliaerror.jl")
+include("juliabase.jl")
+include("juliaraw.jl")
+include("arg.jl")
 
 __init__() = begin
     PyObject_TryConvert_AddRules("builtins.NoneType", [
@@ -124,6 +131,9 @@ __init__() = begin
     PyObject_TryConvert_AddRules("collections.abc.Mapping", [
         (Dict, PyMapping_ConvertRule_dict),
     ])
+    PyObject_TryConvert_AddRules("julia.ValueBase", [
+        (Any, PyJuliaValue_TryConvert_any),
+    ])
     PyObject_TryConvert_AddExtraTypes([
         PyIterableABC_Type,
         PyCallableABC_Type,