more conversions

Author: Christopher Doris

src/PyException.jl

@@ -140,28 +140,21 @@ function Base.showerror(io::IO, e::PyException)
         try
             @py ```
             import traceback
-            $(fs :: C.PyObjectRef) = fs = traceback.extract_tb($(e.bref))
-            $(nfs :: Int) = len(fs)
+            $(fs :: Vector{Tuple{String, String, Int}}) = [(x.name, x.filename, x.lineno) for x in traceback.extract_tb($(e.bref))]
             ```
-            try
-                for i in 1:nfs
-                    @py ```
-                    f = $(fs)[$(i-1)]
-                    $(name::String) = f.name
-                    $(fname::String) = f.filename
-                    $(lineno::Int) = f.lineno
-                    ```
-                    println(io)
-                    printstyled(io, " [", i, "] ")
-                    printstyled(io, name, bold=true)
-                    printstyled(io, " at ")
-                    printstyled(io, fname, ":", lineno, bold=true)
-                end
-            finally
-                C.Py_DecRef(fs)
+            for (i,(name, fname, lineno)) in enumerate(fs)
+                println(io)
+                printstyled(io, " [", i, "] ")
+                printstyled(io, name, bold=true)
+                printstyled(io, " at ")
+                # if (m=match(r"^(.*):([0-9]+)$", fname)) !== nothing
+                #     fname = m.captures[1]
+                #     lineno += parse(Int, m.captures[2]) - 1
+                # end
+                printstyled(io, fname, ":", lineno, bold=true)
             end
-        catch
-            print(io, "<error while printing stacktrace>")
+        catch err
+            print(io, "<error while printing stacktrace: $err>")
         end
     end
 end

src/builtins.jl

