Cython 3.1.0__py3-none-any.whl

Cython/Includes/libcpp/deque.pxd

@@ -0,0 +1,165 @@
+cdef extern from "<deque>" namespace "std" nogil:
+    cdef cppclass deque[T,ALLOCATOR=*]:
+        ctypedef T value_type
+        ctypedef ALLOCATOR allocator_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
+
+        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)
+
+        deque() except +
+        deque(deque&) except +
+        deque(size_t) except +
+        deque(size_t, T&) except +
+        #deque[InputIt](InputIt, InputIt)
+        T& operator[](size_t)
+        #deque& operator=(deque&)
+        bint operator==(deque&, deque&)
+        bint operator!=(deque&, deque&)
+        bint operator<(deque&, deque&)
+        bint operator>(deque&, deque&)
+        bint operator<=(deque&, deque&)
+        bint operator>=(deque&, deque&)
+        void assign(size_t, T&) except +
+        void assign[InputIt](InputIt, InputIt) except +
+        T& at(size_t) except +
+        T& back()
+        iterator begin()
+        const_iterator const_begin "begin"()
+        const_iterator cbegin()
+        void clear()
+        bint empty()
+        iterator end()
+        const_iterator const_end "end"()
+        const_iterator cend()
+        iterator erase(iterator) except +
+        iterator erase(iterator, iterator) except +
+        T& front()
+        iterator insert(iterator, T&) except +
+        void insert(iterator, size_t, T&) except +
+        void insert[InputIt](iterator, InputIt, InputIt) except +
+        size_t max_size()
+        void pop_back()
+        void pop_front()
+        void push_back(T&) except +
+        void push_front(T&) except +
+        reverse_iterator rbegin()
+        #const_reverse_iterator rbegin()
+        const_reverse_iterator crbegin()
+        reverse_iterator rend()
+        #const_reverse_iterator rend()
+        const_reverse_iterator crend()
+        void resize(size_t) except +
+        void resize(size_t, T&) except +
+        size_t size()
+        void swap(deque&)
+
+        # C++11 methods
+        void shrink_to_fit() except +
+        T& emplace_front(...) except +
+        T& emplace_back(...) except +

Cython/Includes/libcpp/exception.pxd

@@ -0,0 +1,86 @@
+from libcpp cimport bool
+
+cdef extern from "<exception>" namespace "std" nogil:
+    cdef cppclass exception_ptr:
+        bool operator bool()
+
+    exception_ptr make_exception_ptr[E](E e) noexcept
+    void rethrow_exception(exception_ptr) except +
+    # current_exception skipped because it'll be almost impossible to use from Cython
+
+cdef extern from *:
+    """
+    static void __Pyx_CppExn2PyErr(void);
+
+    CYTHON_UNUSED static void __pyx_deallocate_exception_ptr_capsule(PyObject *c) {
+        std::exception_ptr *ptr = static_cast<std::exception_ptr*>(
+            PyCapsule_GetPointer(c, "std::exception_ptr wrapper"));
+        delete ptr;
+        PyErr_Clear();
+    }
+
+    CYTHON_UNUSED static void __pyx_to_exception_ptr() {
+        try {
+            __Pyx_CppExn2PyErr(); // First do regular exception conversion
+            throw;
+        } catch (...) {
+            PyObject *type, *value, *tb;
+            PyErr_Fetch(&type, &value, &tb);
+            Py_XDECREF(value);
+            Py_XDECREF(tb);
+            std::exception_ptr *current = new std::exception_ptr(std::current_exception());
+            PyObject *capsule = PyCapsule_New(
+                static_cast<void*>(current),
+                "std::exception_ptr wrapper",
+                &__pyx_deallocate_exception_ptr_capsule);
+            if (!capsule)
+                delete current;  // otherwise it'll be leaked
+            else
+                PyErr_SetObject(type ? type : PyExc_Exception, capsule);
+            Py_DECREF(type);
+        }
+    }
+
+    CYTHON_UNUSED static std::exception_ptr __pyx_wrapped_exception_ptr_from_exception(PyObject *e) {
+        PyObject *args = NULL, *arg0 = NULL;
+        std::exception_ptr result;
+        Py_ssize_t size;
+#if __PYX_LIMITED_VERSION_HEX < 0x030C0000
+        args = PyObject_GetAttrString(e, "args");
+#else
+        args = PyException_GetArgs(e);
+#endif
+        if (!args)
+            goto done;
+        size = PyTuple_Size(args);
+        if (size != 1) {
+            if (size != -1)
+                PyErr_SetString(PyExc_ValueError, "exception args were not the expected length of 1");
+            goto done;
+        }
+        arg0 = PyTuple_GetItem(args, 0);
+        if (!arg0)
+            goto done;
+        {
+            std::exception_ptr* wrapped = static_cast<std::exception_ptr*>(
+                PyCapsule_GetPointer(arg0, "std::exception_ptr wrapper"));
+            if (!wrapped) {
+                goto done;
+            }
+            result = *wrapped;
+        }
+
+      done:
+        Py_XDECREF(args);
+        return result;
+    }
+    """
+    # This can be used as `except +exception_ptr_error_handler`.
+    # It raises a generic Exception, with a wrapped exception_ptr as its value.
+    void exception_ptr_error_handler "__pyx_to_exception_ptr"() except *
+    # Extract the exception_ptr from a caught exception
+    exception_ptr wrapped_exception_ptr_from_exception "__pyx_wrapped_exception_ptr_from_exception"(e) except *
+
+# Dummy inline function to force __Pyx_CppExn2PyErr to be included for utility code above
+cdef inline void __pyx_call_rethrow_exception "__pyx_call_rethrow_exception"(exception_ptr e) except*:
+    rethrow_exception(e)

