split Compat into independent modules

Author: Christopher Doris

src/Compat/Compat.jl

@@ -1,31 +1,5 @@
-"""
-    module PythonCall.Compat
-
-Misc bits and bobs for compatibility.
-"""
+"""Misc bits and bobs for compatibility."""
 module Compat
-using ..PythonCall
-using ..Core
-using ..Core:
-    Core,
-    C,
-    Utils,
-    pynew,
-    incref,
-    getptr,
-    pycopy!,
-    pymodulehooks,
-    pyisnull,
-    pybytes_asvector,
-    pysysmodule,
-    pyosmodule,
-    pystr_fromUTF8
-using ..Convert: pyconvert, @pyconvert
-using ..Wrap: PyArray, PyPandasDataFrame
-using Serialization: Serialization, AbstractSerializer, serialize, deserialize
-using Tables: Tables
-using Requires: @require
-import ..PythonCall: pytable, event_loop_on, event_loop_off, fix_qt_plugin_path
 
 include("gui.jl")
 include("ipython.jl")
@@ -34,10 +8,4 @@ include("serialization.jl")
 include("tables.jl")
 include("pycall.jl")
 
-function __init__()
-    init_gui()
-    init_pyshow()
-    init_tables()
-    @require PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" init_pycall(PyCall)
-end
 end

src/Compat/gui.jl

@@ -1,3 +1,12 @@
+"""Integration with various GUI libraries"""
+module GUI
+
+using ...PythonCall
+using ...C: C
+using ...Core: pynew, pyosmodule, pycopy!, pymodulehooks
+
+import ...PythonCall: event_loop_on, event_loop_off, fix_qt_plugin_path
+
 """
     fix_qt_plugin_path()
 
@@ -58,7 +67,7 @@ const EVENT_LOOPS = Dict{Symbol,Base.Timer}()
 
 const new_event_loop_callback = pynew()
 
-function init_gui()
+function __init__()
     if !C.CTX.is_embedded
         # define callbacks
         g = pydict()
@@ -205,3 +214,5 @@ function _unset_python_input_hook()
     C.PyOS_SetInputHook(C_NULL)
     return
 end
+
+end

src/Compat/ipython.jl

@@ -1,3 +1,9 @@
+"""Integration with IPython"""
+module IPython
+
+using ...PythonCall
+using ...Core: pystr_fromUTF8
+
 """
     PythonDisplay()
 
@@ -68,3 +74,5 @@ function Base.display(d::IPythonDisplay, @nospecialize(x))
     ipy.display.display(dict, raw = true)
     return
 end
+
+end

src/Compat/multimedia.jl

@@ -1,4 +1,8 @@
-### Extensible system for multimedia display of Python objects
+"""Extensible system for multimedia display of Python objects"""
+module Multimedia
+
+using ...PythonCall
+using ...Core: pyisnull, pysysmodule
 
 const PYSHOW_RULES = Function[]
 
@@ -124,7 +128,7 @@ function pyshow_rule_savefig(io::IO, mime::String, x::Py)
     end
 end
 
-function init_pyshow()
+function __init__()
     pyshow_add_rule(pyshow_rule_mimebundle)
     pyshow_add_rule(pyshow_rule_repr)
     pyshow_add_rule(pyshow_rule_savefig)