@@ -128,7 +128,7 @@ export pyrepr
 
 Equivalent to `str(x)` in Python.
 """
-pystr(::Type{T}, x) where {T} = cpyop(T, C.PyObject_Repr, x)
+pystr(::Type{T}, x) where {T} = cpyop(T, C.PyObject_Str, x)
 pystr(x) = pystr(PyObject, x)
 export pystr
 

src/cpython/CPython.jl

@@ -47,6 +47,7 @@ include("dict.jl")
 include("set.jl")
 include("buffer.jl")
 include("collections.jl")
+include("range.jl")
 
 __init__() = begin
     PyObject_TryConvert_AddRules("builtins.NoneType", [
@@ -56,30 +57,36 @@ __init__() = begin
     PyObject_TryConvert_AddRules("builtins.bool", [
         (Bool, PyBool_TryConvertRule_bool, 100),
     ])
-    PyObject_TryConvert_AddRules("builtins.int", [
-        (Integer, PyLong_TryConvertRule_integer, 100),
-        (Rational, PyLong_TryConvertRule_tryconvert),
-        (Real, PyLong_TryConvertRule_tryconvert),
-        (Number, PyLong_TryConvertRule_tryconvert),
-        (Any, PyLong_TryConvertRule_tryconvert),
+    PyObject_TryConvert_AddRules("numbers.Integral", [
+        (Integer, PyLongable_TryConvertRule_integer, 100),
+        (Rational, PyLongable_TryConvertRule_tryconvert),
+        (Real, PyLongable_TryConvertRule_tryconvert),
+        (Number, PyLongable_TryConvertRule_tryconvert),
+        (Any, PyLongable_TryConvertRule_tryconvert),
     ])
     PyObject_TryConvert_AddRules("builtins.float", [
-        (Float64, PyFloat_TryConvertRule_convert, 100),
-        (BigFloat, PyFloat_TryConvertRule_convert),
-        (Float32, PyFloat_TryConvertRule_convert),
-        (Float16, PyFloat_TryConvertRule_convert),
-        (AbstractFloat, PyFloat_TryConvertRule_tryconvert),
-        (Real, PyFloat_TryConvertRule_tryconvert),
-        (Number, PyFloat_TryConvertRule_tryconvert),
+        (Float64, PyFloatable_TryConvertRule_convert, 100)
+    ])
+    PyObject_TryConvert_AddRules("numbers.Real", [
+        (Float64, PyFloatable_TryConvertRule_convert),
+        (BigFloat, PyFloatable_TryConvertRule_convert),
+        (Float32, PyFloatable_TryConvertRule_convert),
+        (Float16, PyFloatable_TryConvertRule_convert),
+        (AbstractFloat, PyFloatable_TryConvertRule_tryconvert),
+        (Real, PyFloatable_TryConvertRule_tryconvert),
+        (Number, PyFloatable_TryConvertRule_tryconvert),
     ])
     PyObject_TryConvert_AddRules("builtins.complex", [
-        (Complex{Float64}, PyComplex_TryConvertRule_convert, 100),
-        (Complex{BigFloat}, PyComplex_TryConvertRule_convert),
-        (Complex{Float32}, PyComplex_TryConvertRule_convert),
-        (Complex{Float16}, PyComplex_TryConvertRule_convert),
-        (Complex{T} where {T<:AbstractFloat}, PyComplex_TryConvertRule_tryconvert),
-        (Complex{T} where {T<:Real}, PyComplex_TryConvertRule_tryconvert),
-        (Number, PyComplex_TryConvertRule_tryconvert),
+        (Complex{Float64}, PyComplexable_TryConvertRule_convert, 100),
+    ])
+    PyObject_TryConvert_AddRules("numbers.Complex", [
+        (Complex{Float64}, PyComplexable_TryConvertRule_convert),
+        (Complex{BigFloat}, PyComplexable_TryConvertRule_convert),
+        (Complex{Float32}, PyComplexable_TryConvertRule_convert),
+        (Complex{Float16}, PyComplexable_TryConvertRule_convert),
+        (Complex{T} where {T<:AbstractFloat}, PyComplexable_TryConvertRule_tryconvert),
+        (Complex{T} where {T<:Real}, PyComplexable_TryConvertRule_tryconvert),
+        (Number, PyComplexable_TryConvertRule_tryconvert),
     ])
     PyObject_TryConvert_AddRules("builtins.bytes", [
         (Vector{UInt8}, PyBytes_TryConvertRule_vector),
@@ -96,6 +103,10 @@ __init__() = begin
     PyObject_TryConvert_AddRules("builtins.tuple", [
         (Tuple, PyIterable_ConvertRule_tuple, 100),
     ])
+    PyObject_TryConvert_AddRules("builtins.range", [
+        (StepRange{T,S} where {T<:Integer, S<:Integer}, PyRange_TryConvertRule_steprange, 100),
+        (UnitRange{T} where {T<:Integer}, PyRange_TryConvertRule_unitrange),
+    ])
     PyObject_TryConvert_AddRules("collections.abc.Iterable", [
         (Vector, PyIterable_ConvertRule_vector),
         (Set, PyIterable_ConvertRule_set),
@@ -112,13 +123,37 @@ __init__() = begin
         (Dict, PyMapping_ConvertRule_dict),
     ])
     PyObject_TryConvert_AddExtraTypes([
-        ("collections.abc.Iterable", PyIterableABC_SubclassCheck),
-        ("collections.abc.Callable", PyCallableABC_SubclassCheck),
-        ("collections.abc.Sequence", PySequenceABC_SubclassCheck),
-        ("collections.abc.Mapping", PyMappingABC_SubclassCheck),
-        ("collections.abc.Set", PySetABC_SubclassCheck),
-        ("builtins.bufferable", PyType_CheckBuffer),
+        PyIterableABC_Type,
+        PyCallableABC_Type,
+        PySequenceABC_Type,
+        PyMappingABC_Type,
+        PySetABC_Type,
+        PyNumberABC_Type,
+        PyComplexABC_Type,
+        PyRealABC_Type,
+        PyRationalABC_Type,
+        PyIntegralABC_Type,
     ])
+    ### Numpy
+    # These aren't necessary but exist just to preserve the datatype.
+    # TODO: Access these types directly.
+    # TODO: Compound types?
+    PyObject_TryConvert_AddRule("numpy.int8", Int8, PyLongable_TryConvertRule_integer, 100)
+    PyObject_TryConvert_AddRule("numpy.int16", Int16, PyLongable_TryConvertRule_integer, 100)
+    PyObject_TryConvert_AddRule("numpy.int32", Int32, PyLongable_TryConvertRule_integer, 100)
+    PyObject_TryConvert_AddRule("numpy.int64", Int64, PyLongable_TryConvertRule_integer, 100)
+    PyObject_TryConvert_AddRule("numpy.int128", Int128, PyLongable_TryConvertRule_integer, 100)
+    PyObject_TryConvert_AddRule("numpy.uint8", UInt8, PyLongable_TryConvertRule_integer, 100)
+    PyObject_TryConvert_AddRule("numpy.uint16", UInt16, PyLongable_TryConvertRule_integer, 100)
+    PyObject_TryConvert_AddRule("numpy.uint32", UInt32, PyLongable_TryConvertRule_integer, 100)
+    PyObject_TryConvert_AddRule("numpy.uint64", UInt64, PyLongable_TryConvertRule_integer, 100)
+    PyObject_TryConvert_AddRule("numpy.uint128", UInt128, PyLongable_TryConvertRule_integer, 100)
+    PyObject_TryConvert_AddRule("numpy.float16", Float16, PyFloatable_TryConvertRule_convert, 100)
+    PyObject_TryConvert_AddRule("numpy.float32", Float32, PyFloatable_TryConvertRule_convert, 100)
+    PyObject_TryConvert_AddRule("numpy.float64", Float64, PyFloatable_TryConvertRule_convert, 100)
+    PyObject_TryConvert_AddRule("numpy.complex32", Complex{Float16}, PyComplexable_TryConvertRule_convert, 100)
+    PyObject_TryConvert_AddRule("numpy.complex64", Complex{Float32}, PyComplexable_TryConvertRule_convert, 100)
+    PyObject_TryConvert_AddRule("numpy.complex128", Complex{Float64}, PyComplexable_TryConvertRule_convert, 100)
 end
 
 end

src/cpython/collections.jl

@@ -6,7 +6,6 @@ for n in [:Container, :Hashable, :Iterable, :Iterator, :Reversible, :Generator,
     t = Symbol(p, :_Type)
     tr = Symbol(p, :__ref)
     c = Symbol(p, :_Check)
-    ct = Symbol(p, :_SubclassCheck)
     @eval const $tr = Ref(PyPtr())
     @eval $t() = begin
         ptr = $tr[]
@@ -18,18 +17,11 @@ for n in [:Container, :Hashable, :Iterable, :Iterator, :Reversible, :Generator,
         isnull(b) && return b
         $tr[] = b
     end
-    @eval $c(_o) = GC.@preserve _o begin
-        o = Base.unsafe_convert(PyPtr, _o)
+    @eval $c(o) = begin
         t = $t()
         isnull(t) && return Cint(-1)
         PyObject_IsInstance(o, t)
     end
-    @eval $ct(_o) = GC.@preserve _o begin
-        o = Base.unsafe_convert(PyPtr, _o)
-        t = $t()
-        isnull(t) && return Cint(-1)
-        PyObject_IsSubclass(o, t)
-    end
 end
 
 PyIterable_ConvertRule_vector(o, ::Type{T}, ::Type{S}) where {T, S<:Vector} = begin

src/cpython/complex.jl

@@ -1,6 +1,7 @@
 @cdef :PyComplex_FromDoubles PyPtr (Cdouble, Cdouble)
 @cdef :PyComplex_RealAsDouble Cdouble (PyPtr,)
 @cdef :PyComplex_ImagAsDouble Cdouble (PyPtr,)
+@cdef :PyComplex_AsCComplex Py_complex (PyPtr,)
 
 const PyComplex_Type__ref = Ref(PyPtr())
 PyComplex_Type() = pyglobal(PyComplex_Type__ref, :PyComplex_Type)
@@ -9,23 +10,23 @@ PyComplex_Check(o) = Py_TypeCheck(o, PyComplex_Type())
 
 PyComplex_CheckExact(o) = Py_TypeCheckExact(o, PyComplex_Type())
 
+PyComplex_AsComplex(o) = begin
+    r = PyComplex_AsCComplex(o)
+    Complex(r.real, r.imag)
+end
+
 PyComplex_From(x::Union{Float16,Float32,Float64}) = PyComplex_FromDoubles(x, 0)
 PyComplex_From(x::Complex{<:Union{Float16,Float32,Float64}}) = PyComplex_FromDoubles(real(x), imag(x))
 
-PyComplex_TryConvertRule_convert(o, ::Type{T}, ::Type{S}) where {T,S} = begin
-    x = PyComplex_RealAsDouble(o)
+# "Complexable" means a 'complex' or anything with a '__complex__' method
+PyComplexable_TryConvertRule_convert(o, ::Type{T}, ::Type{S}) where {T,S} = begin
+    x = PyComplex_AsComplex(o)
     ism1(x) && PyErr_IsSet() && return -1
-    y = PyComplex_ImagAsDouble(o)
-    ism1(y) && PyErr_IsSet() && return -1
-    z = Complex(x, y)
-    putresult(T, convert(S, z))
+    putresult(T, convert(S, x))
 end
 
-PyComplex_TryConvertRule_tryconvert(o, ::Type{T}, ::Type{S}) where {T,S} = begin
-    x = PyComplex_RealAsDouble(o)
+PyComplexable_TryConvertRule_tryconvert(o, ::Type{T}, ::Type{S}) where {T,S} = begin
+    x = PyComplexable_AsComplex(o)
     ism1(x) && PyErr_IsSet() && return -1
-    y = PyComplex_ImagAsDouble(o)
-    ism1(y) && PyErr_IsSet() && return -1
-    z = Complex(x, y)
-    putresult(T, tryconvert(S, z))
+    putresult(T, tryconvert(S, x))
 end

src/cpython/float.jl

@@ -10,13 +10,14 @@ PyFloat_CheckExact(o) = Py_TypeCheckExact(o, PyFloat_Type())
 
 PyFloat_From(o::Union{Float16,Float32,Float64}) = PyFloat_FromDouble(o)
 
-PyFloat_TryConvertRule_convert(o, ::Type{T}, ::Type{S}) where {T,S} = begin
+# "Floatable" means a 'float' or anything with a '__float__' method
+PyFloatable_TryConvertRule_convert(o, ::Type{T}, ::Type{S}) where {T,S} = begin
     x = PyFloat_AsDouble(o)
     ism1(x) && PyErr_IsSet() && return -1
     putresult(T, convert(S, x))
 end
 
-PyFloat_TryConvertRule_tryconvert(o, ::Type{T}, ::Type{S}) where {T,S} = begin
+PyFloatable_TryConvertRule_tryconvert(o, ::Type{T}, ::Type{S}) where {T,S} = begin
     x = PyFloat_AsDouble(o)
     ism1(x) && PyErr_IsSet() && return -1
     putresult(T, tryconvert(S, x))

src/cpython/int.jl

@@ -27,7 +27,8 @@ PyLong_From(x::Integer) = begin
     PyLong_From(y::BigInt)
 end
 
-PyLong_TryConvertRule_integer(o, ::Type{T}, ::Type{S}) where {T, S<:Integer} = begin
+# "Longable" means an 'int' or anything with an '__int__' method.
+PyLongable_TryConvertRule_integer(o, ::Type{T}, ::Type{S}) where {T, S<:Integer} = begin
     # first try to convert to Clonglong (or Culonglong if unsigned)
     x = S <: Unsigned ? PyLong_AsUnsignedLongLong(o) : PyLong_AsLongLong(o)
     if !ism1(x) || !PyErr_IsSet()
@@ -56,7 +57,7 @@ PyLong_TryConvertRule_integer(o, ::Type{T}, ::Type{S}) where {T, S<:Integer} = b
     end
 end
 
-PyLong_TryConvertRule_tryconvert(o, ::Type{T}, ::Type{S}) where {T,S} = begin
+PyLongable_TryConvertRule_tryconvert(o, ::Type{T}, ::Type{S}) where {T,S} = begin
     r = PyLong_TryConvertRule_integer(o, Integer, Integer)
     r == 1 ? putresult(T, tryconvert(S, takeresult(Integer))) : r
 end

src/cpython/number.jl

@@ -32,3 +32,26 @@
 @cdef :PyNumber_Long PyPtr (PyPtr,)
 @cdef :PyNumber_Float PyPtr (PyPtr,)
 @cdef :PyNumber_Index PyPtr (PyPtr,)
+
+for n in [:Number, :Complex, :Real, :Rational, :Integral]
+    p = Symbol(:Py, n, :ABC)
+    t = Symbol(p, :_Type)
+    tr = Symbol(p, :__ref)
+    c = Symbol(p, :_Check)
+    @eval const $tr = Ref(PyPtr())
+    @eval $t() = begin
+        ptr = $tr[]
+        isnull(ptr) || return ptr
+        a = PyImport_ImportModule("numbers")
+        isnull(a) && return a
+        b = PyObject_GetAttrString(a, $(string(n)))
+        Py_DecRef(a)
+        isnull(b) && return b
+        $tr[] = b
+    end
+    @eval $c(o) = begin
+        t = $t()
+        isnull(t) && return Cint(-1)
+        PyObject_IsInstance(o, t)
+    end
+end