Cython/Includes/libcpp/execution.pxd

@@ -0,0 +1,15 @@
+
+cdef extern from "<execution>" namespace "std::execution" nogil:
+    cdef cppclass sequenced_policy:
+        pass
+    cdef cppclass parallel_policy:
+        pass
+    cdef cppclass parallel_unsequenced_policy:
+        pass
+    cdef cppclass unsequenced_policy:
+        pass
+
+    const sequenced_policy seq "std::execution::seq"
+    const parallel_policy par "std::execution::par"
+    const parallel_unsequenced_policy par_unseq "std::execution::par_unseq"
+    const unsequenced_policy unseq "std::execution::unseq"

Cython/Includes/libcpp/forward_list.pxd

@@ -0,0 +1,63 @@
+cdef extern from "<forward_list>" namespace "std" nogil:
+    cdef cppclass forward_list[T,ALLOCATOR=*]:
+        ctypedef T value_type
+        ctypedef ALLOCATOR allocator_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
+
+        cppclass iterator:
+            iterator()
+            iterator(iterator &)
+            T& operator*()
+            iterator operator++()
+            iterator operator++(int)
+            bint operator==(iterator)
+            bint operator!=(iterator)
+        cppclass const_iterator(iterator):
+            pass
+        forward_list() except +
+        forward_list(forward_list&) except +
+        forward_list(size_t, T&) except +
+        #forward_list& operator=(forward_list&)
+        bint operator==(forward_list&, forward_list&)
+        bint operator!=(forward_list&, forward_list&)
+        bint operator<(forward_list&, forward_list&)
+        bint operator>(forward_list&, forward_list&)
+        bint operator<=(forward_list&, forward_list&)
+        bint operator>=(forward_list&, forward_list&)
+        void assign(size_t, T&)
+        T& front()
+        iterator before_begin()
+        const_iterator const_before_begin "before_begin"()
+        iterator begin()
+        const_iterator const_begin "begin"()
+        iterator end()
+        const_iterator const_end "end"()
+        bint empty()
+        size_t max_size()
+        void clear()
+        iterator insert_after(iterator, T&)
+        void insert_after(iterator, size_t, T&)
+        iterator erase_after(iterator)
+        iterator erase_after(iterator, iterator)
+        void push_front(T&)
+        void pop_front()
+        void resize(size_t)
+        void resize(size_t, T&)
+        void swap(forward_list&)
+        void merge(forward_list&)
+        void merge[Compare](forward_list&, Compare)
+        void splice_after(iterator, forward_list&)
+        void splice_after(iterator, forward_list&, iterator)
+        void splice_after(iterator, forward_list&, iterator, iterator)
+        void remove(const T&)
+        void remove_if[Predicate](Predicate)
+        void reverse()
+        void unique()
+        void unique[Predicate](Predicate)
+        void sort()
+        void sort[Compare](Compare)

Cython/Includes/libcpp/functional.pxd