@@ -150,3 +154,5 @@ Base.show(io::IO, mime::MIME"text/csv", df::PyPandasDataFrame) = pyshow(io, mime
 Base.show(io::IO, mime::MIME"text/tab-separated-values", df::PyPandasDataFrame) =
     pyshow(io, mime, df)
 Base.showable(mime::MIME, df::PyPandasDataFrame) = pyshowable(mime, df)
+
+end

src/Compat/pycall.jl

@@ -1,3 +1,12 @@
+"""Interoperability with PyCall.jl"""
+module PyCall
+
+using ...PythonCall
+using ...C: C
+using ...Core: pynew
+
+using Requires: @require
+
 function init_pycall(PyCall::Module)
     # allow explicit conversion between PythonCall.Py and PyCall.PyObject
     # provided they are using the same interpretr
@@ -10,7 +19,7 @@ function init_pycall(PyCall::Module)
     - Set the environment variable `PYTHON` to `PythonCall.C.CTX.exe_path` and rebuild PyCall. This forces PyCall
       to use the same interpreter as PythonCall, but needs to be repeated whenever you switch Julia environment.
     """
-    @eval function Core.Py(x::$PyCall.PyObject)
+    @eval function PythonCall.Py(x::$PyCall.PyObject)
         C.CTX.matches_pycall::Bool || error($errmsg)
         return pynew(C.PyPtr($PyCall.pyreturn(x)))
     end
@@ -19,3 +28,9 @@ function init_pycall(PyCall::Module)
         return $PyCall.PyObject($PyCall.PyPtr(incref(getptr(x))))
     end
 end
+
+function __init__()
+    @require PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" init_pycall(PyCall)
+end
+
+end

src/Compat/serialization.jl

@@ -1,33 +1,36 @@
-### Py
-#
-# We use pickle to serialise Python objects to bytes.
+module Serialization
+
+using ...PythonCall
+using ...Core: pyisnull, pybytes_asvector, pynew
+
+using Serialization: Serialization as S
 
 _pickle_module() = pyimport(get(ENV, "JULIA_PYTHONCALL_PICKLE", "pickle"))
 
 function serialize_py(s, x::Py)
     if pyisnull(x)
-        serialize(s, nothing)
+        S.serialize(s, nothing)
     else
         b = _pickle_module().dumps(x)
-        serialize(s, pybytes_asvector(b))
+        S.serialize(s, pybytes_asvector(b))
     end
 end
 
 function deserialize_py(s)
-    v = deserialize(s)
+    v = S.deserialize(s)
     if v === nothing
         pynew()
     else
         _pickle_module().loads(pybytes(v))
     end
 end
 
-function Serialization.serialize(s::AbstractSerializer, x::Py)
-    Serialization.serialize_type(s, Py, false)
+function S.serialize(s::S.AbstractSerializer, x::Py)
+    S.serialize_type(s, Py, false)
     serialize_py(s, x)
 end
 
-Serialization.deserialize(s::AbstractSerializer, ::Type{Py}) = deserialize_py(s)
+S.deserialize(s::S.AbstractSerializer, ::Type{Py}) = deserialize_py(s)
 
 ### PyException
 #
@@ -38,26 +41,27 @@ Serialization.deserialize(s::AbstractSerializer, ::Type{Py}) = deserialize_py(s)
 # This means the user can install something like "tblib" to enable pickling of tracebacks
 # and for free this enables serializing PyException including the traceback.
 
-function Serialization.serialize(s::AbstractSerializer, x::PyException)
-    Serialization.serialize_type(s, PyException, false)
+function S.serialize(s::S.AbstractSerializer, x::PyException)
+    S.serialize_type(s, PyException, false)
     serialize_py(s, x.v)
 end
 
-Serialization.deserialize(s::AbstractSerializer, ::Type{PyException}) =
-    PyException(deserialize_py(s))
+S.deserialize(s::S.AbstractSerializer, ::Type{PyException}) = PyException(deserialize_py(s))
 
 ### PyArray
 #
 # This type holds a pointer and a handle (usually a python memoryview or capsule) which are
 # not serializable by default, and even if they were would not be consistent after
 # serializing each field independently. So we just serialize the wrapped Python object.
 
-function Serialization.serialize(s::AbstractSerializer, x::PyArray)
-    Serialization.serialize_type(s, typeof(x), false)
+function S.serialize(s::S.AbstractSerializer, x::PyArray)
+    S.serialize_type(s, typeof(x), false)
     serialize_py(s, x.py)
 end
 
-function Serialization.deserialize(s::AbstractSerializer, ::Type{T}) where {T<:PyArray}
+function S.deserialize(s::S.AbstractSerializer, ::Type{T}) where {T<:PyArray}
     # TODO: set buffer and array args too?
     T(deserialize_py(s); copy = false)
 end
+
+end

src/Compat/tables.jl

@@ -1,3 +1,13 @@
+module Tables
+
+using ...PythonCall
+using Tables: Tables as T
+
+using Requires: @require
+
+import ...PythonCall: pytable
+
+
 asvector(x::AbstractVector) = x
 asvector(x) = collect(x)
 
@@ -27,44 +37,40 @@ function pytable(src, format = :pandas; opts...)
     end
 end
 
-function _pytable_columns(src, cols = Tables.columns(src))
-    pydict(
-        pystr(String(n)) => asvector(Tables.getcolumn(cols, n)) for
-        n in Tables.columnnames(cols)
-    )
+function _pytable_columns(src, cols = T.columns(src))
+    pydict(pystr(String(n)) => asvector(T.getcolumn(cols, n)) for n in T.columnnames(cols))
 end
 
-function _pytable_rows(src, rows = Tables.rows(src))
-    names = Tables.columnnames(rows)
+function _pytable_rows(src, rows = T.rows(src))
+    names = T.columnnames(rows)
     t = pyimport("collections" => "namedtuple")(
         "Row",
         pylist(pystr(string(n)) for n in names),
     )
-    pylist(t(map(n -> Tables.getcolumn(row, n), names)...) for row in rows)
+    pylist(t(map(n -> T.getcolumn(row, n), names)...) for row in rows)
 end
 
-function _pytable_rowdicts(src, rows = Tables.rows(src))
-    names = Tables.columnnames(rows)
+function _pytable_rowdicts(src, rows = T.rows(src))
+    names = T.columnnames(rows)
     pynames = [pystr(string(n)) for n in names]
     pylist(
-        pydict(p => Tables.getcolumn(row, n) for (n, p) in zip(names, pynames)) for
-        row in rows
+        pydict(p => T.getcolumn(row, n) for (n, p) in zip(names, pynames)) for row in rows
     )
 end
 
 aspandasvector(x) = asvector(x)
 
-function _pytable_pandas(src, cols = Tables.columns(src); opts...)
+function _pytable_pandas(src, cols = T.columns(src); opts...)
     pyimport("pandas").DataFrame(
         pydict(
-            pystr(string(n)) => aspandasvector(Tables.getcolumn(cols, n)) for
-            n in Tables.columnnames(cols)
+            pystr(string(n)) => aspandasvector(T.getcolumn(cols, n)) for
+            n in T.columnnames(cols)
         );
         opts...,
     )
 end
 
-function init_tables()
+function __init__()
     @require CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597" @eval begin
         aspandasvector(x::CategoricalArrays.CategoricalArray) = begin
             codes = map(x -> x === missing ? -1 : Int(CategoricalArrays.levelcode(x)) - 1, x)
@@ -74,3 +80,5 @@ function init_tables()
         end
     end
 end
+
+end

test/Compat.jl

@@ -21,7 +21,7 @@ end
         pystdout = sys.stdout
         fp = sys.stdout = io.StringIO()
         try
-            d = PythonCall.Internals.Compat.PythonDisplay()
+            d = PythonCall.Internals.Compat.IPython.PythonDisplay()
             @test display(d, 123) === nothing
             fp.seek(0)
             @test pyconvert(String, fp.read()) == "123\n"