wrappers no longer assume they own their object, and do not define pydel

Author: Christopher Doris

src/pywrap/PyDict.jl

@@ -7,7 +7,7 @@ If `x` is not a Python object, it is converted to one using `pydict`.
 """
 struct PyDict{K,V} <: AbstractDict{K,V}
     py :: Py
-    PyDict{K,V}(x=pydict()) where {K,V} = new{K,V}(ispy(x) ? pynew(Py(x)) : pydict(x))
+    PyDict{K,V}(x=pydict()) where {K,V} = new{K,V}(ispy(x) ? Py(x) : pydict(x))
 end
 export PyDict
 
@@ -16,7 +16,6 @@ PyDict(x=pydict()) = PyDict{Py,Py}(x)
 
 ispy(::PyDict) = true
 Py(x::PyDict) = x.py
-pydel!(x::PyDict) = pydel!(x.py)
 
 pyconvert_rule_mapping(::Type{T}, x::Py, ::Type{PyDict{K,V}}=Utils._type_ub(T)) where {T<:PyDict,K,V} =
     if PyDict{Py,Py} <: T

src/pywrap/PyIO.jl

@@ -39,21 +39,19 @@ mutable struct PyIO <: IO
         ibuflen > 0 || error("ibuflen must be positive")
         obuflen = convert(Int, obuflen)
         obuflen > 0 || error("obuflen must be positive")
-        new(pynew(Py(x)), own, text, false, ibuflen, UInt8[], obuflen, UInt8[])
+        new(Py(x), own, text, false, ibuflen, UInt8[], obuflen, UInt8[])
     end
 end
 export PyIO
 
 pyio_finalize!(io::PyIO) = begin
     C.CTX.is_initialized || return
     io.own ? close(io) : flush(io)
-    pydel!(io.py)
     return
 end
 
 ispy(io::PyIO) = true
 Py(io::PyIO) = io.py
-pydel!(io::PyIO) = (finalize(io); nothing)
 
 pyconvert_rule_io(::Type{PyIO}, x::Py) = pyconvert_return(PyIO(x))
 

src/pywrap/PyIterable.jl

@@ -5,15 +5,14 @@ This object iterates over iterable Python object `x`, yielding values of type `T
 """
 struct PyIterable{T}
     py :: Py
-    PyIterable{T}(x) where {T} = new{T}(pynew(Py(x)))
+    PyIterable{T}(x) where {T} = new{T}(Py(x))
 end
 export PyIterable
 
 PyIterable(x) = PyIterable{Py}(x)
 
 ispy(x::PyIterable) = true
 Py(x::PyIterable) = x.py
-pydel!(x::PyIterable) = pydel!(x.py)
 
 Base.IteratorSize(::Type{PyIterable{T}}) where {T} = Base.SizeUnknown()
 Base.eltype(::Type{PyIterable{T}}) where {T} = T

src/pywrap/PyList.jl

@@ -7,15 +7,14 @@ If `x` is not a Python object, it is converted to one using `pylist`.
 """
 struct PyList{T} <: AbstractVector{T}
     py :: Py
-    PyList{T}(x=pylist()) where {T} = new{T}(ispy(x) ? pynew(Py(x)) : pylist(x))
+    PyList{T}(x=pylist()) where {T} = new{T}(ispy(x) ? Py(x) : pylist(x))
 end
 export PyList
 
 PyList(x=pylist()) = PyList{Py}(x)
 
 ispy(::PyList) = true
 Py(x::PyList) = x.py
-pydel!(x::PyList) = pydel!(x.py)
 
 pyconvert_rule_sequence(::Type{T}, x::Py, ::Type{PyList{V}}=Utils._type_ub(T)) where {T<:PyList,V} =
     if PyList{Py} <: T

src/pywrap/PyPandasDataFrame.jl

@@ -16,14 +16,13 @@ struct PyPandasDataFrame <: PyTable
     columnnames::Function # Py -> Symbol
     columntypes::Function # Symbol -> Union{Type,Nothing}
     function PyPandasDataFrame(x; indexname::Union{Symbol,Nothing}=nothing, columnnames::Function=x->Symbol(x), columntypes::Function=x->nothing)
-        new(pynew(Py(x)), indexname, columnnames, columntypes)
+        new(Py(x), indexname, columnnames, columntypes)
     end
 end
 export PyPandasDataFrame
 
 ispy(x::PyPandasDataFrame) = true
 Py(x::PyPandasDataFrame) = x.py
-pydel!(x::PyPandasDataFrame) = pydel!(x.py)
 
 pyconvert_rule_pandasdataframe(::Type{PyPandasDataFrame}, x::Py) = pyconvert_return(PyPandasDataFrame(x))
 

src/pywrap/PySet.jl

@@ -7,15 +7,14 @@ If `x` is not a Python object, it is converted to one using `pyset`.
 """
 struct PySet{T} <: AbstractSet{T}
     py :: Py
-    PySet{T}(x=pyset()) where {T} = new{T}(ispy(x) ? pynew(Py(x)) : pyset(x))
+    PySet{T}(x=pyset()) where {T} = new{T}(ispy(x) ? Py(x) : pyset(x))
 end
 export PySet
 
 PySet(x=pyset()) = PySet{Py}(x)
 
 ispy(::PySet) = true
 Py(x::PySet) = x.py
-pydel!(x::PySet) = pydel!(x.py)
 
 pyconvert_rule_set(::Type{T}, x::Py, ::Type{PySet{V}}=Utils._type_ub(T)) where {T<:PySet,V} =
     if PySet{Py} <: T