passagemath-objects 10.6.41__cp314-cp314t-macosx_13_0_arm64.whl

sage/cpython/pycore_long.h

@@ -0,0 +1,97 @@
+/* sage_setup: distribution = sagemath-objects
+ */
+#include "Python.h"
+#include <stdbool.h>
+
+#if PY_VERSION_HEX >= 0x030C00A5
+// For Python 3.12 compatibility
+#define ob_digit(o)  (((PyLongObject*)o)->long_value.ob_digit)
+#else
+#define ob_digit(o)  (((PyLongObject*)o)->ob_digit)
+#endif
+
+#if PY_VERSION_HEX >= 0x030C00A7
+// For Python 3.12 compatibility
+// taken from cpython:Include/internal/pycore_long.h @ 3.12
+
+/* Long value tag bits:
+ * 0-1: Sign bits value = (1-sign), ie. negative=2, positive=0, zero=1.
+ * 2: Reserved for immortality bit
+ * 3+ Unsigned digit count
+ */
+#define SIGN_MASK 3
+#define SIGN_ZERO 1
+#define SIGN_NEGATIVE 2
+#define NON_SIZE_BITS 3
+
+static inline bool
+_PyLong_IsZero(const PyLongObject *op)
+{
+    return (op->long_value.lv_tag & SIGN_MASK) == SIGN_ZERO;
+}
+
+static inline bool
+_PyLong_IsNegative(const PyLongObject *op)
+{
+    return (op->long_value.lv_tag & SIGN_MASK) == SIGN_NEGATIVE;
+}
+
+static inline bool
+_PyLong_IsPositive(const PyLongObject *op)
+{
+    return (op->long_value.lv_tag & SIGN_MASK) == 0;
+}
+
+static inline Py_ssize_t
+_PyLong_DigitCount(const PyLongObject *op)
+{
+    assert(PyLong_Check(op));
+    return op->long_value.lv_tag >> NON_SIZE_BITS;
+}
+
+#define TAG_FROM_SIGN_AND_SIZE(sign, size) ((1 - (sign)) | ((size) << NON_SIZE_BITS))
+
+static inline void
+_PyLong_SetSignAndDigitCount(PyLongObject *op, int sign, Py_ssize_t size)
+{
+    assert(size >= 0);
+    assert(-1 <= sign && sign <= 1);
+    assert(sign != 0 || size == 0);
+    op->long_value.lv_tag = TAG_FROM_SIGN_AND_SIZE(sign, (size_t)size);
+}
+
+#else
+// fallback for < 3.12
+
+static inline bool
+_PyLong_IsZero(const PyLongObject *op)
+{
+    return Py_SIZE(op) == 0;
+}
+
+static inline bool
+_PyLong_IsNegative(const PyLongObject *op)
+{
+    return Py_SIZE(op) < 0;
+}
+
+static inline bool
+_PyLong_IsPositive(const PyLongObject *op)
+{
+    return Py_SIZE(op) > 0;
+}
+
+static inline Py_ssize_t
+_PyLong_DigitCount(const PyLongObject *op)
+{
+    Py_ssize_t size = Py_SIZE(op);
+    return size < 0 ? -size : size;
+}
+
+static inline void
+_PyLong_SetSignAndDigitCount(PyLongObject *op, int sign, Py_ssize_t size)
+{
+    Py_SET_SIZE(op, sign < 0 ? -size : size);
+}
+
+#endif

sage/cpython/pycore_long.pxd

@@ -0,0 +1,10 @@
+# sage_setup: distribution = sagemath-objects
+from cpython.longintrepr cimport py_long, digit
+
+cdef extern from "pycore_long.h":
+    digit* ob_digit(py_long o)
+    bint _PyLong_IsZero(py_long o)
+    bint _PyLong_IsNegative(py_long o)
+    bint _PyLong_IsPositive(py_long o)
+    Py_ssize_t _PyLong_DigitCount(py_long o)
+    void _PyLong_SetSignAndDigitCount(py_long o, int sign, Py_ssize_t size)

