Cython 3.2.0__cp39-abi3-win32.whl

Cython/Includes/libcpp/queue.pxd

@@ -0,0 +1,25 @@
+cdef extern from "<queue>" namespace "std" nogil:
+    cdef cppclass queue[T]:
+        queue() except +
+        queue(queue&) except +
+        #queue(Container&)
+        T& back()
+        bint empty()
+        T& front()
+        void pop()
+        void push(T&)
+        size_t size()
+        # C++11 methods
+        void swap(queue&)
+
+    cdef cppclass priority_queue[T]:
+        priority_queue() except +
+        priority_queue(priority_queue&) except +
+        #priority_queue(Container&)
+        bint empty()
+        void pop()
+        void push(T&)
+        size_t size()
+        T& top()
+        # C++11 methods
+        void swap(priority_queue&)

Cython/Includes/libcpp/random.pxd

@@ -0,0 +1,166 @@
+from libc.stdint cimport uint_fast32_t, uint_fast64_t
+
+
+cdef extern from "<random>" namespace "std" nogil:
+    cdef cppclass random_device:
+        ctypedef uint_fast32_t result_type
+        random_device() except +
+        result_type operator()() except +
+
+    cdef cppclass mt19937:
+        ctypedef uint_fast32_t result_type
+        mt19937() except +
+        mt19937(result_type seed) except +
+        result_type operator()() except +
+        result_type min() except +
+        result_type max() except +
+        void discard(size_t z) except +
+        void seed(result_type seed) except +
+
+    cdef cppclass mt19937_64:
+        ctypedef uint_fast64_t result_type
+
+        mt19937_64() except +
+        mt19937_64(result_type seed) except +
+        result_type operator()() except +
+        result_type min() except +
+        result_type max() except +
+        void discard(size_t z) except +
+        void seed(result_type seed) except +
+
+    cdef cppclass uniform_int_distribution[T]:
+        ctypedef T result_type
+        uniform_int_distribution() except +
+        uniform_int_distribution(T, T) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass uniform_real_distribution[T]:
+        ctypedef T result_type
+        uniform_real_distribution() except +
+        uniform_real_distribution(T, T) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass bernoulli_distribution:
+        ctypedef bint result_type
+        bernoulli_distribution() except +
+        bernoulli_distribution(double) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass binomial_distribution[T]:
+        ctypedef T result_type
+        binomial_distribution() except +
+        binomial_distribution(T, double) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass geometric_distribution[T]:
+        ctypedef T result_type
+        geometric_distribution() except +
+        geometric_distribution(double) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+
+    cdef cppclass negative_binomial_distribution[T]:
+        ctypedef T result_type
+        negative_binomial_distribution() except +
+        negative_binomial_distribution(T, double) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass poisson_distribution[T]:
+        ctypedef T result_type
+        poisson_distribution() except +
+        poisson_distribution(double) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass exponential_distribution[T]:
+        ctypedef T result_type
+        exponential_distribution() except +
+        exponential_distribution(result_type) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass gamma_distribution[T]:
+        ctypedef T result_type
+        gamma_distribution() except +
+        gamma_distribution(result_type, result_type) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass weibull_distribution[T]:
+        ctypedef T result_type
+        weibull_distribution() except +
+        weibull_distribution(result_type, result_type) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass extreme_value_distribution[T]:
+        ctypedef T result_type
+        extreme_value_distribution() except +
+        extreme_value_distribution(result_type, result_type) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass normal_distribution[T]:
+        ctypedef T result_type
+        normal_distribution() except +
+        normal_distribution(result_type, result_type) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass lognormal_distribution[T]:
+        ctypedef T result_type
+        lognormal_distribution() except +
+        lognormal_distribution(result_type, result_type) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass chi_squared_distribution[T]:
+        ctypedef T result_type
+        chi_squared_distribution() except +
+        chi_squared_distribution(result_type) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass cauchy_distribution[T]:
+        ctypedef T result_type
+        cauchy_distribution() except +
+        cauchy_distribution(result_type, result_type) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass fisher_f_distribution[T]:
+        ctypedef T result_type
+        fisher_f_distribution() except +
+        fisher_f_distribution(result_type, result_type) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +
+
+    cdef cppclass student_t_distribution[T]:
+        ctypedef T result_type
+        student_t_distribution() except +
+        student_t_distribution(result_type) except +
+        result_type operator()[Generator](Generator&) except +
+        result_type min() except +
+        result_type max() except +

