another second off init

Author: Christopher Doris

src/PyRef.jl

@@ -18,6 +18,7 @@ mutable struct PyRef
                 ptr = x.ptr
                 if !isnull(ptr)
                     with_gil(false) do
+                        @assert C.Py_RefCnt(ptr) > 0
                         C.Py_DecRef(ptr)
                     end
                     x.ptr = C_NULL

src/cpython/CPython.jl

@@ -100,7 +100,7 @@ include("juliaio.jl")
 include("as.jl")
 include("arg.jl")
 
-@init begin
+init() = begin
     PyObject_TryConvert_AddRule("builtins.NoneType", Nothing, PyNone_TryConvertRule_nothing, 100)
     PyObject_TryConvert_AddRule("builtins.NoneType", Missing, PyNone_TryConvertRule_missing)
     PyObject_TryConvert_AddRule("builtins.bool", Bool, PyBool_TryConvertRule_bool, 100)
@@ -150,6 +150,7 @@ include("arg.jl")
     PyObject_TryConvert_AddRule("datetime.timedelta", Dates.Period, PyTimeDelta_TryConvertRule_period, 100)
     PyObject_TryConvert_AddRule("datetime.timedelta", Dates.CompoundPeriod, PyTimeDelta_TryConvertRule_compoundperiod)
     PyObject_TryConvert_AddRule("juliacall.ValueBase", Any, PyJuliaValue_TryConvert_any, 1000)
+    PyObject_TryConvert_AddRule("juliacall.As", Any, PyAs_ConvertRule_tryconvert, 1000)
     PyObject_TryConvert_AddExtraType(PyIterableABC_Type)
     PyObject_TryConvert_AddExtraType(PyCallableABC_Type)
     PyObject_TryConvert_AddExtraType(PySequenceABC_Type)
@@ -247,5 +248,10 @@ include("arg.jl")
         PyObject_TryConvert_AddRule("numpy.$p", Any, PyNumpySimpleData_TryConvert_value{T,true}())
     end
 end
+precompile(init, ())
+@init init()
+
+precompile(PyJuliaValue_New, (PyPtr, Function))
+precompile(PyMappingABC_Type, ())
 
 end

src/cpython/as.jl

@@ -1,5 +1,3 @@
-@init PyObject_TryConvert_AddRule("juliacall.As", Any, PyAs_ConvertRule_tryconvert)
-
 PyAs_ConvertRule_tryconvert(o, ::Type{S}) where {S} = begin
     # get the type
     to = PyObject_GetAttrString(o, "type")

src/cpython/juliaany.jl

@@ -1,68 +1,3 @@
-const PyJuliaAnyValue_Type__ref = Ref(PyNULL)
-PyJuliaAnyValue_Type() = begin
-    ptr = PyJuliaAnyValue_Type__ref[]
-    if isnull(ptr)
-        c = []
-        base = PyJuliaBaseValue_Type()
-        isnull(base) && return PyNULL
-        t = fill(
-            PyType_Create(
-                c,
-                name = "juliacall.AnyValue",
-                base = base,
-                repr = pyjlany_repr,
-                str = pyjlany_str,
-                getattro = pyjlany_getattro,
-                setattro = pyjlany_setattro,
-                call = pyjlany_call,
-                iter = pyjlany_iter,
-                richcompare = pyjlany_richcompare,
-                as_mapping = (
-                    length = pyjlany_length,
-                    subscript = pyjlany_getitem,
-                    ass_subscript = pyjlany_setitem,
-                ),
-                as_sequence = (contains = pyjlany_contains,),
-                as_number = (
-                    positive = pyjlany_positive,
-                    negative = pyjlany_negative,
-                    absolute = pyjlany_absolute,
-                    power = pyjlany_power,
-                    add = pyjlany_binop(+),
-                    subtract = pyjlany_binop(-),
-                    multiply = pyjlany_binop(*),
-                    truedivide = pyjlany_binop(/),
-                    divmod = pyjlany_binop((x, y) -> (fld(x, y), mod(x, y))),
-                    floordivide = pyjlany_binop(fld),
-                    remainder = pyjlany_binop(mod),
-                    lshift = pyjlany_binop(<<),
-                    rshift = pyjlany_binop(>>),
-                    and = pyjlany_binop(&),
-                    xor = pyjlany_binop(xor),
-                    or = pyjlany_binop(|),
-                ),
-                methods = [
-                    (name = "__dir__", flags = Py_METH_NOARGS, meth = pyjlany_dir),
-                    (name = "_repr_mimebundle_", flags = Py_METH_VARARGS | Py_METH_KEYWORDS, meth = pyjlany_repr_mimebundle),
-                    (name = "_jl_raw", flags = Py_METH_NOARGS, meth = pyjlany_toraw),
-                    (name = "_jl_display", flags = Py_METH_NOARGS, meth = pyjlany_display),
-                    (name = "_jl_help", flags = Py_METH_NOARGS, meth = pyjlany_help),
-                ],
-                getset = [(name = "__name__", get = pyjlany_name)],
-            ),
-        )
-        ptr = PyPtr(pointer(t))
-        err = PyType_Ready(ptr)
-        ism1(err) && return PyNULL
-        PYJLGCCACHE[ptr] = push!(c, t)
-        PyJuliaAnyValue_Type__ref[] = ptr
-    end
-    ptr
-end
-
-PyJuliaAnyValue_New(x) = PyJuliaValue_New(PyJuliaAnyValue_Type(), x)
-PyJuliaValue_From(x) = PyJuliaAnyValue_New(x)
-
 pyjlany_repr(xo::PyPtr) =
     try
         x = PyJuliaValue_GetValue(xo)