sage/cpython/python_debug.h

@@ -0,0 +1,44 @@
+/* sage_setup: distribution = sagemath-objects
+ */
+/*
+ * Workaround to handle Python preprocessor macros: Translate defined /
+ * undefined into true / false
+ */
+
+
+#include <Python.h>
+
+#ifdef Py_DEBUG
+    #define SAGE_Py_DEBUG Py_DEBUG
+#else
+    #define SAGE_Py_DEBUG 0
+#endif
+
+#ifdef Py_REF_DEBUG
+    #define SAGE_Py_REF_DEBUG Py_REF_DEBUG
+#else
+    #define SAGE_Py_REF_DEBUG 0
+#endif
+
+#ifdef Py_TRACE_REFS
+    #define SAGE_Py_TRACE_REFS Py_TRACE_REFS
+    #define if_Py_TRACE_REFS_then_PyObject_INIT(obj, type) PyObject_INIT(obj, type)
+#else
+    #define SAGE_Py_TRACE_REFS 0
+    #define if_Py_TRACE_REFS_then_PyObject_INIT(obj, type)
+#endif
+
+#ifdef PYMALLOC_DEBUG
+    #define SAGE_PYMALLOC_DEBUG PYMALLOC_DEBUG
+#else
+    #define SAGE_PYMALLOC_DEBUG 0
+#endif
+
+#ifdef WITH_PYMALLOC
+    #define SAGE_WITH_PYMALLOC PYMALLOC_DEBUG
+#else
+    #define SAGE_WITH_PYMALLOC 0
+#endif
+
+
+

sage/cpython/python_debug.pxd

@@ -0,0 +1,47 @@
+# sage_setup: distribution = sagemath-objects
+# Python can be built with extensive debugging support. This file lets
+# Sage know about which debugging options are enabled.
+#
+# To enable debugging, build Sage with the SAGE_DEBUG environment
+# variable set to "yes":
+#
+# [user@localhost:~/sage-x.y.z] export SAGE_DEBUG=yes && make
+
+
+from cpython.ref cimport PyObject, PyTypeObject
+
+cdef extern from "python_debug.h":
+
+    # This is what is generally meant by "a debug build" of Python.
+    # Implies Py_REF_DEBUG, Py_TRACE_REFS, and PYMALLOC_DEBUG (if
+    # WITH_PYMALLOC is enabled).  In addition, C assert()s are enabled.
+    cdef bint Py_DEBUG "SAGE_Py_DEBUG"
+
+    # Turn on aggregate reference counting.  This arranges that extern
+    # _Py_RefTotal hold a count of all references, the sum of
+    # ob_refcnt across all objects.  Also checks after every decref to
+    # verify that the refcount hasn't gone negative, and causes an
+    # immediate fatal error if it has.
+    cdef bint Py_REF_DEBUG "SAGE_Py_REF_DEBUG"
+
+    # Heavy reference debugging. Every PyObject grows two more
+    # pointers, to maintain a doubly-linked list of all live
+    # heap-allocated objects. Implies Py_REF_DEBUG.
+    cdef bint Py_TRACE_REFS "SAGE_Py_TRACE_REFS"
+
+    # Conditionally call PyObject_INIT() if Py_TRACE_REFS is
+    # enabled. This is necessary to initialize the aforementioned
+    # double-linked list.
+    void if_Py_TRACE_REFS_then_PyObject_INIT(PyObject *, PyTypeObject *)
+
+    # When this is enabled, calls to the PyObject_ memory routines are
+    # handled by Python's own small-object allocator, while calls to
+    # the PyMem_ memory routines are directed to the system malloc/
+    # realloc/free.
+    cdef bint WITH_PYMALLOC "SAGE_WITH_PYMALLOC"
+
+    # If this is also defined in addition to WITH_PYMALLOC, calls to
+    # both PyObject_ and PyMem_ memory routines are directed to a
+    # special debugging mode of Python's small-object
+    # allocator. Requires WITH_PYMALLOC.
+    cdef bint PYMALLOC_DEBUG "SAGE_PYMALLOC_DEBUG"