Cython/Includes/libcpp/semaphore.pxd

@@ -0,0 +1,43 @@
+from libcpp cimport bool
+
+cdef extern from "<semaphore>" namespace "std" nogil:
+    # Notes on templating:
+    # Cython doesn't currently support non-class template types so it's
+    # declared here as a class template.
+    # counting_semaphore has a default max value anyway, so you typically
+    # don't need to use the templates. If you do though, then there's a
+    # few tricks - e.g. you can define a class with a cname of "3" for
+    # example.
+
+    # Note on thread-safety:
+    # You should use these classes without the GIL. It's very easy
+    # to deadlock with the GIL, and we're assuming that anyone going
+    # low enough level to be using semaphores doesn't want the overhead
+    # of Cython handling GIL safety.
+    cdef cppclass counting_semaphore[LeastMaxValue=*]:
+        counting_semaphore(ptrdiff_t desired)
+
+        void release() except+
+        void release(ptrdiff_t update) except+
+        void acquire() except+
+        bool try_acquire()
+
+        # unfortunately, we don't currently define chrono types
+        bool try_acquire_for[T](T duration) except+
+        bool try_acquire_until[T](T timepoint) except+
+
+        ptrdiff_t max()
+
+    cdef cppclass binary_semaphore:
+        binary_semaphore(ptrdiff_t desired)
+
+        void release() except+
+        void release(ptrdiff_t update) except+
+        void acquire() except+
+        bool try_acquire()
+
+        # unfortunately, we don't currently define chrono types
+        bool try_acquire_for[T](T timepoint) except+
+        bool try_acquire_until[T](T duration) except+
+
+        ptrdiff_t max()

Cython/Includes/libcpp/set.pxd