@@ -553,3 +488,88 @@ pyjlany_power(xo::PyPtr, yo::PyPtr, zo::PyPtr) = begin
         end
     end
 end
+
+PyJuliaAnyValue_New(x) = PyJuliaValue_New(PyJuliaAnyValue_Type(), x)
+PyJuliaValue_From(x) = PyJuliaAnyValue_New(x)
+
+const PyJuliaAnyValue_Type = LazyPyObject() do
+    c = []
+    base = PyJuliaBaseValue_Type()
+    isnull(base) && return PyNULL
+    ptr = PyPtr(cacheptr!(c, fill(PyTypeObject(
+        name = cacheptr!(c, "juliacall.AnyValue"),
+        base = base,
+        repr = @cfunctionOO(pyjlany_repr),
+        str = @cfunctionOO(pyjlany_str),
+        getattro = @cfunctionOOO(pyjlany_getattro),
+        setattro = @cfunctionIOOO(pyjlany_setattro),
+        call = @cfunctionOOOO(pyjlany_call),
+        iter = @cfunctionOO(pyjlany_iter),
+        richcompare = @cfunctionOOOI(pyjlany_richcompare),
+        as_mapping = cacheptr!(c, fill(PyMappingMethods(
+            length = @cfunctionZO(pyjlany_length),
+            subscript = @cfunctionOOO(pyjlany_getitem),
+            ass_subscript = @cfunctionIOOO(pyjlany_setitem),
+        ))),
+        as_sequence = cacheptr!(c, fill(PySequenceMethods(
+            contains = @cfunctionIOO(pyjlany_contains),
+        ))),
+        as_number = cacheptr!(c, fill(PyNumberMethods(
+            positive = @cfunctionOO(pyjlany_positive),
+            negative = @cfunctionOO(pyjlany_negative),
+            absolute = @cfunctionOO(pyjlany_absolute),
+            power = @cfunctionOOOO(pyjlany_power),
+            add = @cfunctionOOO(pyjlany_binop(+)),
+            subtract = @cfunctionOOO(pyjlany_binop(-)),
+            multiply = @cfunctionOOO(pyjlany_binop(*)),
+            truedivide = @cfunctionOOO(pyjlany_binop(/)),
+            divmod = @cfunctionOOO(pyjlany_binop((x,y) -> (fld(x,y), mod(x,y)))),
+            floordivide = @cfunctionOOO(pyjlany_binop(fld)),
+            remainder = @cfunctionOOO(pyjlany_binop(mod)),
+            lshift = @cfunctionOOO(pyjlany_binop(<<)),
+            rshift = @cfunctionOOO(pyjlany_binop(>>)),
+            and = @cfunctionOOO(pyjlany_binop(&)),
+            xor = @cfunctionOOO(pyjlany_binop(⊻)),
+            or = @cfunctionOOO(pyjlany_binop(|)),
+        ))),
+        methods = cacheptr!(c, [
+            PyMethodDef(
+                name = cacheptr!(c, "__dir__"),
+                flags = Py_METH_NOARGS,
+                meth = @cfunctionOOO(pyjlany_dir),
+            ),
+            PyMethodDef(
+                name = cacheptr!(c, "_repr_mimebundle_"),
+                flags = Py_METH_VARARGS | Py_METH_KEYWORDS,
+                meth = @cfunctionOOOO(pyjlany_repr_mimebundle),
+            ),
+            PyMethodDef(
+                name = cacheptr!(c, "_jl_raw"),
+                flags = Py_METH_NOARGS,
+                meth = @cfunctionOOO(pyjlany_toraw),
+            ),
+            PyMethodDef(
+                name = cacheptr!(c, "_jl_display"),
+                flags = Py_METH_NOARGS,
+                meth = @cfunctionOOO(pyjlany_display),
+            ),
+            PyMethodDef(
+                name = cacheptr!(c, "_jl_help"),
+                flags = Py_METH_NOARGS,
+                meth = @cfunctionOOO(pyjlany_help),
+            ),
+            PyMethodDef(),
+        ]),
+        getset = cacheptr!(c, [
+            PyGetSetDef(
+                name = cacheptr!(c, "__name__"),
+                get = @cfunctionOOP(pyjlany_name),
+            ),
+            PyGetSetDef(),
+        ])
+    ))))
+    err = PyType_Ready(ptr)
+    ism1(err) && return PyNULL
+    PYJLGCCACHE[ptr] = c
+    return ptr
+end

