FEAT: Adding pickle support to quaddtype

quaddtype/numpy_quaddtype/__init__.py

@@ -1,3 +1,5 @@
+import enum
+
 from ._quaddtype_main import (
     QuadPrecision,
     QuadPrecDType,
@@ -10,8 +12,16 @@
 
 __version__ = "0.2.0"
 
+
+class QuadBackend(enum.IntEnum):
+    """Backend type for QuadPrecision computations."""
+    SLEEF = 0
+    LONGDOUBLE = 1
+
+
 __all__ = [
-    'QuadPrecision', 'QuadPrecDType', 'SleefQuadPrecision', 'LongDoubleQuadPrecision',
+    'QuadPrecision', 'QuadPrecDType', 'QuadBackend',
+    'SleefQuadPrecision', 'LongDoubleQuadPrecision',
     'SleefQuadPrecDType', 'LongDoubleQuadPrecDType', 'is_longdouble_128', 
     # Constants
     'pi', 'e', 'log2e', 'log10e', 'ln2', 'ln10', 'max_value', 'epsilon',

quaddtype/numpy_quaddtype/__init__.pyi

@@ -1,4 +1,5 @@
 from typing import Final
+import enum
 
 from ._quaddtype_main import (
     QuadPrecDType,
@@ -10,9 +11,14 @@ from ._quaddtype_main import (
     set_num_threads,
 )
 
+class QuadBackend(enum.IntEnum):
+    SLEEF = 0
+    LONGDOUBLE = 1
+
 __all__ = [
     "QuadPrecision",
     "QuadPrecDType",
+    "QuadBackend",
     "SleefQuadPrecision",
     "LongDoubleQuadPrecision",
     "SleefQuadPrecDType",

quaddtype/numpy_quaddtype/_quaddtype_main.pyi

@@ -4,6 +4,8 @@ import numpy as np
 from numpy._typing import _128Bit  # pyright: ignore[reportPrivateUsage]
 from typing_extensions import Never, Self, override
 
+from numpy_quaddtype import QuadBackend
+
 _Backend: TypeAlias = Literal["sleef", "longdouble"]
 _IntoQuad: TypeAlias = (
     QuadPrecision
@@ -20,6 +22,10 @@ _ScalarItemArg: TypeAlias = Literal[0, -1] | tuple[Literal[0, -1]] | tuple[()]
 class QuadPrecDType(np.dtype[QuadPrecision]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
     def __new__(cls, /, backend: _Backend = "sleef") -> Self: ...
 
+    # QuadPrecDType specific attributes
+    @property
+    def backend(self) -> QuadBackend: ...
+
     # `numpy.dtype` overrides
     names: None  # pyright: ignore[reportIncompatibleVariableOverride]
     @property

quaddtype/numpy_quaddtype/src/dtype.c

@@ -1,4 +1,5 @@
 #include <Python.h>
+#include <structmember.h>
 #include <sleef.h>
 #include <sleefquad.h>
 #include <ctype.h>
@@ -439,13 +440,45 @@ QuadPrecDType_str(QuadPrecDTypeObject *self)
     return PyUnicode_FromFormat("QuadPrecDType(backend='%s')", backend_str);
 }
 
+
+static PyObject *
+quaddtype__reduce__(QuadPrecDTypeObject *self, PyObject *NPY_UNUSED(args))
+{
+    const char *backend_str = (self->backend == BACKEND_SLEEF) ? "sleef" : "longdouble";
+
+    /* Return (type(self), (backend_str,)) 
+     * This will call type(self).__new__(type(self), backend_str) followed by __init__
+     */
+    PyObject *result = Py_BuildValue("O(s)", Py_TYPE(self), backend_str);
+
+    return result;
+}
+
+static PyMethodDef QuadPrecDType_methods[] = {
+        {
+                "__reduce__",
+                (PyCFunction)quaddtype__reduce__,
+                METH_NOARGS,
+                "Reduction method for a QuadPrecDType object",
+        },
+        {NULL, NULL, 0, NULL},
+};
+
+static PyMemberDef QuadPrecDType_members[] = {
+        {"backend", T_INT, offsetof(QuadPrecDTypeObject, backend), READONLY,
+         "The backend used for quad precision (0=sleef, 1=longdouble)"},
+        {NULL, 0, 0, 0, NULL},
+};
+
 PyArray_DTypeMeta QuadPrecDType = {
         {{
                 PyVarObject_HEAD_INIT(NULL, 0).tp_name = "numpy_quaddtype.QuadPrecDType",
                 .tp_basicsize = sizeof(QuadPrecDTypeObject),
                 .tp_new = QuadPrecDType_new,
                 .tp_repr = (reprfunc)QuadPrecDType_repr,
                 .tp_str = (reprfunc)QuadPrecDType_str,
+                .tp_methods = QuadPrecDType_methods,
+                .tp_members = QuadPrecDType_members,
         }},
 };