sage/cpython/pyx_visit.h

@@ -0,0 +1,13 @@
+/* sage_setup: distribution = sagemath-objects
+ */
+/* 3-argument version of Py_VISIT, easier to use from Cython */
+
+#define Py_VISIT3(op, visit, arg)                                       \
+    do {                                                                \
+        if (op) {                                                       \
+            int vret = visit((PyObject *)(op), arg);                    \
+            if (vret)                                                   \
+                return vret;                                            \
+        }                                                               \
+    } while (0)
+

sage/cpython/string.pxd

@@ -0,0 +1,76 @@
+# sage_setup: distribution = sagemath-objects
+# ****************************************************************************
+#       Copyright (C) 2017 Erik M. Bray <erik.bray@lri.fr>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+cdef extern from "string_impl.h":
+    str _cstr_to_str(const char* c, encoding, errors)
+    bytes _str_to_bytes(s, encoding, errors)
+
+
+cdef inline str char_to_str(const char* c, encoding=None, errors=None):
+    r"""
+    Convert a C string to a Python ``str``.
+    """
+    # Implemented in C to avoid relying on PY_MAJOR_VERSION
+    # compile-time variable. We keep the Cython wrapper to deal with
+    # the default arguments.
+    return _cstr_to_str(c, encoding, errors)
+
+
+cpdef inline str bytes_to_str(b, encoding=None, errors=None):
+    r"""
+    Convert ``bytes`` to ``str``.
+
+    This decodes the given ``bytes`` to a Python 3 unicode ``str`` using
+    the specified encoding.  It is a no-op on ``str`` input.
+
+    EXAMPLES::
+
+        sage: from sage.cpython.string import bytes_to_str
+        sage: s = bytes_to_str(b'\xcf\x80')
+        sage: s == u'π'
+        True
+        sage: bytes_to_str([])
+        Traceback (most recent call last):
+        ...
+        TypeError: expected bytes, list found
+    """
+    if isinstance(b, str):
+        return b
+    if type(b) is not bytes:
+        raise TypeError(f"expected bytes, {type(b).__name__} found")
+
+    return _cstr_to_str(<bytes>b, encoding, errors)
+
+
+cpdef inline bytes str_to_bytes(s, encoding=None, errors=None):
+    r"""
+    Convert ``str`` or ``unicode`` to ``bytes``.
+
+    It encodes the given ``str`` to a Python 3 ``bytes``
+    using the specified encoding.  It is a no-op on ``bytes`` input.
+
+    EXAMPLES::
+
+        sage: from sage.cpython.string import str_to_bytes
+        sage: bs = [str_to_bytes(u'π')]
+        sage: all(b == b'\xcf\x80' for b in bs)
+        True
+        sage: str_to_bytes([])
+        Traceback (most recent call last):
+        ...
+        TypeError: expected str... list found
+    """
+    # Implemented in C to avoid relying on PY_MAJOR_VERSION
+    # compile-time variable. We keep the Cython wrapper to deal with
+    # the default arguments.
+    if isinstance(s, bytes):
+        return s
+    return _str_to_bytes(s, encoding, errors)

sage/cpython/string.pyx