src/cpython/juliaarray.jl

@@ -1,52 +1,3 @@
-const PyJuliaArrayValue_Type__ref = Ref(PyNULL)
-PyJuliaArrayValue_Type() = begin
-    ptr = PyJuliaArrayValue_Type__ref[]
-    if isnull(ptr)
-        c = []
-        base = PyJuliaAnyValue_Type()
-        isnull(base) && return PyNULL
-        t = fill(
-            PyType_Create(
-                c,
-                name = "juliacall.ArrayValue",
-                base = base,
-                as_mapping = (
-                    subscript = pyjlarray_getitem,
-                    ass_subscript = pyjlarray_setitem,
-                ),
-                as_buffer = (
-                    get = pyjlarray_get_buffer,
-                    release = pyjlarray_release_buffer,
-                ),
-                getset = [
-                    (name = "ndim", get = pyjlarray_ndim),
-                    (name = "shape", get = pyjlarray_shape),
-                    (name = "__array_interface__", get = pyjlarray_array_interface),
-                ],
-                methods = [
-                    (name = "copy", flags = Py_METH_NOARGS, meth = pyjlarray_copy),
-                    (name = "reshape", flags = Py_METH_O, meth = pyjlarray_reshape),
-                    (name = "__array__", flags = Py_METH_NOARGS, meth = pyjlarray_array),
-                ],
-            ),
-        )
-        ptr = PyPtr(pointer(t))
-        err = PyType_Ready(ptr)
-        ism1(err) && return PyNULL
-        for abcf in (CONFIG.version < v"3.6" ? (PyContainerABC_Type, PyIterableABC_Type, PySizedABC_Type) : (PyCollectionABC_Type,))
-            abc = abcf()
-            isnull(abc) && return PyNULL
-            ism1(PyABC_Register(ptr, abc)) && return PyNULL
-        end
-        PYJLGCCACHE[ptr] = push!(c, t)
-        PyJuliaArrayValue_Type__ref[] = ptr
-    end
-    ptr
-end
-
-PyJuliaArrayValue_New(x::AbstractArray) = PyJuliaValue_New(PyJuliaArrayValue_Type(), x)
-PyJuliaValue_From(x::AbstractArray) = PyJuliaArrayValue_New(x)
-
 pyjl_getaxisindex(x::AbstractUnitRange{<:Integer}, ko::PyPtr) = begin
     if PySlice_Check(ko)
         ao, co, bo = PySimpleObject_GetValue(ko, Tuple{PyPtr,PyPtr,PyPtr})
@@ -504,3 +455,66 @@ pyjlarray_array(xo::PyPtr, ::PyPtr) = begin
         ao
     end
 end
