Cython 3.1.0__py3-none-any.whl

Cython/Includes/libcpp/shared_mutex.pxd

@@ -0,0 +1,72 @@
+from libcpp cimport bool
+from libcpp.mutex cimport defer_lock_t, defer_lock, try_to_lock_t, try_to_lock, adopt_lock_t, adopt_lock
+
+cdef extern from "<shared_mutex>" namespace "std" nogil:
+    cppclass shared_mutex:
+        # may not be present, and we know nothing about it
+        cppclass native_handle_type:
+            pass
+
+        # We strongly recommend not calling lock with the GIL held (to avoid deadlocks)
+        void lock() except+
+        bool try_lock()
+        void unlock()
+
+        # We strongly recommend not calling lock_shared with the GIL held (to avoid deadlocks)
+        void lock_shared() except+
+        bool try_lock_shared()
+        void unlock_shared()
+
+        native_handle_type native_handle() except+
+
+    cppclass shared_timed_mutex:
+        # may not be present, and we know nothing about it.
+        # For shared_timed_mutex cppreference doesn't mention this
+        cppclass native_handle_type:
+            pass
+
+        # We strongly recommend not calling lock with the GIL held (to avoid deadlocks)
+        # and moderately recommend not calling the timed lock functions with the GIL either.
+        void lock() except+
+        bool try_lock()
+        bool try_lock_for[T](const T& duration) except+
+        bool try_lock_until[T](const T& time_point) except+
+        void unlock()
+
+        void lock_shared() except+
+        bool try_lock_shared()
+        bool try_lock_shared_for[T](const T& duration) except+
+        bool try_lock_shared_until[T](const T& time_point) except+
+        void unlock_shared()
+
+        native_handle_type native_handle() except+
+
+    cppclass shared_lock[T]:
+        ctypedef T mutex_type
+        # This covers both the plain regular constructor, the 3 versions with tags
+        # and two std::chrono constructors.  The two templated chrono versions stop
+        # us from declaring the overloads explicitly.
+        shared_lock()
+        shared_lock(mutex_type&, ...) except+
+        #shared_lock(mutex_type&, defer_lock_t)
+        #shared_lock(mutex_type&, try_to_lock_t) except+
+        ## this feels like it should be noexcept, but cppreference implies it isn't
+        #shared_lock(mutex_type&, adopt_lock_t) except+
+
+        # We strongly recommend not calling lock with the GIL held (to avoid deadlocks)
+        void lock() except+
+        bool try_lock() except+
+        bool try_lock_for[T](const T& duration) except+
+        bool try_lock_until[T](const T& time_point) except+
+        void unlock() except+
+
+        # We strongly recommend not calling lock_shared with the GIL held (to avoid deadlocks)
+        void swap(shared_lock& other)
+        # "release" is definitely not the same as unlock. Noted here because
+        # DW always makes this mistake and regrets it and wants to save you
+        # from the same fate.
+        mutex_type* release()
+
+        mutex_type* mutex()
+        bool owns_lock()
+        bool operator bool()

Cython/Includes/libcpp/span.pxd