@@ -0,0 +1,26 @@
+from libcpp cimport bool
+
+cdef extern from "<functional>" namespace "std" nogil:
+    cdef cppclass function[T]:
+        function() except +
+        function(T*) except +
+        function(function&) except +
+        function(void*) except +
+
+        function operator=(T*)
+        function operator=(function&)
+        function operator=(void*)
+        function operator=[U](U)
+
+        bool operator bool()
+
+    # Comparisons
+    cdef cppclass greater[T=*]:
+        # https://github.com/cython/cython/issues/3193
+        greater() except +
+        bool operator()(const T& lhs, const T& rhs) except +
+
+    cdef cppclass reference_wrapper[T]:
+        reference_wrapper()
+        reference_wrapper(T)
+        T& get() const

Cython/Includes/libcpp/future.pxd

@@ -0,0 +1,103 @@
+from libcpp cimport bool
+from libcpp.exception cimport exception_ptr
+
+cdef extern from "<future>":
+    pass  # include first
+
+cdef extern from *:
+    """
+    static void __Pyx_CppExn2PyErr();
+    CYTHON_UNUSED static void __pyx_future_error_handler() {
+        try {
+            throw;
+        } catch (const std::future_error &e) {
+            PyObject *args = Py_BuildValue(
+                "sis",
+                "std::future_error",
+                e.code().value(),
+                e.what()
+            );
+            if (!args) return;
+            Py_INCREF(PyExc_RuntimeError);
+            // It'd be nice to raise something more specific, but I can't easily do that
+            // so I've tried to at least make them identifiable by the arguments.
+            PyErr_Restore(PyExc_RuntimeError, args, NULL);
+        } catch (...) {
+            // Forward to the normal Cython exception conversion;
+            __Pyx_CppExn2PyErr();
+        }
+    }
+    """
+    void __pyx_future_error_handler() except+
+
+cdef extern from "<future>" namespace "std" nogil:
+    cdef enum class future_status:
+        ready
+        timeout
+        deferred
+
+    cdef cppclass future[T]:
+        future() noexcept
+        future(future& other) noexcept  # slightly mistyped move constructor
+
+        future& operator=(future& other) noexcept  # slightly mistyped move assignment
+
+        shared_future[T] share() noexcept
+
+        # Not strictly right when T is a reference or void
+        T get() except +__pyx_future_error_handler
+
+        bool valid() noexcept
+
+        void wait() except+
+        # For wait_for and wait_until we don't have chrono yet
+        future_status wait_for(...) except+
+        future_status wait_until(...) except+
+
+    cdef cppclass shared_future[T]:
+        shared_future() noexcept
+        shared_future(const shared_future& other) noexcept  # noexcept only from c++17 strictly
+        shared_future(future[T]& other) noexcept  # slightly mistyped move
+
+        shared_future& operator=(const shared_future& other) noexcept  # noexcept only from c++17 strictly
+        shared_future& operator=(future& other) noexcept  # slightly mistyped move
+
+        # Not strictly right when T is a reference or void
+        const T& get() except +__pyx_future_error_handler
+
+        bool valid() noexcept
+
+        void wait() except+
+        # For wait_for and wait_until we don't have chrono yet
+        future_status wait_for(...) except+
+        future_status wait_until(...) except+
+
+    cdef cppclass promise[T]:
+        promise() noexcept
+        # don't expose the allocator version
+        promise(promise& other) noexcept  # slightly mistyped move
+
+        promise& operator=(promise& other) noexcept  # slightly mistyped move
+
+        void swap(promise& other) noexcept
+
+        future[T] get_future() except+
+
+        # Note that the set_* functions all have specialized error handling.
+        # A std::future_error will be converted to a RuntimeError with 3 arguments.
+        # The first argument is the string "std::future_error",
+        # the second is the error code as an int for comparison with future_errc,
+        # and the third is the message.
+        void set_value(T value) except +__pyx_future_error_handler
+        void set_value() except +__pyx_future_error_handler  # only for void specialization
+        void set_value_at_thread_exit(T value) except +__pyx_future_error_handler
+        void set_value_at_thread_exit() except +__pyx_future_error_handler  # only for void specialization
+
+        void set_exception(exception_ptr p) except +__pyx_future_error_handler
+        void set_exception_at_thread_exit(exception_ptr p) except +__pyx_future_error_handler
+
+    cdef enum class future_errc:
+        broken_promise
+        future_already_retrieved
+        promise_already_satisfied
+        no_state