@@ -0,0 +1,34 @@
+# sage_setup: distribution = sagemath-objects
+"""
+String <-> bytes encoding/decoding
+
+TESTS:
+
+Check that this can be used outside of Sage (see :issue:`25549`)::
+
+    sage: cython(                                                                       # needs sage.misc.cython
+    ....: '''
+    ....: from sage.cpython.string cimport char_to_str
+    ....: print(char_to_str("hello world!"))
+    ....: ''')
+    hello world!
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2017 Erik M. Bray <erik.bray@lri.fr>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+import sys
+
+
+# Provide this as a shortcut to calling sys.getfilesystemencoding(), which
+# after interpreter initialization is constant.
+FS_ENCODING = sys.getfilesystemencoding()
+
+# Functions in this module are implemented in the .pxd file for inlining.

sage/cpython/string_impl.h

@@ -0,0 +1,60 @@
+/* sage_setup: distribution = sagemath-objects
+ */
+/*****************************************************************************
+#       Copyright (C) 2017 Erik M. Bray <erik.bray@lri.fr>
+#       Copyright (C) 2018 Jeroen Demeyer <J.Demeyer@UGent.be>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+*****************************************************************************/
+
+#include <Python.h>
+#include <string.h>
+
+
+static inline PyObject* _cstr_to_str(const char* c, PyObject* encoding, PyObject* errors)
+{
+    const char* err = NULL;  // Default: strict
+    const char* enc = NULL;  // Default: utf-8
+
+    if (errors != Py_None) {
+        err = PyUnicode_AsUTF8(errors);
+        if (!err) return NULL;
+    }
+
+    if (encoding != Py_None) {
+        enc = PyUnicode_AsUTF8(encoding);
+        if (!enc) return NULL;
+    }
+
+    return PyUnicode_Decode(c, strlen(c), enc, err);
+}
+
+
+static inline PyObject* _str_to_bytes(PyObject* s, PyObject* encoding, PyObject* errors)
+{
+    if (!PyUnicode_Check(s)) {
+        PyErr_Format(PyExc_TypeError,
+                     "expected str, %s found",
+                     Py_TYPE(s)->tp_name);
+        return NULL;
+    }
+
+    const char* err = NULL;  // Default: strict
+    const char* enc = NULL;  // Default: utf-8
+
+    if (errors != Py_None) {
+        err = PyUnicode_AsUTF8(errors);
+        if (!err) return NULL;
+    }
+
+    if (encoding != Py_None) {
+        enc = PyUnicode_AsUTF8(encoding);
+        if (!enc) return NULL;
+    }
+
+    return PyUnicode_AsEncodedString(s, enc, err);
+}

sage/cpython/type.pxd

@@ -0,0 +1,2 @@
+# sage_setup: distribution = sagemath-objects
+cpdef bint can_assign_class(obj) noexcept

sage/cpython/type.pyx

@@ -0,0 +1,40 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Type internals
+"""
+
+from cpython.object cimport Py_TYPE, PyTypeObject, Py_TPFLAGS_HEAPTYPE
+
+cdef PyTypeObject* PyInstance_Type = NULL
+try:
+    from types import InstanceType
+    PyInstance_Type = <PyTypeObject*>InstanceType
+except ImportError:
+    pass
+
+
+cpdef bint can_assign_class(obj) noexcept:
+    """
+    Can we assign ``obj.__class__``?
+
+    Note that Python 3.5 has experimented with allowing assigning
+    ``__class__`` in more cases but this was mostly reverted. In this
+    function, we apply the Python 2.7 semantics.
+
+    EXAMPLES::
+
+        sage: class X: pass
+        sage: from sage.cpython.type import can_assign_class
+        sage: can_assign_class(X())
+        True
+        sage: class Y(int): pass
+        sage: from sage.cpython.type import can_assign_class
+        sage: can_assign_class(Y())
+        True
+        sage: can_assign_class(1)
+        False
+    """
+    cdef PyTypeObject* tp = Py_TYPE(obj)
+    if tp is PyInstance_Type:
+        return True
+    return (tp.tp_flags & Py_TPFLAGS_HEAPTYPE) != 0

sage/cpython/wrapperdescr.pxd

