passagemath-objects 10.6.45__cp313-cp313-musllinux_1_2_x86_64.whl

sage/cpython/dict_internal.h

@@ -0,0 +1,245 @@
+/* sage_setup: distribution = sagemath-objects
+ */
+/* This contains internal definitions for python dictionaries,
+ * mostly copied from cpython sourcecode.
+ *
+ * Moved here to make it easier to maintain in the face of python
+ * changes.
+ * */
+
+#if PY_VERSION_HEX < 0x30b0000
+
+/************************************************************/
+/* Copied verbatim from cpython 3.8 (Objects/dict-common.h) */
+/************************************************************/
+
+#ifndef Py_DICT_COMMON_H
+#define Py_DICT_COMMON_H
+
+typedef struct {
+    /* Cached hash code of me_key. */
+    Py_hash_t me_hash;
+    PyObject *me_key;
+    PyObject *me_value; /* This field is only meaningful for combined tables */
+} PyDictKeyEntry;
+
+/* dict_lookup_func() returns index of entry which can be used like DK_ENTRIES(dk)[index].
+ * -1 when no entry found, -3 when compare raises error.
+ */
+typedef Py_ssize_t (*dict_lookup_func)
+    (PyDictObject *mp, PyObject *key, Py_hash_t hash, PyObject **value_addr);
+
+#define DKIX_EMPTY (-1)
+#define DKIX_DUMMY (-2)  /* Used internally */
+#define DKIX_ERROR (-3)
+
+/* See dictobject.c for actual layout of DictKeysObject */
+struct _dictkeysobject {
+    Py_ssize_t dk_refcnt;
+
+    /* Size of the hash table (dk_indices). It must be a power of 2. */
+    Py_ssize_t dk_size;
+
+    /* Function to lookup in the hash table (dk_indices):
+
+       - lookdict(): general-purpose, and may return DKIX_ERROR if (and
+         only if) a comparison raises an exception.
+
+       - lookdict_unicode(): specialized to Unicode string keys, comparison of
+         which can never raise an exception; that function can never return
+         DKIX_ERROR.
+
+       - lookdict_unicode_nodummy(): similar to lookdict_unicode() but further
+         specialized for Unicode string keys that cannot be the <dummy> value.
+
+       - lookdict_split(): Version of lookdict() for split tables. */
+    dict_lookup_func dk_lookup;
+
+    /* Number of usable entries in dk_entries. */
+    Py_ssize_t dk_usable;
+
+    /* Number of used entries in dk_entries. */
+    Py_ssize_t dk_nentries;
+
+    /* Actual hash table of dk_size entries. It holds indices in dk_entries,
+       or DKIX_EMPTY(-1) or DKIX_DUMMY(-2).
+
+       Indices must be: 0 <= indice < USABLE_FRACTION(dk_size).
+
+       The size in bytes of an indice depends on dk_size:
+
+       - 1 byte if dk_size <= 0xff (char*)
+       - 2 bytes if dk_size <= 0xffff (int16_t*)
+       - 4 bytes if dk_size <= 0xffffffff (int32_t*)
+       - 8 bytes otherwise (int64_t*)
+
+       Dynamically sized, SIZEOF_VOID_P is minimum. */
+    char dk_indices[];  /* char is required to avoid strict aliasing. */
+
+    /* "PyDictKeyEntry dk_entries[dk_usable];" array follows:
+       see the DK_ENTRIES() macro */
+};
+
+#endif
+
+
+/***********************************************************/
+/* Copied verbatim from cpython 3.8 (Objects/dictobject.c) */
+/***********************************************************/
+
+#define PERTURB_SHIFT 5
+#define DK_SIZE(dk) ((dk)->dk_size)
+#if SIZEOF_VOID_P > 4
+#define DK_IXSIZE(dk)                          \
+    (DK_SIZE(dk) <= 0xff ?                     \
+        1 : DK_SIZE(dk) <= 0xffff ?            \
+            2 : DK_SIZE(dk) <= 0xffffffff ?    \
+                4 : sizeof(int64_t))
+#else
+#define DK_IXSIZE(dk)                          \
+    (DK_SIZE(dk) <= 0xff ?                     \
+        1 : DK_SIZE(dk) <= 0xffff ?            \
+            2 : sizeof(int32_t))
+#endif
+#define DK_ENTRIES(dk) \
+    ((PyDictKeyEntry*)(&((int8_t*)((dk)->dk_indices))[DK_SIZE(dk) * DK_IXSIZE(dk)]))
+
+#define DK_MASK(dk) (((dk)->dk_size)-1)
+
+/* lookup indices.  returns DKIX_EMPTY, DKIX_DUMMY, or ix >=0 */
+static inline Py_ssize_t
+dictkeys_get_index(PyDictKeysObject *keys, Py_ssize_t i)
+{
+    Py_ssize_t s = DK_SIZE(keys);
+    Py_ssize_t ix;
+
+    if (s <= 0xff) {
+        int8_t *indices = (int8_t*)(keys->dk_indices);
+        ix = indices[i];
+    }
+    else if (s <= 0xffff) {
+        int16_t *indices = (int16_t*)(keys->dk_indices);
+        ix = indices[i];
+    }
+#if SIZEOF_VOID_P > 4
+    else if (s > 0xffffffff) {
+        int64_t *indices = (int64_t*)(keys->dk_indices);
+        ix = indices[i];
+    }
+#endif
+    else {
+        int32_t *indices = (int32_t*)(keys->dk_indices);
+        ix = indices[i];
+    }
+    assert(ix >= DKIX_DUMMY);
+    return ix;
+}
+
+/* write to indices. */
+static inline void
+dictkeys_set_index(PyDictKeysObject *keys, Py_ssize_t i, Py_ssize_t ix)
+{
+    Py_ssize_t s = DK_SIZE(keys);
+
+    assert(ix >= DKIX_DUMMY);
+
+    if (s <= 0xff) {
+        int8_t *indices = (int8_t*)(keys->dk_indices);
+        assert(ix <= 0x7f);
+        indices[i] = (char)ix;
+    }
+    else if (s <= 0xffff) {
+        int16_t *indices = (int16_t*)(keys->dk_indices);
+        assert(ix <= 0x7fff);
+        indices[i] = (int16_t)ix;
+    }
+#if SIZEOF_VOID_P > 4
+    else if (s > 0xffffffff) {
+        int64_t *indices = (int64_t*)(keys->dk_indices);
+        indices[i] = ix;
+    }
+#endif
+    else {
+        int32_t *indices = (int32_t*)(keys->dk_indices);
+        assert(ix <= 0x7fffffff);
+        indices[i] = (int32_t)ix;
+    }
+}
+
+/************************************************************/
+
+#else   /* Python >= 3.11 */
+
+#define Py_BUILD_CORE
+#undef _PyGC_FINALIZED
+#include <internal/pycore_dict.h>
+
+/************************************************************/
+/* Copied verbatim from cpython 3.11 (Objects/dictobject.c) */
+/************************************************************/
+
+#define PERTURB_SHIFT 5
+#define DK_MASK(dk) (DK_SIZE(dk)-1)
+
+/* lookup indices.  returns DKIX_EMPTY, DKIX_DUMMY, or ix >=0 */
+static inline Py_ssize_t
+dictkeys_get_index(const PyDictKeysObject *keys, Py_ssize_t i)
+{
+    int log2size = DK_LOG_SIZE(keys);
+    Py_ssize_t ix;
+
+    if (log2size < 8) {
+        const int8_t *indices = (const int8_t*)(keys->dk_indices);
+        ix = indices[i];
+    }
+    else if (log2size < 16) {
+        const int16_t *indices = (const int16_t*)(keys->dk_indices);
+        ix = indices[i];
+    }
+#if SIZEOF_VOID_P > 4
+    else if (log2size >= 32) {
+        const int64_t *indices = (const int64_t*)(keys->dk_indices);
+        ix = indices[i];
+    }
+#endif
+    else {
+        const int32_t *indices = (const int32_t*)(keys->dk_indices);
+        ix = indices[i];
+    }
+    assert(ix >= DKIX_DUMMY);
+    return ix;
+}
+
+/* write to indices. */
+static inline void
+dictkeys_set_index(PyDictKeysObject *keys, Py_ssize_t i, Py_ssize_t ix)
+{
+    int log2size = DK_LOG_SIZE(keys);
+
+    assert(ix >= DKIX_DUMMY);
+    assert(keys->dk_version == 0);
+
+    if (log2size < 8) {
+        int8_t *indices = (int8_t*)(keys->dk_indices);
+        assert(ix <= 0x7f);
+        indices[i] = (char)ix;
+    }
+    else if (log2size < 16) {
+        int16_t *indices = (int16_t*)(keys->dk_indices);
+        assert(ix <= 0x7fff);
+        indices[i] = (int16_t)ix;
+    }
+#if SIZEOF_VOID_P > 4
+    else if (log2size >= 32) {
+        int64_t *indices = (int64_t*)(keys->dk_indices);
+        indices[i] = ix;
+    }
+#endif
+    else {
+        int32_t *indices = (int32_t*)(keys->dk_indices);
+        assert(ix <= 0x7fffffff);
+        indices[i] = (int32_t)ix;
+    }
+}
+
+#endif

