move wrapper types into separate modules

Author: Christopher Doris

src/Convert/Convert.jl

@@ -50,6 +50,16 @@ using Dates: Date, Time, DateTime, Second, Millisecond, Microsecond, Nanosecond
 import PythonCall:
     pyconvert, @pyconvert, pyconvert_add_rule, pyconvert_return, pyconvert_unconverted
 
+# internal API
+export pyconvert_add_rule,
+    pyconvert_return,
+    pyconvert_isunconverted,
+    pyconvert_result,
+    pyconvert_tryconvert,
+    PYCONVERT_PRIORITY_ARRAY,
+    PYCONVERT_PRIORITY_CANONICAL,
+    PYCONVERT_PRIORITY_NORMAL
+
 include("pyconvert.jl")
 include("rules.jl")
 include("ctypes.jl")

src/Core/Core.jl

@@ -128,6 +128,19 @@ import PythonCall:
     pydel!,
     unsafe_pynext
 
+# internal API
+export pynew,
+    pyisnull,
+    pycopy!,
+    getptr,
+    pydel!,
+    unsafe_pynext,
+    PyNULL,
+    @autopy,
+    pystr_fromUTF8,
+    pystr_asUTF8vector,
+    pybytes_asvector
+
 const ROOT_DIR = dirname(dirname(@__DIR__))
 
 include("Py.jl")

src/Wrap/PyArray.jl

@@ -1,3 +1,16 @@
+module PyArrays
+
+using ...PythonCall
+using ...Utils
+using ...C
+using ...Core
+using ...Convert
+
+using Base: @propagate_inbounds
+
+import ...PythonCall: PyArray, ispy, Py
+
+
 struct UnsafePyObject
     ptr::C.PyPtr
 end
@@ -670,3 +683,23 @@ function pyarray_check_T(::Type{T}, ::Type{R}) where {T,R}
         error("invalid eltype T=$T for raw eltype R=$R")
     end
 end
+
+function __init__()
+    priority = PYCONVERT_PRIORITY_ARRAY
+    pyconvert_add_rule("<arraystruct>", PyArray, pyconvert_rule_array_nocopy, priority)
+    pyconvert_add_rule("<arrayinterface>", PyArray, pyconvert_rule_array_nocopy, priority)
+    pyconvert_add_rule("<array>", PyArray, pyconvert_rule_array_nocopy, priority)
+    pyconvert_add_rule("<buffer>", PyArray, pyconvert_rule_array_nocopy, priority)
+
+    priority = PYCONVERT_PRIORITY_NORMAL
+    pyconvert_add_rule("<arraystruct>", Array, pyconvert_rule_array, priority)
+    pyconvert_add_rule("<arrayinterface>", Array, pyconvert_rule_array, priority)
+    pyconvert_add_rule("<array>", Array, pyconvert_rule_array, priority)
+    pyconvert_add_rule("<buffer>", Array, pyconvert_rule_array, priority)
+    pyconvert_add_rule("<arraystruct>", AbstractArray, pyconvert_rule_array, priority)
+    pyconvert_add_rule("<arrayinterface>", AbstractArray, pyconvert_rule_array, priority)
+    pyconvert_add_rule("<array>", AbstractArray, pyconvert_rule_array, priority)
+    pyconvert_add_rule("<buffer>", AbstractArray, pyconvert_rule_array, priority)
+end
+
+end

src/Wrap/PyDict.jl

@@ -1,3 +1,12 @@
+module PyDicts
+
+using ...PythonCall
+using ...Utils
+using ...Core
+using ...Convert
+
+import ...PythonCall: PyDict, ispy, Py
+
 PyDict{K}(x = pydict()) where {K} = PyDict{K,Py}(x)
 PyDict(x = pydict()) = PyDict{Py,Py}(x)
 
@@ -99,3 +108,14 @@ function Base.get!(f::Union{Function,Type}, x::PyDict{K,V}, k) where {K,V}
         return x[k] = convert(V, f())
     end
 end
+
+function __init__()
+    pyconvert_add_rule(
+        "collections.abc:Mapping",
+        PyDict,
+        pyconvert_rule_mapping,
+        PYCONVERT_PRIORITY_CANONICAL,
+    )
+end
+
+end

src/Wrap/PyIO.jl

@@ -1,3 +1,12 @@
+module PyIOs
+
+using ...PythonCall
+using ...Utils
+using ...Core
+using ...Convert
+
+import ...PythonCall: PyIO, ispy, Py
+
 pyio_finalize!(io::PyIO) = begin
     C.CTX.is_initialized || return
     io.own ? close(io) : flush(io)
