reimplement conversion of buffers/arrays to julia arrays

Author: Christopher Doris

docs/src/conversion-to-julia.md

@@ -18,8 +18,9 @@ The following table specifies the conversion rules in place. If the initial Pyth
 | :----------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------- |
 | **Top priority (wrapped values).**                                                                           |                                                             |
 | `juliacall.AnyValue`                                                                                         | `Any`                                                       |
+| `juliacall.As`                                                                                               | `Any`                                                       |
 | **Very high priority (arrays).**                                                                             |                                                             |
-| Objects satisfying the buffer or array interface (inc. `bytes`, `bytearray`, `array.array`, `numpy.ndarray`) | `PyArray`                                                   |
+| Objects satisfying the buffer or array interface (inc. `bytes`, `bytearray`, `array.array`, `numpy.ndarray`) | `PyArray`, `Array`, `AbstractArray`                         |
 | **High priority (canonical conversions).**                                                                   |                                                             |
 | `None`                                                                                                       | `Nothing`                                                   |
 | `bool`                                                                                                       | `Bool`                                                      |

src/convert.jl

@@ -140,11 +140,17 @@ function pyconvert_get_rules(type::Type, pytype::Py)
     omro_ = filter(t -> pyisin(t, omro), mro)
     @assert length(omro) == length(omro_)
     @assert all(pyis(x,y) for (x,y) in zip(omro, omro_))
-    # TODO: special cases (buffer protocol, etc.)
 
     # get the names of the types in the MRO of pytype
     mro = String["$(t.__module__)/$(t.__qualname__)" for t in mro]
 
+    # add special names
+    # currently we don't care where they go because they are tested in their own priority (200)
+    pyhasattr(pytype, "__array_struct__") && push!(mro, "<arraystruct>")
+    pyhasattr(pytype, "__array_interface__") && push!(mro, "<arrayinterface>")
+    pyhasattr(pytype, "__array__") && push!(mro, "<array>")
+    C.PyType_CheckBuffer(getptr(pytype)) && push!(mro, "<buffer>")
+
     # get corresponding rules
     rules = PyConvertRule[rule for tname in mro for rule in get!(Vector{PyConvertRule}, PYCONVERT_RULES, tname)]
 
@@ -276,6 +282,10 @@ function init_pyconvert()
     pyconvert_add_rule("juliacall/As", Any, pyconvert_rule_jlas, 300)
     pyconvert_add_rule("juliacall/ValueBase", Any, pyconvert_rule_jlvalue, 300)
     # priority 200: arrays
+    pyconvert_add_rule("<arraystruct>", AbstractArray, pyconvert_rule_array, 200)
+    pyconvert_add_rule("<arrayinterface>", AbstractArray, pyconvert_rule_array, 200)
+    pyconvert_add_rule("<array>", AbstractArray, pyconvert_rule_array, 200)
+    pyconvert_add_rule("<buffer>", AbstractArray, pyconvert_rule_array, 200)
     # priority 100: canonical
     pyconvert_add_rule("builtins/NoneType", Nothing, pyconvert_rule_none, 100)
     pyconvert_add_rule("builtins/bool", Bool, pyconvert_rule_bool, 100)

src/pywrap/PyArray.jl

@@ -64,6 +64,15 @@ end
 
 pyconvert_rule_array(::Type{A}, x::Py) where {A<:PyArray} = pyarray_make(A, x, copy=false)
 
+function pyconvert_rule_array(::Type{A}, x::Py) where {A<:AbstractArray}
+    r = pyconvert_rule_array(PyArray, x)
+    if pyconvert_isunconverted(r)
+        return pyconvert_unconverted()
+    else
+        return pyconvert_tryconvert(A, pyconvert_result(PyArray, r))
+    end
+end
+
 abstract type PyArraySource end
 
 function pyarray_make(::Type{A}, x::Py; array::Bool=true, buffer::Bool=true, copy::Bool=true) where {A<:PyArray}