Cython/Includes/libcpp/iterator.pxd

@@ -0,0 +1,34 @@
+#Basic reference: http://www.cplusplus.com/reference/iterator/
+#Most of these classes are in fact empty structs
+
+from libc.stddef import ptrdiff_t
+
+cdef extern from "<iterator>" namespace "std" nogil:
+    cdef cppclass iterator[Category,T,Distance,Pointer,Reference]:
+        pass
+    cdef cppclass output_iterator_tag:
+        pass
+    cdef cppclass input_iterator_tag:
+        pass
+    cdef cppclass forward_iterator_tag(input_iterator_tag):
+        pass
+    cdef cppclass bidirectional_iterator_tag(forward_iterator_tag):
+        pass
+    cdef cppclass random_access_iterator_tag(bidirectional_iterator_tag):
+        pass
+
+    cdef cppclass back_insert_iterator[T](iterator[output_iterator_tag,void,void,void,void]):
+        pass
+    cdef cppclass front_insert_iterator[T](iterator[output_iterator_tag,void,void,void,void]):
+        pass
+    cdef cppclass insert_iterator[T](iterator[output_iterator_tag,void,void,void,void]):
+        pass
+    back_insert_iterator[CONTAINER] back_inserter[CONTAINER](CONTAINER &)
+    front_insert_iterator[CONTAINER] front_inserter[CONTAINER](CONTAINER &)
+    ##Note: this is the C++98 version of inserter.
+    ##The C++11 versions's prototype relies on typedef members of classes, which Cython doesn't currently support:
+    ##template <class Container>
+    ##insert_iterator<Container> inserter (Container& x, typename Container::iterator it)
+    insert_iterator[CONTAINER] inserter[CONTAINER,ITERATOR](CONTAINER &, ITERATOR)
+
+    ptrdiff_t distance[It](It first, It last)

Cython/Includes/libcpp/latch.pxd

@@ -0,0 +1,17 @@
+from libcpp cimport bool
+
+cdef extern from "<latch>" namespace "std" nogil:
+    # Note on thread safety:
+    # For any of the blocking functions, you should be very careful
+    # to ensure that you are not deadlocked on the GIL.
+    cdef cppclass latch:
+        latch(ptrdiff_t expected)
+
+        void count_down() except+
+        void count_down(ptrdiff_t n) except+
+        bool try_wait()
+        void wait() except+
+        void arrive_and_wait() except+
+        void arrive_and_wait(ptrdiff_t n) except+
+
+        ptrdiff_t max()

Cython/Includes/libcpp/limits.pxd

@@ -0,0 +1,61 @@
+cdef extern from "<limits>" namespace "std" nogil:
+    enum float_round_style:
+        round_indeterminate       = -1
+        round_toward_zero         = 0
+        round_to_nearest          = 1
+        round_toward_infinity     = 2
+        round_toward_neg_infinity = 3
+
+    enum float_denorm_style:
+        denorm_indeterminate  = -1
+        denorm_absent         = 0
+        denorm_present        = 1
+
+    #The static methods can be called as, e.g. numeric_limits[int].round_error(), etc.
+    #The const data members should be declared as static.  Cython currently doesn't allow that
+    #and/or I can't figure it out, so you must instantiate an object to access, e.g.
+    #cdef numeric_limits[double] lm
+    #print lm.round_style
+    cdef cppclass numeric_limits[T]:
+        const bint is_specialized
+        @staticmethod
+        T min()
+        @staticmethod
+        T max()
+        const int digits
+        const int  digits10
+        const bint is_signed
+        const bint is_integer
+        const bint is_exact
+        const int radix
+        @staticmethod
+        T epsilon()
+        @staticmethod
+        T round_error()
+
+        const int  min_exponent
+        const int  min_exponent10
+        const int  max_exponent
+        const int  max_exponent10
+
+        const bint has_infinity
+        const bint has_quiet_NaN
+        const bint has_signaling_NaN
+        const float_denorm_style has_denorm
+        const bint has_denorm_loss
+        @staticmethod
+        T infinity()
+        @staticmethod
+        T quiet_NaN()
+        @staticmethod
+        T signaling_NaN()
+        @staticmethod
+        T denorm_min()
+
+        const bint is_iec559
+        const bint is_bounded
+        const bint is_modulo
+
+        const bint traps
+        const bint tinyness_before
+        const float_round_style round_style