@@ -213,3 +222,10 @@ function Base.position(io::PyIO)
         return pyconvert(Int, @py io.tell()) - length(io.ibuf)
     end
 end
+
+function __init__()
+    pyconvert_add_rule("io:IOBase", PyIO, pyconvert_rule_io, PYCONVERT_PRIORITY_CANONICAL)
+    pyconvert_add_rule("_io:_IOBase", PyIO, pyconvert_rule_io, PYCONVERT_PRIORITY_CANONICAL)
+end
+
+end

src/Wrap/PyIterable.jl

@@ -1,3 +1,12 @@
+module PyIterables
+
+using ...PythonCall
+using ...Utils
+using ...Core
+using ...Convert
+
+import ...PythonCall: PyIterable, ispy, Py
+
 PyIterable(x) = PyIterable{Py}(x)
 
 ispy(x::PyIterable) = true
@@ -23,3 +32,14 @@ function pyconvert_rule_iterable(
 ) where {T<:PyIterable,T1}
     pyconvert_return(T1(x))
 end
+
+function __init__()
+    pyconvert_add_rule(
+        "collections.abc:Iterable",
+        PyIterable,
+        pyconvert_rule_iterable,
+        PYCONVERT_PRIORITY_CANONICAL,
+    )
+end
+
+end

src/Wrap/PyList.jl

@@ -1,3 +1,12 @@
+module PyLists
+
+using ...PythonCall
+using ...Utils
+using ...Core
+using ...Convert
+
+import ...PythonCall: PyList, ispy, Py
+
 PyList(x = pylist()) = PyList{Py}(x)
 
 ispy(::PyList) = true
@@ -88,3 +97,20 @@ end
 function Base.copy(x::PyList{T}) where {T}
     return PyList{T}(@py x.copy())
 end
+
+function __init__()
+    pyconvert_add_rule(
+        "collections.abc:Sequence",
+        PyList,
+        pyconvert_rule_sequence,
+        PYCONVERT_PRIORITY_CANONICAL,
+    )
+    pyconvert_add_rule(
+        "pandas.core.arrays.base:ExtensionArray",
+        PyList,
+        pyconvert_rule_sequence,
+        PYCONVERT_PRIORITY_CANONICAL,
+    )
+end
+
+end

src/Wrap/PyPandasDataFrame.jl

@@ -1,3 +1,13 @@
+module PyPandasDataFrames
+
+using ...PythonCall
+using ...Utils
+using ...Convert
+
+using Tables: Tables
+
+import ...PythonCall: PyPandasDataFrame, ispy, Py
+
 ispy(x::PyPandasDataFrame) = true
 Py(x::PyPandasDataFrame) = x.py
 
@@ -66,3 +76,14 @@ function _columns(df, columnnames, columntypes)
     table = Tables.DictColumnTable(schema, coldict)
     Tables.columns(table)
 end
+
+function __init__()
+    pyconvert_add_rule(
+        "pandas.core.frame:DataFrame",
+        PyPandasDataFrame,
+        pyconvert_rule_pandasdataframe,
+        PYCONVERT_PRIORITY_CANONICAL,
+    )
+end
+
+end

src/Wrap/PySet.jl

@@ -1,3 +1,12 @@
+module PySets
+
+using ...PythonCall
+using ...Utils
+using ...Core
+using ...Convert
+
+import ...PythonCall: PySet, ispy, Py
+
 PySet(x = pyset()) = PySet{Py}(x)
 
 ispy(::PySet) = true
@@ -86,3 +95,14 @@ end
 function Base.copy(x::PySet{T}) where {T}
     return PySet{T}(@py x.copy())
 end
+
+function __init__()
+    pyconvert_add_rule(
+        "collections.abc:Set",
+        PySet,
+        pyconvert_rule_set,
+        PYCONVERT_PRIORITY_CANONICAL,
+    )
+end
+
+end

src/Wrap/PyTable.jl

@@ -1,3 +1,9 @@
+module PyTables
+
+using ...PythonCall
+
+import ...PythonCall: PyTable
+
 PyTable(x) = pyconvert(PyTable, x)
 
 # Tables.istable(x::Py) = Tables.istable(@pyconvert(PyTable, x, return false))
@@ -6,3 +12,5 @@ PyTable(x) = pyconvert(PyTable, x)
 # Tables.columnaccess(x::Py) = Tables.columnaccess(@pyconvert(PyTable, x, return false))
 # Tables.columns(x::Py) = Tables.columns(pyconvert(PyTable, x))
 # Tables.materializer(x::Py) = Tables.materializer(pyconvert(PyTable, x))
+
+end