@@ -0,0 +1,67 @@
+# sage_setup: distribution = sagemath-objects
+from cpython.object cimport PyObject, PyTypeObject
+
+cdef extern from *:
+    ctypedef object (*wrapperfunc)(self, args, void* wrapped)
+    ctypedef object (*wrapperfunc_kwds)(self, args, void* wrapped, kwds)
+
+    struct wrapperbase:
+        char* name
+        int offset
+        void* function
+        wrapperfunc wrapper
+        char* doc
+        int flags
+        PyObject* name_strobj
+
+    int PyWrapperFlag_KEYWORDS
+
+    ctypedef class sage.cpython.builtin_types.wrapper_descriptor [object PyWrapperDescrObject]:
+        cdef type d_type
+        cdef d_name
+        cdef wrapperbase* d_base
+        cdef void* d_wrapped
+
+    PyDescr_NewWrapper(PyTypeObject* cls, wrapperbase* wrapper, void* wrapped)
+
+
+cdef wrapperdescr_fastcall(wrapper_descriptor slotwrapper, self, args, kwds)
+
+
+cdef inline wrapperbase* get_slotdef(wrapper_descriptor slotwrapper) except NULL:
+    """
+    Given a slot wrapper, return the corresponding ``slotdef``.
+
+    A ``slotdef`` is associated to a specific slot like ``__eq__``
+    and does not depend at all on the type. In other words, calling
+    ``get_slotdef(t.__eq__)`` will return the same ``slotdef``
+    independent of the type ``t`` (provided that the type implements
+    rich comparison in C).
+
+    TESTS::
+
+        sage: # needs sage.misc.cython
+        sage: cython(
+        ....: '''
+        ....: from sage.cpython.wrapperdescr cimport get_slotdef
+        ....: from cpython.long cimport PyLong_FromVoidPtr
+        ....: def py_get_slotdef(slotwrapper):
+        ....:     return PyLong_FromVoidPtr(get_slotdef(slotwrapper))
+        ....: ''')
+        sage: py_get_slotdef(object.__init__)  # random
+        140016903442416
+        sage: py_get_slotdef(bytes.__lt__)  # random
+        140016903441800
+        sage: py_get_slotdef(bytes.__lt__) == py_get_slotdef(Integer.__lt__)
+        True
+        sage: py_get_slotdef(bytes.__lt__) == py_get_slotdef(bytes.__gt__)
+        False
+        sage: class X():
+        ....:     def __eq__(self, other):
+        ....:         return False
+        sage: py_get_slotdef(X.__eq__)
+        Traceback (most recent call last):
+        ...
+        TypeError: Cannot convert ... to wrapper_descriptor
+    """
+    return slotwrapper.d_base

sage/ext/all__sagemath_objects.py

@@ -0,0 +1,3 @@
+# sage_setup: distribution = sagemath-objects
+# The presence of this file ensures that sage_setup for sagemath-objects
+# considers this directory as a namespace package

sage/ext/ccobject.h

@@ -0,0 +1,64 @@
+/* sage_setup: distribution = sagemath-objects
+ */
+#ifndef __SAGE_CCOBJECT_H__
+#define __SAGE_CCOBJECT_H__
+
+#ifdef __cplusplus
+
+#include <iostream>
+#include <sstream>
+
+
+template <class T>
+static CYTHON_INLINE int ccreadstr(T& x, PyObject* b)
+{
+    PyObject* converted = NULL;
+
+    // Accept "str" input
+    if (PyUnicode_Check(b))
+    {
+        converted = PyUnicode_EncodeFSDefault(b);
+        if (!converted) {return -1;}
+        b = converted;
+    }
+
+    char* buffer;
+    Py_ssize_t length;
+
+    if (PyBytes_AsStringAndSize(b, &buffer, &length) == -1)
+        {Py_XDECREF(converted); return -1;}
+    std::istringstream input(std::string(buffer, length));
+    Py_XDECREF(converted);
+
+    input >> x;
+
+    return 0;
+}
+
+
+template <class T>
+static CYTHON_INLINE PyObject* ccrepr(const T& x)
+{
+    std::ostringstream instore;
+    instore << x;
+    std::string instr = instore.str();
+    return PyUnicode_DecodeFSDefaultAndSize(instr.c_str(), instr.size());
+}
+
+
+/* Arrays */
+template <class T>
+static inline T* Allocate_array(size_t n)
+{
+    return new T[n];
+}
+
+template <class T>
+static inline void Delete_array(T* v)
+{
+    delete[] v;
+}
+
+#endif
+
+#endif /* ifndef __SAGE_CCOBJECT_H__ */

sage/ext/cplusplus.pxd

