nicer eltypes for PyArray

Author: Christopher Doris

docs/src/releasenotes.md

@@ -1,5 +1,10 @@
 # Release Notes
 
+## Unreleased
+* In `PyArray{T}(x)`, the eltype `T` no longer needs to exactly match the stored data type.
+  If `x` has numeric elements, then any number type `T` is allowed. If `x` has string
+  elements, then any string type `T` is allowed.
+
 ## 0.9.10 (2022-12-02)
 * Bug fixes.
 

src/pywrap/PyArray.jl

@@ -614,22 +614,55 @@ pyarray_offset(x::PyArray{T,1,M,true}, i::Int) where {T,M} = (i - 1) .* x.stride
 pyarray_offset(x::PyArray{T,N}, i::Vararg{Int,N}) where {T,N} = sum((i .- 1) .* x.strides)
 pyarray_offset(x::PyArray{T,0}) where {T} = 0
 
-pyarray_load(::Type{R}, p::Ptr{R}) where {R} = unsafe_load(p)
-pyarray_load(::Type{T}, p::Ptr{UnsafePyObject}) where {T} = begin
-    u = unsafe_load(p)
-    o = u.ptr == C_NULL ? pynew(Py(nothing)) : pynew(incref(u.ptr))
-    T == Py ? o : pyconvert(T, o)
+function pyarray_load(::Type{T}, p::Ptr{R}) where {T,R}
+    if R == T
+        unsafe_load(p)
+    elseif R == UnsafePyObject
+        u = unsafe_load(p)
+        o = u.ptr == C_NULL ? pynew(Py(nothing)) : pynew(incref(u.ptr))
+        T == Py ? o : pyconvert(T, o)
+    else
+        convert(T, unsafe_load(p))
+    end
 end
 
-pyarray_store!(p::Ptr{R}, x::R) where {R} = unsafe_store!(p, x)
-pyarray_store!(p::Ptr{UnsafePyObject}, x::UnsafePyObject) = unsafe_store!(p, x)
-pyarray_store!(p::Ptr{UnsafePyObject}, x) = @autopy x begin
-    decref(unsafe_load(p).ptr)
-    unsafe_store!(p, UnsafePyObject(incref(getptr(x_))))
+function pyarray_store!(p::Ptr{R}, x::T) where {R,T}
+    if R == T
+        unsafe_store!(p, x)
+    elseif R == UnsafePyObject
+        @autopy x begin
+            decref(unsafe_load(p).ptr)
+            unsafe_store!(p, UnsafePyObject(incref(getptr(x_))))
+        end
+    else
+        unsafe_store!(p, convert(R, x))
+    end
 end
 
-pyarray_get_T(::Type{R}, ::Type{T0}, ::Type{T1}) where {R,T0,T1} = T0 <: R <: T1 ? R : error("not possible")
-pyarray_get_T(::Type{UnsafePyObject}, ::Type{T0}, ::Type{T1}) where {T0,T1} = T0 <: Py <: T1 ? Py : T1
+function pyarray_get_T(::Type{R}, ::Type{T0}, ::Type{T1}) where {R,T0,T1}
+    if R == UnsafePyObject
+        if T0 <: Py <: T1
+            Py
+        else
+            T1
+        end
+    elseif T0 <: R <: T1
+        R
+    else
+        error("impossible")
+    end
+end
 
-pyarray_check_T(::Type{T}, ::Type{R}) where {T,R} = T == R ? nothing : error("invalid eltype T=$T for raw eltype R=$R")
-pyarray_check_T(::Type{T}, ::Type{UnsafePyObject}) where {T} = nothing
+function pyarray_check_T(::Type{T}, ::Type{R}) where {T,R}
+    if R == UnsafePyObject
+        nothing
+    elseif T == R
+        nothing
+    elseif T <: Number && R <: Number
+        nothing
+    elseif T <: AbstractString && R <: AbstractString
+        nothing
+    else
+        error("invalid eltype T=$T for raw eltype R=$R")
+    end
+end   

src/utils.jl

@@ -169,10 +169,11 @@ module Utils
         StaticString{T,N}(codeunits::NTuple{N,T}) where {T,N} = new{T,N}(codeunits)
     end
 
-    function Base.print(io::IO, x::StaticString)
-        cs = collect(x.codeunits)
-        i = findfirst(==(0), cs)
-        print(io, transcode(String, i===nothing ? cs : cs[1:i-1]))
+    function Base.String(x::StaticString{T,N}) where {T,N}
+        i = findfirst(iszero, x.codeunits)
+        j = i === nothing ? N : i - 1
+        cs = T[x.codeunits[i] for i in 1:j]
+        transcode(String, cs)
     end
 
     function Base.convert(::Type{StaticString{T,N}}, x::AbstractString) where {T,N}