Cython 3.3.0a1__cp315-cp315-win_amd64.whl

Cython/Includes/libcpp/exception.pxd

@@ -0,0 +1,216 @@
+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 +
+    exception_ptr current_exception() noexcept
+
+    cdef cppclass exception:
+        const char* what() noexcept
+
+cdef extern from "<stdexcept>" namespace "std" nogil:
+    # Omitting the constructors of derived exception classes for now.
+    # They can't be stack-allocated easily in Cython because they don't have
+    # a nullary constructor. They also can't be thrown in Cython.
+    # So they're most useful just as class names when implementing
+    # exception handlers.
+    cdef cppclass logic_error(exception):
+        pass
+    cdef cppclass invalid_argument(logic_error):
+        pass
+    cdef cppclass domain_error(logic_error):
+        pass
+    cdef cppclass length_error(logic_error):
+        pass
+    cdef cppclass out_of_range(logic_error):
+        pass
+
+    cdef cppclass runtime_error(exception):
+        pass
+    cdef cppclass range_error(runtime_error):
+        pass
+    cdef cppclass overflow_error(runtime_error):
+        pass
+
+    cdef cppclass bad_typeid(exception):
+        pass
+
+    cdef cppclass bad_cast(exception):
+        pass
+
+    cdef cppclass bad_alloc(exception):
+        pass
+
+    cdef cppclass bad_exception(exception):
+        pass
+
+
+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)
+
+
+cdef extern from *:
+    """
+    namespace {
+        #if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+        template <typename ExceptionT>
+        bool __pyx_call_exception_handler(void (*handler)(ExceptionT&)) {
+            try {
+                throw;
+            } catch(ExceptionT &ex) {
+                handler(ex);
+                return static_cast<bool>(PyErr_Occurred());
+            } catch (...) {
+                return false;
+            }
+        }
+
+        bool __pyx_call_exception_handler(void(*handler)()) {
+            try {
+                throw;
+            } catch (...) {
+                handler();
+                return static_cast<bool>(PyErr_Occurred());
+            }
+        }
+
+        template <typename ...HandlerTs>
+        void __pyx_delegate_to_exception_handlers(HandlerTs&& ... handlers) {
+            if (!std::current_exception()) {
+                PyErr_SetString(PyExc_SystemError, "__pyx_delegrate_to_exception_handlers called without a C++ exception");
+                return;
+            }
+            bool handled = (__pyx_call_exception_handler(std::forward<HandlerTs>(handlers)) || ... );
+            if (!handled)
+                throw;
+        }
+
+        #elif __cplusplus >= 201103L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201103L)
+
+        inline bool __pyx_call_exception_handler_recursive() {
+            return false;
+        }
+
+        template <typename ExceptionT, typename ...HandlerTs>
+        bool __pyx_call_exception_handler_recursive(void (*first_handler)(ExceptionT&), HandlerTs&& ...handlers);
+
+        template <typename ...HandlerTs>
+        bool __pyx_call_exception_handler_recursive(void (*first_handler)(), HandlerTs&& ...handlers) {
+            try {
+                throw;
+            } catch (...) {
+                first_handler();
+                if (static_cast<bool>(PyErr_Occurred())) return true;
+            }
+            return __pyx_call_exception_handler_recursive(std::forward<HandlerTs>(handlers)...);
+        }
+
+        template <typename ExceptionT, typename ...HandlerTs>
+        bool __pyx_call_exception_handler_recursive(void (*first_handler)(ExceptionT&), HandlerTs&& ...handlers) {
+            try {
+                throw;
+            } catch (ExceptionT& e) {
+                first_handler(e);
+                if (static_cast<bool>(PyErr_Occurred())) return true;
+            } catch (...) {}
+            return __pyx_call_exception_handler_recursive(std::forward<HandlerTs>(handlers)...);
+        }
+
+        template <typename ...HandlerTs>
+        void __pyx_delegate_to_exception_handlers(HandlerTs&& ... handlers) {
+            if (!std::current_exception()) {
+                PyErr_SetString(PyExc_SystemError, "__pyx_delegrate_to_exception_handlers called without a C++ exception");
+                return;
+            }
+            bool handled = __pyx_call_exception_handler_recursive(std::forward<HandlerTs>(handlers)...);
+            if (!handled)
+                throw;
+        }
+        #endif
+    } // anonymous namespace
+    """
+    # Convenience function for writing easy custom C++ exception handlers.
+    # Pass it a collection of C++ function pointers taking either an exception reference, or no arguments.
+    # The function pointers are tried in order. If their argument type matches the current C++ exception (or if
+    # their argument type is empty) then they are called.
+    # If they raise a Python exception then the exception handling finishes and that exception is raised.
+    # Otherwise the next handler will be called.
+    # If no handlers raise a Python exception then the default Cython mechanism will be used.
+    void delegate_to_exception_handlers "__pyx_delegate_to_exception_handlers"(...) except+*

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

Cython/Includes/libcpp/list.pxd

@@ -0,0 +1,117 @@
+cdef extern from "<list>" namespace "std" nogil:
+    cdef cppclass 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 const_iterator
+        cppclass iterator:
+            iterator() except +
+            iterator(iterator&) except +
+            value_type& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator++(int)
+            iterator operator--(int)
+            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)
+            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)
+            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)
+            bint operator==(reverse_iterator)
+            bint operator==(const_reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator!=(const_reverse_iterator)
+
+        list() except +
+        list(list&) except +
+        list(size_t, T&) except +
+        #list operator=(list&)
+        bint operator==(list&, list&)
+        bint operator!=(list&, list&)
+        bint operator<(list&, list&)
+        bint operator>(list&, list&)
+        bint operator<=(list&, list&)
+        bint operator>=(list&, list&)
+        void assign(size_t, 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)
+        iterator erase(iterator, iterator)
+        T& front()
+        iterator insert(iterator, T&)
+        void insert(iterator, size_t, T&)
+        size_t max_size()
+        void merge(list&) except +
+        #void merge(list&, BinPred)
+        void pop_back()
+        void pop_front()
+        void push_back(T&) except +
+        void push_front(T&) except +
+        reverse_iterator rbegin()
+        const_reverse_iterator const_rbegin "rbegin"()
+        const_reverse_iterator crbegin()
+        void remove(T&) except +
+        #void remove_if(UnPred)
+        reverse_iterator rend()
+        const_reverse_iterator const_rend "rend"()
+        const_reverse_iterator crend()
+        void resize(size_t, T&) except +
+        void reverse()
+        size_t size()
+        void sort() except +
+        #void sort(BinPred)
+        void splice(iterator, list&)
+        void splice(iterator, list&, iterator)
+        void splice(iterator, list&, iterator, iterator)
+        void swap(list&)
+        void unique()
+        #void unique(BinPred)