@@ -0,0 +1,17 @@
+# sage_setup: distribution = sagemath-objects
+# ***************************************************************************
+#       Copyright (C) 2017 Jeroen Demeyer <J.Demeyer@UGent.be>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
+
+cdef extern from "ccobject.h":
+    # Print representation of any C++ object
+    str ccrepr[T](const T& x)
+
+    # Read a Python bytes/str into a C++ object
+    int ccreadstr[T](T x, object b) except -1

sage/ext/mod_int.h

@@ -0,0 +1,30 @@
+/* sage_setup: distribution = sagemath-objects
+ */
+/* See mod_int.pxd if you want to use these declarations in Cython */
+
+/* CPython using signed long as the data type for plain integers, which is
+ *   - 8 bytes on 64-bit Linux and OSX
+ *   - 4 bytes on 64-bit Windows and all 32-bit supported platforms.
+ * If you want to convert mod_int quickly to Python, then it must fit
+ * into such an integer. Otherwise you'll end up with Python's
+ * arbitrary-size integers instead of machine ints.
+ *
+ * However, 4 bytes is rather small and one can quickly run out of
+ * primes, especially if the problem has many bad primes. See Trac
+ * #10281 for details.
+ *
+ * Hence, we use signed 64-bit ints. This gives us fast conversion
+ * to/from Python on 64-bit Linux and OSX, and a large number of
+ * available (but not quite as fast) primes on 64-bit Windows and all
+ * 32-bit platforms (see Issue #10281)
+ */
+
+typedef int64_t mod_int;
+
+/* The largest value we can do arithmetic on without risking overflowing.
+ * That is, you can multiply two MOD_INT_MAX in a mod_int.
+ */
+#define MOD_INT_OVERFLOW_UNSIGNED ((((uint64_t)1) << (sizeof(mod_int)*8 - 1)) - 1)
+#define MOD_INT_OVERFLOW ((mod_int)MOD_INT_OVERFLOW_UNSIGNED)
+#define MOD_INT_MAX ((mod_int)sqrt(MOD_INT_OVERFLOW_UNSIGNED) - 1)
+

sage/ext/mod_int.pxd

@@ -0,0 +1,24 @@
+# sage_setup: distribution = sagemath-objects
+"""
+The `mod_int` Data Type
+
+* In C/C++ headers, you can `#include "mod_int.h"`
+* In Cython files, use `from sage.ext.mod_int cimport *`
+"""
+
+# ***************************************************************************
+#       Copyright (C) 2013 Volker Braun <vbraun.name@gmail.com>
+#       Copyright (C) 2013 William Stein <wstein@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
+
+
+cdef extern from "mod_int.h":
+    ctypedef long mod_int
+    mod_int MOD_INT_MAX
+    mod_int MOD_INT_OVERFLOW

sage/ext/stdsage.pxd

@@ -0,0 +1,39 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Standard C helper code for Cython modules
+"""
+# ***************************************************************************
+#       Copyright (C) 2015 Jeroen Demeyer <jdemeyer@cage.ugent.be>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
+
+from cpython.object cimport Py_TYPE, PyTypeObject, PyObject
+
+
+cdef inline PY_NEW(type t):
+    """
+    Return ``t.__new__(t)``.  This works even for types like
+    :class:`Integer` where we change ``tp_new`` at runtime (Cython
+    optimizations assume that ``tp_new`` doesn't change).
+    """
+    return (<PyTypeObject*>t).tp_new(t, <PyObject*>NULL, <PyObject*>NULL)
+
+
+cdef inline void PY_SET_TP_NEW(type dst, type src) noexcept:
+    """
+    Manually set ``dst.__new__`` to ``src.__new__``.  This is used to
+    speed up Cython's boilerplate object construction code by skipping
+    irrelevant base class ``tp_new`` methods.
+    """
+    (<PyTypeObject*>dst).tp_new = (<PyTypeObject*>src).tp_new
+
+
+cdef inline bint HAS_DICTIONARY(obj) noexcept:
+    """
+    Test whether the given object has a Python dictionary.
+    """
+    return Py_TYPE(obj).tp_dictoffset != 0