@@ -0,0 +1,87 @@
+from libcpp.vector cimport vector
+
+cdef extern from "<span>" namespace "std" nogil:
+    # Only Extent = std::dynamic_extent is supported until Cython can also
+    # support integer templates. See https://github.com/cython/cython/pull/426
+    cdef cppclass span[T]:
+        ctypedef T value_type
+        ctypedef size_t size_type
+        ctypedef ptrdiff_t difference_type
+
+        size_t extent
+
+        cppclass iterator:
+            iterator() except +
+            iterator(iterator&) except +
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator++(int)
+            iterator operator--(int)
+            iterator operator+(size_type)
+            iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(iterator)
+            bint operator==(const_iterator)
+            bint operator!=(iterator)
+            bint operator!=(const_iterator)
+            bint operator<(iterator)
+            bint operator<(const_iterator)
+            bint operator>(iterator)
+            bint operator>(const_iterator)
+            bint operator<=(iterator)
+            bint operator<=(const_iterator)
+            bint operator>=(iterator)
+            bint operator>=(const_iterator)
+
+        cppclass reverse_iterator:
+            reverse_iterator() except +
+            reverse_iterator(reverse_iterator&) except +
+            T& operator*()
+            reverse_iterator operator++()
+            reverse_iterator operator--()
+            reverse_iterator operator++(int)
+            reverse_iterator operator--(int)
+            reverse_iterator operator+(size_type)
+            reverse_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator<(const_reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator>(const_reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator<=(const_reverse_iterator)
+            bint operator>=(reverse_iterator)
+            bint operator>=(const_reverse_iterator)
+
+        # const_iterator was added in C++23, so leaving it out for now
+
+        span()
+        span(T*, size_type) except +  # span[It](It, size_type)
+        span(T*, T*) except +  # span[It, End](It, End)
+        span(vector&)  # span[U, N](array[T, N]& arr)
+        span(span&)
+
+        T& operator[](ssize_t)
+
+        T& back()
+        iterator begin()
+        T* data()
+        bint empty()
+        iterator end()
+        span[T] first(size_type)
+        T& front()
+        span[T] last(size_type)
+        reverse_iterator rbegin()
+        reverse_iterator rend()
+        size_type size()
+        span[T] subspan(size_type)
+        span[T] subspan(size_type, size_type)
+
+    cdef size_t dynamic_extent

Cython/Includes/libcpp/stack.pxd

@@ -0,0 +1,11 @@
+cdef extern from "<stack>" namespace "std" nogil:
+    cdef cppclass stack[T]:
+        ctypedef T value_type
+        stack() except +
+        stack(stack&) except +
+        #stack(Container&)
+        bint empty()
+        void pop()
+        void push(T&) except +
+        size_t size()
+        T& top()

Cython/Includes/libcpp/stop_token.pxd

@@ -0,0 +1,105 @@
+from libcpp cimport bool
+
+cdef extern from "<stop_token>" namespace "std" nogil:
+    cdef cppclass stop_token:
+        bool stop_requested() noexcept
+        bool stop_possible() noexcept
+
+    cdef cppclass nostopstate_t:
+        pass
+
+    nostopstate_t nostopstate
+
+    cdef cppclass stop_source:
+        stop_source() except+
+        stop_source(nostopstate_t) noexcept
+
+        bool request_stop() noexcept
+        void swap(stop_source& other) noexcept
+
+        stop_token get_token() noexcept
+        bool stop_requested() noexcept
+        bool stop_possible() noexcept
+
+    # stop_callback is not copyable or moveable which currently means it must
+    # be heap-allocated in Cython (although use with cpp_locals should eventually be supported too)
+    cdef cppclass stop_callback[Callback]:
+        # in principle the second argument is a template argument with a "std::constructable_from" constraint,
+        # but for Cython's purposes it probably makes sense to assume no conversion
+        stop_callback(stop_token st, Callback cb) noexcept
+
+cdef extern from *:
+    """
+    #include <optional>
+    #include <utility>
+
+    namespace {
+        using __pyx_func_ptr_stop_callback = std::stop_callback<void (*)()>;
+
+        class __pyx_python_stop_callback_holder {
+            class callable_py_object_holder {
+                PyObject *o;
+
+              public:
+                explicit callable_py_object_holder(PyObject *o)
+                    : o(o)
+                {
+                    Py_INCREF(o);
+                }
+
+                callable_py_object_holder(callable_py_object_holder&& rhs)
+                    : o(std::exchange(rhs.o, nullptr))
+                {
+                }
+
+                ~callable_py_object_holder() {
+                    if (o) {
+                        PyGILState_STATE state = PyGILState_Ensure();
+                        Py_DECREF(o);
+                        PyGILState_Release(state);
+                    }
+                }
+
+                callable_py_object_holder(const callable_py_object_holder&) = delete;
+                callable_py_object_holder& operator=(const callable_py_object_holder&) = delete;
+
+                void operator()() const {
+                    PyGILState_STATE state = PyGILState_Ensure();
+                    PyObject *result = PyObject_CallObject(o, NULL);
+                    if (!result) {
+                        PyObject *s = PyUnicode_FromString("python_stop_callback_holder callback");
+                        PyErr_WriteUnraisable(s);
+                        Py_XDECREF(s);
+                    } else {
+                        Py_DECREF(result);
+                    }
+                    PyGILState_Release(state);
+                }
+            };
+
+            std::optional<std::stop_callback<callable_py_object_holder>> callback;
+
+          public:
+            __pyx_python_stop_callback_holder() = default;
+            __pyx_python_stop_callback_holder(std::stop_token token, PyObject *callable) {
+                initialize(std::move(token), callable);
+            }
+            __pyx_python_stop_callback_holder(const __pyx_python_stop_callback_holder&) = delete;
+
+            __pyx_python_stop_callback_holder& operator=(const __pyx_python_stop_callback_holder&) = delete;
+
+            void initialize(std::stop_token token, PyObject *callable) {
+                callback.emplace(std::move(token), callable_py_object_holder(callable));
+            }
+        };
+    }
+    """
+    # This is provided as a convenience mainly as a reminder to use nogil functions!
+    ctypedef stop_callback[void (*)() nogil noexcept] func_ptr_stop_callback "__pyx_func_ptr_stop_callback"
+
+    # A fairly thin wrapper to let you create a stop callback with a Python object.
+    # For most uses, it should be created empty and then filled with "initialize"
+    cdef cppclass python_stop_callback_holder "__pyx_python_stop_callback_holder":
+        python_stop_callback_holder()
+        python_stop_callback_holder(stop_token token, object callable)
+        void initialize(stop_token token, object callable)

Cython/Includes/libcpp/string.pxd

@@ -0,0 +1,355 @@
+
+# deprecated cimport for backwards compatibility:
+from libc.string cimport const_char
+
+from libcpp.string_view cimport string_view
+
+cdef extern from "<string>" namespace "std::string" nogil:
+    const size_t npos
+
+cdef extern from "<string>" namespace "std" nogil:
+    # 21.3.4, numeric conversions
+    int stoi(const string& s, size_t* idx, int base) except +
+    long stol(const string& s, size_t* idx, int base) except +
+    unsigned long stoul(const string& s, size_t* idx, int base) except +
+    long long stoll(const string& s, size_t* idx, int base) except +
+    unsigned long long stoull(const string& s, size_t* idx, int base) except +
+    float stof(const string& s, size_t* idx) except +
+    double stod(const string& s, size_t* idx) except +
+    long double stold(const string& s, size_t* idx) except +
+
+    # Duplicate declarations are necessary, because extern functions cannot have default arguments values
+    int stoi(const string& s, size_t* idx) except +
+    long stol(const string& s, size_t* idx) except +
+    unsigned long stoul(const string& s, size_t* idx) except +
+    long long stoll(const string& s, size_t* idx) except +
+    unsigned long long stoull(const string& s, size_t* idx) except +
+
+    int stoi(const string& s) except +
+    long stol(const string& s) except +
+    unsigned long stoul(const string& s) except +
+    long long stoll(const string& s) except +
+    unsigned long long stoull(const string& s) except +
+    float stof(const string& s) except +
+    double stod(const string& s) except +
+    long double stold(const string& s) except +
+
+    string to_string(int val) except +
+    string to_string(unsigned val) except +
+    string to_string(long val) except +
+    string to_string(unsigned long val) except +
+    string to_string(long long val) except +
+    string to_string(unsigned long long val) except +
+    string to_string(float val) except +
+    string to_string(double val) except +
+    string to_string(long double val) except +
+
+    # Cython doesn't know which size type is equivalent to s/size_t on a given platform
+    string to_string(size_t val) except +
+    string to_string(ssize_t val) except +
+
+    cdef cppclass string:
+        ctypedef char value_type
+
+        # these should really be allocator_type.size_type and
+        # allocator_type.difference_type to be true to the C++ definition
+        # but cython doesn't support deferred access on template arguments
+        ctypedef size_t size_type
+        ctypedef ptrdiff_t difference_type
+
+        bint operator==(const string&)
+        bint operator==(const char*)
+        bint operator!= (const string&)
+        bint operator!= (const char*)
+        bint operator< (const string&)
+        bint operator< (const char*)
+        bint operator> (const string&)
+        bint operator> (const char*)
+        bint operator<= (const string&)
+        bint operator<= (const char*)
+        bint operator>= (const string&)
+        bint operator>= (const char*)
+
+        string operator+ (const string&) except +
+        string operator+ (const char*) except +
+
+        cppclass const_iterator
+        cppclass iterator:
+            iterator() except +
+            iterator(iterator&) except +
+            value_type& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator++(int)
+            iterator operator--(int)
+            iterator operator+(size_type)
+            iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(iterator)
+            bint operator==(const_iterator)
+            bint operator!=(iterator)
+            bint operator!=(const_iterator)
+            bint operator<(iterator)
+            bint operator<(const_iterator)
+            bint operator>(iterator)
+            bint operator>(const_iterator)
+            bint operator<=(iterator)
+            bint operator<=(const_iterator)
+            bint operator>=(iterator)
+            bint operator>=(const_iterator)
+        cppclass const_iterator:
+            const_iterator() except +
+            const_iterator(iterator&) except +
+            const_iterator(const_iterator&) except +
+            operator=(iterator&) except +
+            const value_type& operator*()
+            const_iterator operator++()
+            const_iterator operator--()
+            const_iterator operator++(int)
+            const_iterator operator--(int)
+            const_iterator operator+(size_type)
+            const_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(iterator)
+            bint operator==(const_iterator)
+            bint operator!=(iterator)
+            bint operator!=(const_iterator)
+            bint operator<(iterator)
+            bint operator<(const_iterator)
+            bint operator>(iterator)
+            bint operator>(const_iterator)
+            bint operator<=(iterator)
+            bint operator<=(const_iterator)
+            bint operator>=(iterator)
+            bint operator>=(const_iterator)
+
+        cppclass const_reverse_iterator
+        cppclass reverse_iterator:
+            reverse_iterator() except +
+            reverse_iterator(reverse_iterator&) except +
+            value_type& operator*()
+            reverse_iterator operator++()
+            reverse_iterator operator--()
+            reverse_iterator operator++(int)
+            reverse_iterator operator--(int)
+            reverse_iterator operator+(size_type)
+            reverse_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator<(const_reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator>(const_reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator<=(const_reverse_iterator)
+            bint operator>=(reverse_iterator)
+            bint operator>=(const_reverse_iterator)
+        cppclass const_reverse_iterator:
+            const_reverse_iterator() except +
+            const_reverse_iterator(reverse_iterator&) except +
+            operator=(reverse_iterator&) except +
+            const value_type& operator*()
+            const_reverse_iterator operator++()
+            const_reverse_iterator operator--()
+            const_reverse_iterator operator++(int)
+            const_reverse_iterator operator--(int)
+            const_reverse_iterator operator+(size_type)
+            const_reverse_iterator operator-(size_type)
+            difference_type operator-(iterator)
+            difference_type operator-(const_iterator)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator<(const_reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator>(const_reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator<=(const_reverse_iterator)
+            bint operator>=(reverse_iterator)
+            bint operator>=(const_reverse_iterator)
+
+        # 21.3.2.2, construct/copy/destroy
+        string() except +  # (1)
+        string(const string& s) except +  # (3)
+        string(const string& s, size_t pos) except +  # (5)
+        string(const string& s, size_t pos, size_t len) except +  # (6)
+        string(const char* s, size_t n) except +  # (9)
+        string(const char* s) except +  # (10)
+        string(size_t n, char c) except +  # (11)
+        string(const string_view& sv) except +
+        # type (string&) is needed here so that Cython can compile templated definition
+        string& string[InputIt](InputIt, InputIt) except +  # (12)
+
+        #string& operator= (const string&)
+        #string& operator= (const char*)
+        #string& operator= (char)
+
+        # 21.3.2.3, iterators
+        iterator begin()
+        const_iterator const_begin "begin"()
+        iterator end()
+        const_iterator const_end "end"()
+
+        reverse_iterator rbegin()
+        const_reverse_iterator const_rbegin "rbegin"()
+        reverse_iterator rend()
+        const_reverse_iterator const_rend "rend"()
+
+        const_iterator cbegin()
+        const_iterator cend()
+        const_reverse_iterator crbegin()
+        const_reverse_iterator crend()
+
+        # 21.3.2.4, capacity
+        size_t size()
+        size_t length()
+        size_t max_size()
+        void resize(size_t, char) except +
+        void resize(size_t) except +
+        size_t capacity()
+        void reserve(size_t) except +
+        void shrink_to_fit() except +
+        void clear()
+        bint empty()
+
+        # 21.3.2.5, element access
+        char& operator[](size_t pos)
+        char& at(size_t pos) except +
+
+        char& front()
+        char& back()
+
+        # 21.3.2.6, modifiers
+        string& append(const string& s) except +  # (1)
+        string& append(const string& s, size_t subpos, size_t sublen) except +  # (2)
+        string& append(const char* s) except +  # (5)
+        string& append(const char* s, size_t n) except +  # (6)
+        string& append(size_t n, char c) except +  # (7)
+        string& append[InputIt](InputIt, InputIt) except +  # (8)
+
+        void push_back(char c) except +
+
+        string& assign(const string& s) except +  # (1)
+        string& assign(const string& s, size_t subpos, size_t sublen) except +  # (3)
+        string& assign(const char* s, size_t n) except +  # (6)
+        string& assign(const char* s) except +  # (7)
+        string& assign(size_t n, char c) except +  # (8)
+        string& assign[InputIt](InputIt, InputIt) except +  # (9)
+
+        string& insert(size_t pos, const string& s) except +  # (1)
+        string& insert(size_t pos, const string& s, size_t subpos, size_t sublen) except +  # (2)
+        string& insert(size_t pos, const char* s, size_t n) except +  # (5)
+        string& insert(size_t pos, const char* s) except +  # (6)
+        string& insert(size_t pos, size_t n, char c) except +  # (7)
+        iterator insert(iterator p, char c) except +  # (8)
+        iterator insert(iterator p, size_t n, char c) except +  # (9)
+        # This method should be templated in InputIt arguments, but then it is not resolved by Cython
+        iterator insert(iterator, iterator, iterator) except +  # (10)
+
+        string& erase(size_t pos, size_t len) except +  # (1)
+        string& erase(size_t pos) except +  # (1)
+        string& erase() except +  # (1)
+        iterator erase(iterator p) except +  # (2)
+        iterator erase(const_iterator p) except +
+        iterator erase(iterator first, iterator last) except +  # (3)
+        iterator erase(const_iterator first, const_iterator last) except +
+
+        void pop_back()
+
+        string& replace(size_t pos, size_t len, const string& str) except +  # (1)
+        string& replace(size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) except +  # (2)
+        string& replace(size_t pos, size_t len, const char* s, size_t n) except +  # (5)
+        string& replace(size_t pos, size_t len, const char* s) except +  # (6)
+        string& replace(size_t pos, size_t len, size_t n, char c) except +  # (7)
+        string& replace(iterator i1, iterator i2, const string& str) except +  # (8)
+        string& replace(iterator i1, iterator i2, const char* s, size_t n) except +  # (10)
+        string& replace(iterator i1, iterator i2, const char* s) except +  # (11)
+        string& replace(iterator i1, iterator i2, size_t n, char c) except +  # (12)
+        string& replace(iterator i1, iterator i2, iterator j1, iterator j2) except +  # (13)
+
+        size_t copy(char* s, size_t len, size_t pos) except +
+        size_t copy(char* s, size_t len) except +
+
+        void swap(string& other)
+
+        # 21.3.2.7, string operations
+        const char* c_str()
+        const char* data()
+
+        size_t find(const string& s, size_t pos)
+        size_t find(const string& s)
+        size_t find(const char* s, size_t pos, size_t n)
+        size_t find(const char* s, size_t pos)
+        size_t find(const char* s)
+        size_t find(char c, size_t pos)
+        size_t find(char c)
+
+        size_t rfind(const string&, size_t pos)
+        size_t rfind(const string&)
+        size_t rfind(const char* s, size_t pos, size_t n)
+        size_t rfind(const char* s, size_t pos)
+        size_t rfind(const char* s)
+        size_t rfind(char c, size_t pos)
+        size_t rfind(char c)
+
+        size_t find_first_of(const string&, size_t pos)
+        size_t find_first_of(const string&)
+        size_t find_first_of(const char* s, size_t pos, size_t n)
+        size_t find_first_of(const char* s, size_t pos)
+        size_t find_first_of(const char* s)
+        size_t find_first_of(char c, size_t pos)
+        size_t find_first_of(char c)
+
+        size_t find_first_not_of(const string& s, size_t pos)
+        size_t find_first_not_of(const string& s)
+        size_t find_first_not_of(const char* s, size_t pos, size_t n)
+        size_t find_first_not_of(const char* s, size_t pos)
+        size_t find_first_not_of(const char*)
+        size_t find_first_not_of(char c, size_t pos)
+        size_t find_first_not_of(char c)
+
+        size_t find_last_of(const string& s, size_t pos)
+        size_t find_last_of(const string& s)
+        size_t find_last_of(const char* s, size_t pos, size_t n)
+        size_t find_last_of(const char* s, size_t pos)
+        size_t find_last_of(const char* s)
+        size_t find_last_of(char c, size_t pos)
+        size_t find_last_of(char c)
+
+        size_t find_last_not_of(const string& s, size_t pos)
+        size_t find_last_not_of(const string& s)
+        size_t find_last_not_of(const char* s, size_t pos, size_t n)
+        size_t find_last_not_of(const char* s, size_t pos)
+        size_t find_last_not_of(const char* s)
+        size_t find_last_not_of(char c, size_t pos)
+        size_t find_last_not_of(char c)
+
+        string substr(size_t pos, size_t len) except +
+        string substr(size_t pos) except +
+        string substr()
+
+        int compare(const string& s)
+        int compare(size_t pos, size_t len, const string& s) except +
+        int compare(size_t pos, size_t len, const string& s, size_t subpos, size_t sublen) except +
+        int compare(const char* s) except +
+        int compare(size_t pos, size_t len, const char* s) except +
+        int compare(size_t pos, size_t len, const char* s , size_t n) except +
+
+        # C++20
+        bint starts_with(char c) except +
+        bint starts_with(const char* s)
+
+        bint ends_with(char c) except +
+        bint ends_with(const char* s)
+
+        # C++23
+        bint contains(char c) except +
+        bint contains(const char* s)