+
+const PyJuliaArrayValue_Type = LazyPyObject() do
+    c = []
+    base = PyJuliaAnyValue_Type()
+    isnull(base) && return PyNULL
+    ptr = PyPtr(cacheptr!(c, fill(PyTypeObject(
+        name = cacheptr!(c, "juliacall.ArrayValue"),
+        base = base,
+        as_mapping = cacheptr!(c, fill(PyMappingMethods(
+            subscript = @cfunctionOOO(pyjlarray_getitem),
+            ass_subscript = @cfunctionIOOO(pyjlarray_setitem),
+        ))),
+        as_buffer = cacheptr!(c, fill(PyBufferProcs(
+            get = @cfunction(pyjlarray_get_buffer, Cint, (PyPtr, Ptr{Py_buffer}, Cint)),
+            release = @cfunction(pyjlarray_release_buffer, Cvoid, (PyPtr, Ptr{Py_buffer})),
+        ))),
+        getset = cacheptr!(c, [
+            PyGetSetDef(
+                name = cacheptr!(c, "ndim"),
+                get = @cfunctionOOP(pyjlarray_ndim),
+            ),
+            PyGetSetDef(
+                name = cacheptr!(c, "shape"),
+                get = @cfunctionOOP(pyjlarray_shape),
+            ),
+            PyGetSetDef(
+                name = cacheptr!(c, "__array_interface__"),
+                get = @cfunctionOOP(pyjlarray_array_interface),
+            ),
+            PyGetSetDef(),
+        ]),
+        methods = cacheptr!(c, [
+            PyMethodDef(
+                name = cacheptr!(c, "copy"),
+                flags = Py_METH_NOARGS,
+                meth = @cfunctionOOO(pyjlarray_copy),
+            ),
+            PyMethodDef(
+                name = cacheptr!(c, "reshape"),
+                flags = Py_METH_O,
+                meth = @cfunctionOOO(pyjlarray_reshape),
+            ),
+            PyMethodDef(
+                name = cacheptr!(c, "__array__"),
+                flags = Py_METH_NOARGS,
+                meth = @cfunctionOOO(pyjlarray_array),
+            ),
+            PyMethodDef(),
+        ])
+    ))))
+    err = PyType_Ready(ptr)
+    ism1(err) && return PyNULL
+    for abcf in (CONFIG.version < v"3.6" ? (PyContainerABC_Type, PyIterableABC_Type, PySizedABC_Type) : (PyCollectionABC_Type,))
+        abc = abcf()
+        isnull(abc) && return PyNULL
+        ism1(PyABC_Register(ptr, abc)) && return PyNULL
+    end
+    PYJLGCCACHE[ptr] = c
+    return ptr
+end
+
+PyJuliaArrayValue_New(x::AbstractArray) = PyJuliaValue_New(PyJuliaArrayValue_Type(), x)
+PyJuliaValue_From(x::AbstractArray) = PyJuliaArrayValue_New(x)

src/cpython/juliabase.jl

@@ -30,34 +30,25 @@ pyjlbase_dealloc(o::PyPtr) = begin
     nothing
 end
 
-const PyJuliaBaseValue_Type__ref = Ref(PyNULL)
-PyJuliaBaseValue_Type() = begin
-    ptr = PyJuliaBaseValue_Type__ref[]
-    if isnull(ptr)
-        c = []
-        t = fill(
-            PyType_Create(
-                c,
-                name = "juliacall.ValueBase",
-                basicsize = sizeof(PyJuliaValueObject),
-                new = pyglobal(:PyType_GenericNew),
-                init = @cfunction(pyjlbase_init, Cint, (PyPtr, PyPtr, PyPtr)),
-                dealloc = @cfunction(pyjlbase_dealloc, Cvoid, (PyPtr,)),
-                flags = Py_TPFLAGS_BASETYPE |
-                        Py_TPFLAGS_HAVE_VERSION_TAG |
-                        (CONFIG.isstackless ? Py_TPFLAGS_HAVE_STACKLESS_EXTENSION : 0x00),
-                weaklistoffset = fieldoffset(PyJuliaValueObject, 3),
-                getattro = pyglobal(:PyObject_GenericGetAttr),
-                setattro = pyglobal(:PyObject_GenericSetAttr),
-            ),
-        )
-        ptr = PyPtr(pointer(t))
-        err = PyType_Ready(ptr)
-        ism1(err) && return PyNULL
-        PYJLGCCACHE[ptr] = push!(c, t)
-        PyJuliaBaseValue_Type__ref[] = ptr
-    end
-    ptr
+const PyJuliaBaseValue_Type = LazyPyObject() do
+    c = []
+    ptr = PyPtr(cacheptr!(c, fill(PyTypeObject(
+        name = cacheptr!(c, "juliacall.ValueBase"),
+        basicsize = sizeof(PyJuliaValueObject),
+        new = pyglobal(:PyType_GenericNew),
+        init = @cfunctionIOOO(pyjlbase_init),
+        dealloc = @cfunctionVO(pyjlbase_dealloc),
+        flags = Py_TPFLAGS_BASETYPE |
+                Py_TPFLAGS_HAVE_VERSION_TAG |
+                (CONFIG.isstackless ? Py_TPFLAGS_HAVE_STACKLESS_EXTENSION : 0x00),
+        weaklistoffset = fieldoffset(PyJuliaValueObject, 3),
+        getattro = pyglobal(:PyObject_GenericGetAttr),
+        setattro = pyglobal(:PyObject_GenericSetAttr),
+    ))))
+    err = PyType_Ready(ptr)
+    ism1(err) && return PyNULL
+    PYJLGCCACHE[ptr] = c
+    return ptr
 end
 
 PyJuliaValue_Check(o) = Py_TypeCheck(o, PyJuliaBaseValue_Type())