passagemath-objects 10.8.1a3__cp314-cp314-win_amd64.whl

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

sage/groups/all__sagemath_objects.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-objects

sage/groups/group.pxd

@@ -0,0 +1,14 @@
+# sage_setup: distribution = sagemath-objects
+from sage.structure.parent cimport Parent
+
+cdef class Group(Parent):
+    pass
+
+cdef class AbelianGroup(Group):
+    pass
+
+cdef class FiniteGroup(Group):
+    pass
+
+cdef class AlgebraicGroup(Group):
+    pass