feat: add PEP 489 support

src/BTrees/SetOpTemplate.h

@@ -4,12 +4,12 @@
 #include "Python.h"
 
 static PyObject *
-union_m(PyObject *ignored, PyObject *args);
+union_m(PyObject *module, PyObject *args);
 
 static PyObject *
-intersection_m(PyObject *ignored, PyObject *args);
+intersection_m(PyObject *module, PyObject *args);
 
 static PyObject *
-difference_m(PyObject *ignored, PyObject *args);
+difference_m(PyObject *module, PyObject *args);
 
 # endif

src/BTrees/SetTemplate.c

@@ -239,11 +239,7 @@ _set_setstate(Bucket *self, PyObject *args)
     }
     self->len=0;
 
-    if (self->next)
-    {
-        Py_DECREF(self->next);
-        self->next=0;
-    }
+    Py_CLEAR(self->next);
 
     if (l > self->size)
     {
@@ -276,14 +272,17 @@ _set_setstate(Bucket *self, PyObject *args)
 static PyObject *
 set_setstate(Bucket *self, PyObject *args)
 {
+    PyObject* obj_self = (PyObject*)self;
+    PerCAPI* per_capi = _get_per_capi(obj_self);
     int r;
 
     UNLESS (PyArg_ParseTuple(args, "O", &args))
         return NULL;
 
-    PER_PREVENT_DEACTIVATION(self);
-    r=_set_setstate(self, args);
-    PER_UNUSE(self);
+    per_prevent_deactivation((cPersistentObject*)self);
+    r = _set_setstate(self, args);
+    per_allow_deactivation((cPersistentObject*)self);
+    per_capi->accessed((cPersistentObject*)self);
 
     if (r < 0)
         return NULL;
@@ -353,13 +352,18 @@ static struct PyMethodDef Set_methods[] = {
 static int
 Set_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
+    Bucket* b_self = BUCKET(self);
     PyObject *v = NULL;
 
+    b_self->next = 0;
+    b_self->keys = 0;
+    b_self->values = 0;
+
     if (!PyArg_ParseTuple(args, "|O:" MOD_NAME_PREFIX "Set", &v))
         return -1;
 
     if (v)
-        return _Set_update((Bucket *)self, v);
+        return _Set_update(b_self, v);
     else
         return 0;
 }
@@ -390,29 +394,38 @@ set_repr(Bucket *self)
 static Py_ssize_t
 set_length(Bucket *self)
 {
+    PyObject* obj_self = (PyObject*)self;
+    PerCAPI* per_capi = _get_per_capi(obj_self);
     int r;
 
-    PER_USE_OR_RETURN(self, -1);
+    if (!per_use((cPersistentObject*)self, per_capi))
+        return -1;
     r = self->len;
-    PER_UNUSE(self);
+    per_allow_deactivation((cPersistentObject*)self);
+    per_capi->accessed((cPersistentObject*)self);
 
     return r;
 }
 
 static PyObject *
 set_item(Bucket *self, Py_ssize_t index)
 {
-    PyObject *r=0;
+    PyObject* obj_self = (PyObject*)self;
+    PerCAPI* per_capi = _get_per_capi(obj_self);
 
-    PER_USE_OR_RETURN(self, NULL);
+    PyObject *r = 0;
+
+    if (!per_use((cPersistentObject*)self, per_capi))
+        return NULL;
     if (index >= 0 && index < self->len)
     {
         COPY_KEY_TO_OBJECT(r, self->keys[index]);
     }
     else
         IndexError(index);
 
-    PER_UNUSE(self);
+    per_allow_deactivation((cPersistentObject*)self);
+    per_capi->accessed((cPersistentObject*)self);
 
     return r;
 }
@@ -656,101 +669,99 @@ set_iand(Bucket* self, PyObject* other)
     return result;
 }
 
-static PySequenceMethods set_as_sequence = {
-    (lenfunc)set_length,                /* sq_length */
-    (binaryfunc)0,                      /* sq_concat */
-    (ssizeargfunc)0,                    /* sq_repeat */
-    (ssizeargfunc)set_item,             /* sq_item */
-    (ssizessizeargfunc)0,               /* sq_slice */
-    (ssizeobjargproc)0,                 /* sq_ass_item */
-    (ssizessizeobjargproc)0,            /* sq_ass_slice */
-    (objobjproc)bucket_contains,        /* sq_contains */
-    0,                                  /* sq_inplace_concat */
-    0,                                  /* sq_inplace_repeat */
+static char Set__name__[] = MODULE_NAME MOD_NAME_PREFIX "Set";
+static char Set__doc__[] = "Result set mapped as a single bucket";
+
+#if USE_STATIC_TYPES
+
+static PyNumberMethods Set_as_number = {
+    .nb_subtract                = bucket_sub,
+    .nb_and                     = bucket_and,
+    .nb_xor                     = (binaryfunc)Generic_set_xor,
+    .nb_or                      = bucket_or,
+    .nb_inplace_subtract        = (binaryfunc)set_isub,
+    .nb_inplace_and             = (binaryfunc)set_iand,
+    .nb_inplace_xor             = (binaryfunc)set_ixor,
+    .nb_inplace_or              = (binaryfunc)set_ior,
 };
 
-static PyNumberMethods set_as_number = {
-     (binaryfunc)0,                     /* nb_add */
-     bucket_sub,                        /* nb_subtract */
-     (binaryfunc)0,                     /* nb_multiply */
-     (binaryfunc)0,                     /* nb_remainder */
-     (binaryfunc)0,                     /* nb_divmod */
-     (ternaryfunc)0,                    /* nb_power */
-     (unaryfunc)0,                      /* nb_negative */
-     (unaryfunc)0,                      /* nb_positive */
-     (unaryfunc)0,                      /* nb_absolute */
-     (inquiry)0,                        /* nb_bool */
-     (unaryfunc)0,                      /* nb_invert */
-     (binaryfunc)0,                     /* nb_lshift */
-     (binaryfunc)0,                     /* nb_rshift */
-     bucket_and,                        /* nb_and */
-     (binaryfunc)Generic_set_xor,       /* nb_xor */
-     bucket_or,                         /* nb_or */
-     0,                                 /*nb_int*/
-     0,                                 /*nb_reserved*/
-     0,                                 /*nb_float*/
-     0,                                 /*nb_inplace_add*/
-     (binaryfunc)set_isub,              /*nb_inplace_subtract*/
-     0,                                 /*nb_inplace_multiply*/
-     0,                                 /*nb_inplace_remainder*/
-     0,                                 /*nb_inplace_power*/
-     0,                                 /*nb_inplace_lshift*/
-     0,                                 /*nb_inplace_rshift*/
-     (binaryfunc)set_iand,              /*nb_inplace_and*/
-     (binaryfunc)set_ixor,              /*nb_inplace_xor*/
-     (binaryfunc)set_ior,               /*nb_inplace_or*/
+static PySequenceMethods Set_as_sequence = {
+    .sq_length                  = (lenfunc)set_length,
+    .sq_item                    = (ssizeargfunc)set_item,
+    .sq_contains                = (objobjproc)bucket_contains,
 };
 
-static PyTypeObject SetType = {
+static PyTypeObject Set_type_def = {
     PyVarObject_HEAD_INIT(NULL, 0)      /* PyPersist_Type */
-    MODULE_NAME MOD_NAME_PREFIX "Set",  /* tp_name */
-    sizeof(Bucket),                     /* tp_basicsize */
-    0,                                  /* tp_itemsize */
-    (destructor)bucket_dealloc,         /* tp_dealloc */
-    0,                                  /* tp_print */
-    0,                                  /* tp_getattr */
-    0,                                  /* tp_setattr */
-    0,                                  /* tp_compare */
-    (reprfunc)set_repr,                 /* tp_repr */
-    &set_as_number,                     /* tp_as_number */
-    &set_as_sequence,                   /* tp_as_sequence */
-    0,                                  /* tp_as_mapping */
-    0,                                  /* tp_hash */
-    0,                                  /* tp_call */
-    0,                                  /* tp_str */
-    0,                                  /* tp_getattro */
-    0,                                  /* tp_setattro */
-    0,                                  /* tp_as_buffer */
-    Py_TPFLAGS_DEFAULT |
-    Py_TPFLAGS_HAVE_GC |
-    Py_TPFLAGS_BASETYPE,                /* tp_flags */
-    0,                                  /* tp_doc */
-    (traverseproc)bucket_traverse,      /* tp_traverse */
-    (inquiry)bucket_tp_clear,           /* tp_clear */
-    0,                                  /* tp_richcompare */
-    0,                                  /* tp_weaklistoffset */
-    (getiterfunc)Bucket_getiter,        /* tp_iter */
-    0,                                  /* tp_iternext */
-    Set_methods,                        /* tp_methods */
-    Bucket_members,                     /* tp_members */
-    0,                                  /* tp_getset */
-    0,                                  /* tp_base */
-    0,                                  /* tp_dict */
-    0,                                  /* tp_descr_get */
-    0,                                  /* tp_descr_set */
-    0,                                  /* tp_dictoffset */
-    Set_init,                           /* tp_init */
-    0,                                  /* tp_alloc */
-    0, /*PyType_GenericNew,*/           /* tp_new */
+    .tp_name                    = Set__name__,
+    .tp_doc                     = Set__doc__,
+    .tp_basicsize               = sizeof(Bucket),
+    .tp_flags                   = Py_TPFLAGS_DEFAULT |
+                                  Py_TPFLAGS_HAVE_GC |
+                                  Py_TPFLAGS_BASETYPE,
+    .tp_alloc                   = _pytype_generic_alloc,
+    .tp_new                     = _pytype_generic_new,
+    .tp_init                    = Set_init,
+    .tp_repr                    = (reprfunc)set_repr,
+    .tp_iter                    = (getiterfunc)Bucket_getiter,
+    .tp_traverse                = (traverseproc)bucket_traverse,
+    .tp_clear                   = (inquiry)bucket_tp_clear,
+    .tp_dealloc                 = (destructor)bucket_dealloc,
+    .tp_methods                 = Set_methods,
+    .tp_members                 = Bucket_members,
+    .tp_as_number               = &Set_as_number,
+    .tp_as_sequence             = &Set_as_sequence,
+};
+
+#else
+
+static PyType_Slot Set_type_slots[] = {
+    {Py_tp_doc,                 Set__doc__},
+    {Py_tp_alloc,               _pytype_generic_alloc},
+    {Py_tp_new,                 _pytype_generic_new},
+    {Py_tp_init,                Set_init},
+    {Py_tp_repr,                (reprfunc)set_repr},
+    {Py_tp_iter,                (getiterfunc)Bucket_getiter},
+    {Py_tp_traverse,            (traverseproc)bucket_traverse},
+    {Py_tp_clear,               (inquiry)bucket_tp_clear},
+    {Py_tp_dealloc,             (destructor)bucket_dealloc},
+    {Py_tp_methods,             Set_methods},
+    {Py_tp_members,             Bucket_members},
+    {Py_nb_subtract,            bucket_sub},
+    {Py_nb_and,                 bucket_and},
+    {Py_nb_xor,                 (binaryfunc)Generic_set_xor},
+    {Py_nb_or,                  bucket_or},
+    {Py_nb_inplace_subtract,    (binaryfunc)set_isub},
+    {Py_nb_inplace_and,         (binaryfunc)set_iand},
+    {Py_nb_inplace_xor,         (binaryfunc)set_ixor},
+    {Py_nb_inplace_or,          (binaryfunc)set_ior},
+    {Py_sq_length,              (lenfunc)set_length},
+    {Py_sq_item,                (ssizeargfunc)set_item},
+    {Py_sq_contains,            (objobjproc)bucket_contains},
+    {0,                         NULL}
 };
 
+static PyType_Spec Set_type_spec = {
+    .name                       = Set__name__,
+    .basicsize                  = sizeof(Bucket),
+    .flags                      = Py_TPFLAGS_DEFAULT |
+                                  Py_TPFLAGS_HAVE_GC |
+                                  Py_TPFLAGS_IMMUTABLETYPE |
+                                  Py_TPFLAGS_BASETYPE,
+    .slots                      = Set_type_slots
+};
+
+#endif
+
 static int
 nextSet(SetIteration *i)
 {
+    PyObject* obj_self = i->set;
+    PerCAPI* per_capi = _get_per_capi(obj_self);
 
     if (i->position >= 0)
     {
-        UNLESS(PER_USE(BUCKET(i->set)))
+        UNLESS(per_use((cPersistentObject*)BUCKET(i->set), per_capi))
             return -1;
 
         if (i->position)
@@ -767,10 +778,10 @@ nextSet(SetIteration *i)
         else
         {
           i->position = -1;
-          PER_ACCESSED(BUCKET(i->set));
+          per_capi->accessed((cPersistentObject*)BUCKET(i->set));
         }
 
-      PER_ALLOW_DEACTIVATION(BUCKET(i->set));
+      per_allow_deactivation((cPersistentObject*)BUCKET(i->set));
     }