@@ -0,0 +1,228 @@
+from .utility cimport pair
+
+cdef extern from "<set>" namespace "std" nogil:
+    cdef cppclass set[T]:
+        ctypedef T 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
+
+        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)
+
+        set() except +
+        set(set&) except +
+        #set(key_compare&)
+        #set& operator=(set&)
+        bint operator==(set&, set&)
+        bint operator!=(set&, set&)
+        bint operator<(set&, set&)
+        bint operator>(set&, set&)
+        bint operator<=(set&, set&)
+        bint operator>=(set&, set&)
+        iterator begin()
+        const_iterator const_begin "begin"()
+        const_iterator cbegin()
+        void clear()
+        size_t count(const T&)
+        bint empty()
+        iterator end()
+        const_iterator const_end "end"()
+        const_iterator cend()
+        pair[iterator, iterator] equal_range(const T&)
+        pair[const_iterator, const_iterator] const_equal_range "equal_range"(const T&)
+        iterator erase(iterator)
+        iterator const_erase "erase"(const_iterator)
+        iterator erase(const_iterator, const_iterator)
+        size_t erase(const T&)
+        iterator find(const T&)
+        const_iterator const_find "find"(const T&)
+        pair[iterator, bint] insert(const T&) except +
+        iterator insert(iterator, const T&) except +
+        iterator insert(const_iterator, const T&) except +
+        iterator const_insert "insert"(const_iterator, const T&) except +
+        void insert[InputIt](InputIt, InputIt) except +
+        #key_compare key_comp()
+        iterator lower_bound(const T&)
+        const_iterator const_lower_bound "lower_bound"(const T&)
+        size_t max_size()
+        reverse_iterator rbegin()
+        const_reverse_iterator const_rbegin "rbegin"()
+        const_reverse_iterator crbegin()
+        reverse_iterator rend()
+        const_reverse_iterator const_rend "rend"()
+        const_reverse_iterator crend()
+        size_t size()
+        void swap(set&)
+        iterator upper_bound(const T&)
+        const_iterator const_upper_bound "upper_bound"(const T&)
+        #value_compare value_comp()
+        # C++20
+        bint contains(const T&)
+
+    cdef cppclass multiset[T]:
+        ctypedef T 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
+
+        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)
+
+        multiset() except +
+        multiset(multiset&) except +
+        #multiset(key_compare&)
+        #multiset& operator=(multiset&)
+        bint operator==(multiset&, multiset&)
+        bint operator!=(multiset&, multiset&)
+        bint operator<(multiset&, multiset&)
+        bint operator>(multiset&, multiset&)
+        bint operator<=(multiset&, multiset&)
+        bint operator>=(multiset&, multiset&)
+        iterator begin()
+        const_iterator const_begin "begin"()
+        const_iterator cbegin()
+        void clear()
+        size_t count(const T&)
+        bint empty()
+        iterator end()
+        const_iterator const_end "end"()
+        const_iterator cend()
+        pair[iterator, iterator] equal_range(const T&)
+        pair[const_iterator, const_iterator] const_equal_range "equal_range"(const T&)
+        iterator erase(iterator)
+        iterator const_erase "erase"(const_iterator)
+        iterator erase(const_iterator, const_iterator)
+        size_t erase(const T&)
+        iterator find(const T&)
+        const_iterator const_find "find"(const T&)
+        iterator insert(const T&) except +
+        iterator insert(iterator, const T&) except +
+        iterator const_insert "insert"(const_iterator, const T&) except +
+        void insert[InputIt](InputIt, InputIt) except +
+        #key_compare key_comp()
+        iterator lower_bound(const T&)
+        const_iterator const_lower_bound "lower_bound"(const T&)
+        size_t max_size()
+        reverse_iterator rbegin()
+        const_reverse_iterator const_rbegin "rbegin"()
+        const_reverse_iterator crbegin()
+        reverse_iterator rend()
+        const_reverse_iterator const_rend "rend"()
+        const_reverse_iterator crend()
+        size_t size()
+        void swap(multiset&)
+        iterator upper_bound(const T&)
+        const_iterator const_upper_bound "upper_bound"(const T&)
+        # C++20
+        bint contains(const T&)

Cython/Includes/libcpp/shared_mutex.pxd

@@ -0,0 +1,96 @@
+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()
+
+        # We strongly recommend not calling lock_shared with the GIL held (to avoid deadlocks)
+        # and moderately recommend not calling the timed lock functions with the GIL either.
+        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+
+
+    # We strongly recommend not attempting to acquire a lock via a shared_lock while holding
+    # the GIL. Use py_safe_construct_shared_lock instead.
+    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()
+
+# Just to get our GIL-safe utility code
+cimport libcpp.mutex as _cpp_mutex
+
+cdef extern from *:
+    """
+    namespace {
+        template <typename... LockTs>
+        void __pyx_py_safe_std_lock(LockTs& ...locks);
+
+        template <typename MutexT>
+        std::shared_lock<MutexT> __pyx_py_safe_construct_shared_lock(MutexT &m) {
+            std::shared_lock<MutexT> l(m, std::defer_lock);
+            __pyx_py_safe_std_lock(l);  // in mutex.pxd
+            return l;
+        }
+    }
+    """
+    # Construct a shared_lock while holding the GIL, without deadlock on the GIL
+    shared_lock[MutexT] py_safe_construct_shared_lock "__pyx_py_safe_construct_shared_lock" [MutexT](MutexT& m) except+ nogil

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()