sage/cpython/getattr.pxd

@@ -0,0 +1,9 @@
+# sage_setup: distribution = sagemath-objects
+# A class that allows for a more efficient creation
+# of attribute errors, so that raising them requires
+# less time.
+cdef class AttributeErrorMessage:
+    cdef public cls
+    cdef public name
+
+cpdef getattr_from_other_class(self, cls, name)

sage/cpython/getattr.pyx

@@ -0,0 +1,439 @@
+# sage_setup: distribution = sagemath-objects
+"""
+Variants of getattr()
+"""
+
+from cpython.object cimport PyObject, PyTypeObject, Py_TYPE, descrgetfunc
+
+from sage.cpython.string cimport bytes_to_str
+
+cdef extern from "Python.h":
+    r"""
+    /* Coded in C because class internals need to be accessed. */
+    static PyObject*
+    instance_getattr(PyObject* obj, PyObject* name)
+    {
+        if (PyType_Check(obj)) {
+            return _PyType_Lookup((PyTypeObject*)obj, name);
+        }
+
+        PyObject** dptr = _PyObject_GetDictPtr(obj);
+        if (dptr == NULL) return NULL;
+        PyObject* dict = *dptr;
+        if (dict == NULL) return NULL;
+        return PyDict_GetItem(dict, name);
+    }
+    """
+
+    # Return the attribute "name" from "obj". This only looks up the
+    # attribute in the instance "obj" and not in obj.__class__.
+    # If "obj" is a class, this searches for the attribute in the base
+    # classes.
+    #
+    # Return a borrowed reference or NULL if the attribute was not found.
+    PyObject* instance_getattr(obj, name)
+
+    int PyDescr_IsData(PyObject*)
+
+
+cdef class AttributeErrorMessage:
+    """
+    Try to emulate the standard Python :exc:`AttributeError` message.
+
+    .. NOTE::
+
+        The typical fate of an attribute error is being caught. Hence,
+        under normal circumstances, nobody will ever see the error
+        message. The idea for this class is to provide an object that
+        is fast to create and whose string representation is an attribute
+        error's message. That string representation is only created if
+        someone wants to see it.
+
+    EXAMPLES::
+
+        sage: 1.bla  #indirect doctest
+        Traceback (most recent call last):
+        ...
+        AttributeError: 'sage.rings.integer.Integer' object has no attribute 'bla'...
+        sage: x = polygen(ZZ, 'x')
+        sage: QQ[x].gen().bla                                                           # needs sage.libs.flint
+        Traceback (most recent call last):
+        ...
+        AttributeError: 'sage.rings.polynomial.polynomial_rational_flint.Polynomial_rational_flint' object has no attribute 'bla'...
+
+    ::
+
+        sage: from sage.cpython.getattr import AttributeErrorMessage
+        sage: AttributeErrorMessage(int(1), 'bla')
+        'int' object has no attribute 'bla'
+
+    TESTS:
+
+    The error message used for the :exc:`AttributeError` is a unique object
+    and is changed inplace. This is for reasons of efficiency.
+    Hence, if one really needs the error message as a string, then one should
+    make a copy of its string representation before it changes. ::
+
+        sage: try:
+        ....:     1.__bla
+        ....: except AttributeError as exc:
+        ....:     ElementError = exc
+        sage: ElementError
+        AttributeError('sage.rings.integer.Integer' object has no attribute '__bla'...)
+        sage: try:
+        ....:     x.__bla
+        ....: except AttributeError as exc:
+        ....:     ElementError2 = exc
+        sage: ElementError
+        AttributeError('sage.rings.polynomial...' object has no attribute '__bla'...)
+        sage: ElementError2.args[0] is ElementError.args[0]
+        True
+        sage: isinstance(ElementError.args[0], sage.cpython.getattr.AttributeErrorMessage)
+        True
+
+    AUTHOR:
+
+    - Simon King (2011-05-21)
+    """
+    def __init__(self, obj=None, name=""):
+        self.cls = type(obj)
+        self.name = name
+
+    def __repr__(self):
+        cls = bytes_to_str((<PyTypeObject*>self.cls).tp_name, 'utf-8',
+                           'replace')
+        # Go directly through tp_name since __name__ can be overridden--this is
+        # almost verbatim how CPython formats this message except we don't cut
+        # off the class name after 50 characters, and non-strings are displayed
+        # with their repr :)
+        return f"'{cls}' object has no attribute {self.name!r}"
+
+
+cdef AttributeErrorMessage dummy_error_message = AttributeErrorMessage()
+
+
+cpdef raw_getattr(obj, name):
+    """
+    Like ``getattr(obj, name)`` but without invoking the binding
+    behavior of descriptors under normal attribute access.
+    This can be used to easily get unbound methods or other
+    descriptors.
+
+    This ignores ``__getattribute__`` hooks but it does support
+    ``__getattr__``.
+
+    .. NOTE::
+
+        For Cython classes, ``__getattr__`` is actually implemented as
+        ``__getattribute__``, which means that it is not supported by
+        ``raw_getattr``.
+
+    EXAMPLES::
+
+        sage: class X:
+        ....:     @property
+        ....:     def prop(self):
+        ....:         return 42
+        ....:     def method(self):
+        ....:         pass
+        ....:     def __getattr__(self, name):
+        ....:         return "magic " + name
+        sage: raw_getattr(X, "prop")
+        <property object at ...>
+        sage: raw_getattr(X, "method")
+        <function ...method at ...>
+        sage: raw_getattr(X, "attr")
+        Traceback (most recent call last):
+        ...
+        AttributeError: '...' object has no attribute 'attr'...
+        sage: x = X()
+        sage: raw_getattr(x, "prop")
+        <property object at ...>
+        sage: raw_getattr(x, "method")
+        <function ...method at ...>
+        sage: raw_getattr(x, "attr")
+        'magic attr'
+        sage: x.__dict__["prop"] = 'no'
+        sage: x.__dict__["method"] = 'yes'
+        sage: x.__dict__["attr"] = 'ok'
+        sage: raw_getattr(x, "prop")
+        <property object at ...>
+        sage: raw_getattr(x, "method")
+        'yes'
+        sage: raw_getattr(x, "attr")
+        'ok'
+
+    The same tests with an inherited new-style class::
+
+        sage: class Y(X, object):
+        ....:     pass
+        sage: raw_getattr(Y, "prop")
+        <property object at ...>
+        sage: raw_getattr(Y, "method")
+        <function ...method at ...>
+        sage: raw_getattr(Y, "attr")
+        Traceback (most recent call last):
+        ...
+        AttributeError: '...' object has no attribute 'attr'...
+        sage: y = Y()
+        sage: raw_getattr(y, "prop")
+        <property object at ...>
+        sage: raw_getattr(y, "method")
+        <function ...method at ...>
+        sage: raw_getattr(y, "attr")
+        'magic attr'
+        sage: y.__dict__["prop"] = 'no'
+        sage: y.__dict__["method"] = 'yes'
+        sage: y.__dict__["attr"] = 'ok'
+        sage: raw_getattr(y, "prop")
+        <property object at ...>
+        sage: raw_getattr(y, "method")
+        'yes'
+        sage: raw_getattr(y, "attr")
+        'ok'
+    """
+    cdef PyObject* class_attr = NULL
+
+    try:
+        cls = obj.__class__
+    except AttributeError:
+        # Old-style classes don't have a __class__ (because these do
+        # not support metaclasses).
+        cls = None
+    else:
+        class_attr = instance_getattr(cls, name)
+
+        # We honor the order prescribed by the descriptor protocol:
+        # a data descriptor overrides instance attributes. In other
+        # cases, the instance attribute takes priority.
+        if class_attr is not NULL and PyDescr_IsData(class_attr):
+            return <object>class_attr
+
+    instance_attr = instance_getattr(obj, name)
+    if instance_attr is not NULL:
+        return <object>instance_attr
+    if class_attr is not NULL:
+        return <object>class_attr
+
+    if cls is not None:
+        try:
+            cls_getattr = cls.__getattr__
+        except AttributeError:
+            pass
+        else:
+            return cls_getattr(obj, name)
+
+    dummy_error_message.cls = type(obj)
+    dummy_error_message.name = name
+    raise AttributeError(dummy_error_message)
+
+
+cpdef getattr_from_other_class(self, cls, name):
+    """
+    Emulate ``getattr(self, name)``, as if ``self`` was an instance of
+    ``cls``.
+
+    INPUT:
+
+    - ``self`` -- some object
+
+    - ``cls`` -- a new-style class
+
+    - ``name`` -- string
+
+    If ``self`` is an instance of cls, raises an :exc:`AttributeError`, to
+    avoid a double lookup. This function is intended to be called from
+    __getattr__, and so should not be called if name is an attribute
+    of ``self``.
+
+    EXAMPLES::
+
+        sage: from sage.cpython.getattr import getattr_from_other_class
+        sage: class A():
+        ....:      def inc(self):
+        ....:          return self + 1
+        ....:
+        ....:      @staticmethod
+        ....:      def greeting():
+        ....:          print("Hello World!")
+        ....:
+        ....:      @lazy_attribute
+        ....:      def lazy_attribute(self):
+        ....:          return repr(self)
+        sage: getattr_from_other_class(1, A, "inc")
+        <bound method A.inc of 1>
+        sage: getattr_from_other_class(1, A, "inc")()
+        2
+
+    Static methods work::
+
+        sage: getattr_from_other_class(1, A, "greeting")()
+        Hello World!
+
+    Caveat: lazy attributes work with extension types only
+    if they allow attribute assignment or have a public attribute
+    ``_cached_methods`` of type ``<dict>``. This condition
+    is satisfied, e.g., by any class that is derived from
+    :class:`Parent`::
+
+        sage: getattr_from_other_class(1, A, "lazy_attribute")
+        Traceback (most recent call last):
+        ...
+        AttributeError: 'sage.rings.integer.Integer' object has no attribute 'lazy_attribute'...
+
+    The integer ring is a parent, so, lazy attributes work::
+
+        sage: getattr_from_other_class(ZZ, A, "lazy_attribute")
+        'Integer Ring'
+        sage: getattr_from_other_class(PolynomialRing(QQ, name='x', sparse=True).one(), A, "lazy_attribute")
+        '1'
+        sage: getattr_from_other_class(17, A, "lazy_attribute")
+        Traceback (most recent call last):
+        ...
+        AttributeError: 'sage.rings.integer.Integer' object has no attribute 'lazy_attribute'...
+
+    In general, descriptors are not yet well supported, because they
+    often do not accept to be cheated with the type of their instance::
+
+        sage: A.__weakref__.__get__(1)
+        Traceback (most recent call last):
+        ...
+        TypeError: descriptor '__weakref__' for 'A' objects doesn't apply
+        to ...'sage.rings.integer.Integer' object
+
+    When this occurs, an :exc:`AttributeError` is raised::
+
+        sage: getattr_from_other_class(1, A, "__weakref__")
+        Traceback (most recent call last):
+        ...
+        AttributeError: 'sage.rings.integer.Integer' object has no attribute '__weakref__'...
+
+    This was caught by :issue:`8296` for which we do a couple more tests::
+
+        sage: "__weakref__" in dir(A)
+        True
+        sage: 1.__weakref__
+        Traceback (most recent call last):
+        ...
+        AttributeError: 'sage.rings.integer.Integer' object has no attribute '__weakref__'...
+
+        sage: n = 1
+        sage: ip = get_ipython()                 # not tested: only works in interactive shell
+        sage: ip.magic_psearch('n.N')            # not tested: only works in interactive shell
+        n.N
+        sage: ip.magic_psearch('n.__weakref__')  # not tested: only works in interactive shell
+
+    Caveat: When __call__ is not defined for instances, using
+    ``A.__call__`` yields the method ``__call__`` of the class. We use
+    a workaround but there is no guarantee for robustness.
+
+        sage: getattr_from_other_class(1, A, "__call__")
+        Traceback (most recent call last):
+        ...
+        AttributeError: 'sage.rings.integer.Integer' object has no attribute '__call__'...
+
+    TESTS:
+
+    Check that we do not pick up special attributes from the ``type``
+    class, see :issue:`20686`::
+
+        sage: getattr_from_other_class(1, type, "__name__")
+        Traceback (most recent call last):
+        ...
+        AttributeError: 'sage.rings.integer.Integer' object has no attribute '__name__'...
+
+    Non-strings as "name" are handled gracefully::
+
+        sage: getattr_from_other_class(1, type, None)
+        Traceback (most recent call last):
+        ...
+        AttributeError: 'sage.rings.integer.Integer' object has no attribute None...
+    """
+    if not isinstance(cls, type):
+        raise TypeError(f"{cls!r} is not a type")
+
+    if isinstance(self, cls):
+        dummy_error_message.cls = type(self)
+        dummy_error_message.name = name
+        raise AttributeError(dummy_error_message)
+    cdef PyObject* attr = instance_getattr(cls, name)
+    if attr is NULL:
+        dummy_error_message.cls = type(self)
+        dummy_error_message.name = name
+        raise AttributeError(dummy_error_message)
+    attribute = <object>attr
+    # Check for a descriptor (__get__ in Python)
+    cdef descrgetfunc getter = Py_TYPE(attribute).tp_descr_get
+    if getter is NULL:
+        # Not a descriptor
+        return attribute
+    # Conditionally defined lazy_attributes don't work well with fake subclasses
+    # (a :exc:`TypeError` is raised if the lazy attribute is not defined).
+    # For the moment, we ignore that when this occurs.
+    # Other descriptors (including __weakref__) also break.
+    try:
+        return getter(attribute, self, cls)
+    except TypeError:
+        pass
+    dummy_error_message.cls = type(self)
+    dummy_error_message.name = name
+    raise AttributeError(dummy_error_message)
+
+
+def dir_with_other_class(self, *cls):
+    r"""
+    Emulates ``dir(self)``, as if ``self`` was also an instance ``cls``,
+    right after ``caller_class`` in the method resolution order
+    (``self.__class__.mro()``)
+
+    EXAMPLES::
+
+        sage: class A():
+        ....:    a = 1
+        ....:    b = 2
+        ....:    c = 3
+        sage: class B():
+        ....:    b = 2
+        ....:    c = 3
+        ....:    d = 4
+        sage: x = A()
+        sage: x.c = 1; x.e = 1
+        sage: from sage.cpython.getattr import dir_with_other_class
+        sage: dir_with_other_class(x, B)
+        [..., 'a', 'b', 'c', 'd', 'e']
+        sage: class C():
+        ....:    f = 6
+        sage: dir_with_other_class(x, B, C)
+        [..., 'a', 'b', 'c', 'd', 'e', 'f']
+
+    Check that objects without dicts are well handled::
+
+        sage: # needs sage.misc.cython
+        sage: cython("cdef class A:\n    cdef public int a")
+        sage: cython("cdef class B:\n    cdef public int b")
+        sage: x = A()
+        sage: x.a = 1
+        sage: hasattr(x,'__dict__')
+        False
+        sage: dir_with_other_class(x, B)
+        [..., 'a', 'b']
+
+    TESTS:
+
+    Check that :issue:`13043` is fixed::
+
+        sage: len(dir(RIF))==len(set(dir(RIF)))                                         # needs sage.rings.real_interval_field
+        True
+    """
+    ret = set()
+    # This tries to emulate the standard dir function
+    # Is there a better way to call dir on self, while ignoring this
+    # __dir__? Using dir(super(A, self)) does not work since the
+    # attributes coming from subclasses of A will be ignored
+    ret.update(dir(self.__class__))
+    if hasattr(self, "__dict__"):
+        ret.update(list(self.__dict__))
+    for c in cls:
+        if not isinstance(self, c):
+            ret.update(dir(c))
+    return sorted(ret)