numpy and ctypes conversions

Author: Christopher Doris

src/PythonCall.jl

@@ -40,6 +40,8 @@ include("concrete/fraction.jl")
 include("concrete/method.jl")
 include("concrete/datetime.jl")
 include("concrete/code.jl")
+include("concrete/ctypes.jl")
+include("concrete/numpy.jl")
 # @py
 # anything below can depend on @py, anything above cannot
 include("py_macro.jl")
@@ -105,6 +107,8 @@ function __init__()
         init_gui()
         init_ipython()
         init_tables()
+        init_numpy()
+        init_ctypes()
     end
     @require PyCall="438e738f-606a-5dbb-bf0a-cddfbfd45ab0" init_pycall(PyCall)
 end

src/concrete/ctypes.jl

@@ -0,0 +1,60 @@
+struct pyconvert_rule_ctypessimplevalue{R,S} <: Function end
+
+function (::pyconvert_rule_ctypessimplevalue{R,SAFE})(::Type{T}, x::Py) where {R,SAFE,T}
+    ptr = GC.@preserve x C.PySimpleObject_GetValue(Ptr{R}, getptr(x))
+    ans = unsafe_load(ptr)
+    if SAFE
+        pyconvert_return(convert(T, ans))
+    else
+        pyconvert_tryconvert(T, ans)
+    end
+end
+
+const CTYPES_SIMPLE_TYPES = [
+    ("char", Cchar),
+    ("wchar", Cwchar_t),
+    ("byte", Cchar),
+    ("ubyte", Cuchar),
+    ("short", Cshort),
+    ("ushort", Cushort),
+    ("int", Cint),
+    ("uint", Cuint),
+    ("long", Clong),
+    ("ulong", Culong),
+    ("longlong", Clonglong),
+    ("ulonglong", Culonglong),
+    ("size_t", Csize_t),
+    ("ssize_t", Cssize_t),
+    ("float", Cfloat),
+    ("double", Cdouble),
+    ("char_p", Ptr{Cchar}),
+    ("wchar_p", Ptr{Cwchar_t}),
+    ("void_p", Ptr{Cvoid}),
+]
+
+function init_ctypes()
+    for (t,T) in CTYPES_SIMPLE_TYPES
+        isptr = endswith(t, "_p")
+        isreal = !isptr
+        isnumber = isreal
+        isfloat = t in ("float", "double")
+        isint = isreal && !isfloat
+        isuint = isint && (startswith(t, "u") || t == "size_t")
+
+        name = "ctypes/c_$t"
+        rule = pyconvert_rule_ctypessimplevalue{T, false}()
+        saferule = pyconvert_rule_ctypessimplevalue{T, true}()
+
+        t == "char_p" && pyconvert_add_rule(name, Cstring, saferule)
+        t == "wchar_p" && pyconvert_add_rule(name, Cwstring, saferule)
+        pyconvert_add_rule(name, T, saferule)
+        isuint && pyconvert_add_rule(name, UInt, sizeof(T) ≤ sizeof(UInt) ? saferule : rule)
+        isuint && pyconvert_add_rule(name, Int, sizeof(T) < sizeof(Int) ? saferule : rule)
+        isint && !isuint && pyconvert_add_rule(name, Int, sizeof(T) ≤ sizeof(Int) ? saferule : rule)
+        isint && pyconvert_add_rule(name, Integer, rule)
+        isfloat && pyconvert_add_rule(name, Float64, saferule)
+        isreal && pyconvert_add_rule(name, Real, rule)
+        isnumber && pyconvert_add_rule(name, Number, rule)
+        isptr && pyconvert_add_rule(name, Ptr, saferule)
+    end
+end

src/concrete/numpy.jl

@@ -0,0 +1,53 @@
+struct pyconvert_rule_numpysimplevalue{R,S} <: Function end
+
+function (::pyconvert_rule_numpysimplevalue{R,SAFE})(::Type{T}, x::Py) where {R,SAFE,T}
+    ans = GC.@preserve x C.PySimpleObject_GetValue(R, getptr(x))
+    if SAFE
+        pyconvert_return(convert(T, ans))
+    else
+        pyconvert_tryconvert(T, ans)
+    end
+end
+
+const NUMPY_SIMPLE_TYPES = [
+    ("int8", Int8),
+    ("int16", Int16),
+    ("int32", Int32),
+    ("int64", Int64),
+    ("uint8", UInt8),
+    ("uint16", UInt16),
+    ("uint32", UInt32),
+    ("uint64", UInt64),
+    ("float16", Float16),
+    ("float32", Float32),
+    ("float64", Float64),
+    ("complex32", ComplexF16),
+    ("complex64", ComplexF32),
+    ("complex128", ComplexF64),
+]
+
+function init_numpy()
+    for (t,T) in NUMPY_SIMPLE_TYPES
+        isint = occursin("int", t)
+        isuint = occursin("uint", t)
+        isfloat = occursin("float", t)
+        iscomplex = occursin("complex", t)
+        isreal = isint || isfloat
+        isnumber = isreal || iscomplex
+
+        name = "numpy/$t"
+        rule = pyconvert_rule_numpysimplevalue{T, false}()
+        saferule = pyconvert_rule_numpysimplevalue{T, true}()
+
+        pyconvert_add_rule(name, T, saferule, 100)
+        isuint && pyconvert_add_rule(name, UInt, sizeof(T) ≤ sizeof(UInt) ? saferule : rule)
+        isuint && pyconvert_add_rule(name, Int, sizeof(T) < sizeof(Int) ? saferule : rule)
+        isint && !isuint && pyconvert_add_rule(name, Int, sizeof(T) ≤ sizeof(Int) ? saferule : rule)
+        isint && pyconvert_add_rule(name, Integer, rule)
+        isfloat && pyconvert_add_rule(name, Float64, saferule)
+        isreal && pyconvert_add_rule(name, Real, rule)
+        iscomplex && pyconvert_add_rule(name, ComplexF64, saferule)
+        iscomplex && pyconvert_add_rule(name, Complex, rule)
+        isnumber && pyconvert_add_rule(name, Number, rule)
+    end
+end

src/cpython/extras.jl

@@ -51,6 +51,10 @@ function PyOS_RunInputHook()
     end
 end
 
+function PySimpleObject_GetValue(::Type{T}, o::PyPtr) where {T}
+    UnsafePtr{PySimpleObject{T}}(o).value[!]
+end
+
 # FAST REFCOUNTING
 #
 # _Py_IncRef(o) = ccall(POINTERS.Py_IncRef, Cvoid, (PyPtr,), o)