move to new PythonCall.GC module

Author: Christopher Doris

docs/src/releasenotes.md

@@ -1,6 +1,7 @@
 # Release Notes
 
 ## Unreleased
+* Adds `PythonCall.GC.disable()` and `PythonCall.GC.enable()`.
 * Experimental new function `juliacall.interactive()` allows the Julia async event loop to
   run in the background of the Python REPL.
 * Experimental new IPython extension `juliacall.ipython` providing the `%jl` and `%%jl`

src/Py.jl

@@ -43,7 +43,7 @@ mutable struct Py
 end
 export Py
 
-py_finalizer(x::Py) = C.gc_enqueue(getptr(x))
+py_finalizer(x::Py) = GC.enqueue(getptr(x))
 
 ispy(::Py) = true
 getptr(x::Py) = getfield(x, :ptr)

src/cpython/gc.jl

@@ -0,0 +1,83 @@
+"""
+Garbarge collection of Python objects.
+
+See `disable` and `enable`.
+"""
+module GC
+
+import ..PythonCall.C
+
+const ENABLED = Ref(true)
+const QUEUE = PyPtr[]
+
+"""
+    PythonCall.GC.disable()
+
+Disable the PythonCall garbage collector.
+
+This means that whenever a Python object owned by Julia is finalized, it is not immediately
+freed but is instead added to a queue of objects to free later when `enable()` is called.
+
+Like most PythonCall functions, you must only call this from the main thread.
+"""
+function disable()
+    ENABLED[] = false
+    return
+end
+
+"""
+    PythonCall.GC.enable()
+
+Re-enable the PythonCall garbage collector.
+
+This frees any Python objects which were finalized while the GC was disabled, and allows
+objects finalized in the future to be freed immediately.
+
+Like most PythonCall functions, you must only call this from the main thread.
+"""
+function enable()
+    ENABLED[] = true
+    if !isempty(QUEUE)
+        C.with_gil(false) do
+            for ptr in QUEUE
+                if ptr != C.PyNULL
+                    C.Py_DecRef(ptr)
+                end
+            end
+        end
+    end
+    empty!(QUEUE)
+    return
+end
+
+function enqueue(ptr::C.PyPtr)
+    if ptr != C.PyNULL && C.CTX.is_initialized
+        if ENABLED[]
+            C.with_gil(false) do
+                C.Py_DecRef(ptr)
+            end
+        else
+            push!(QUEUE, ptr)
+        end
+    end
+    return
+end
+
+function enqueue_all(ptrs)
+    if C.CTX.is_initialized
+        if ENABLED[]
+            C.with_gil(false) do
+                for ptr in ptrs
+                    if ptr != C.PyNULL
+                        C.Py_DecRef(ptr)
+                    end
+                end
+            end
+        else
+            append!(QUEUE, ptrs)
+        end
+    end
+    return
+end
+
+end # module GC

src/gc.jl

@@ -23,7 +23,7 @@ PyObjectArray(undef::UndefInitializer, dims::Vararg{Integer,N}) where {N} = PyOb
 PyObjectArray{N}(x::AbstractArray{T,N}) where {T,N} = copyto!(PyObjectArray{N}(undef, size(x)), x)
 PyObjectArray(x::AbstractArray{T,N}) where {T,N} = PyObjectArray{N}(x)
 
-pyobjectarray_finalizer(x::PyObjectArray) = C.gc_enqueue_all(x.ptrs)
+pyobjectarray_finalizer(x::PyObjectArray) = GC.enqueue_all(x.ptrs)
 
 Base.IndexStyle(x) = Base.IndexStyle(x.ptrs)