Cython 3.1.0__py3-none-any.whl

Cython/Utility/Lock.c

@@ -0,0 +1,136 @@
+////////////////////// PyThreadTypeLock.proto //////////
+//@proto_block: utility_code_proto_before_types
+
+// This lock type always uses PyThread_type_lock. The main reason
+// to use it is if you are using the Limited API and want to
+// share locks between modules.
+
+#define __Pyx_Locks_PyThreadTypeLock PyThread_type_lock
+#define __Pyx_Locks_PyThreadTypeLock_DECL NULL
+#define __Pyx_Locks_PyThreadTypeLock_Init(l) l = PyThread_allocate_lock()
+#define __Pyx_Locks_PyThreadTypeLock_Delete(l) PyThread_free_lock(l)
+#define __Pyx_Locks_PyThreadTypeLock_LockNogil(l) (void)PyThread_acquire_lock(l, WAIT_LOCK)
+#define __Pyx_Locks_PyThreadTypeLock_Unlock(l) PyThread_release_lock(l)
+static void __Pyx__Locks_PyThreadTypeLock_Lock(__Pyx_Locks_PyThreadTypeLock lock); /* proto */
+static void __Pyx__Locks_PyThreadTypeLock_LockGil(__Pyx_Locks_PyThreadTypeLock lock); /* proto */
+// CYTHON_INLINE because these may be unused
+static CYTHON_INLINE void __Pyx_Locks_PyThreadTypeLock_Lock(__Pyx_Locks_PyThreadTypeLock lock) {
+    __Pyx__Locks_PyThreadTypeLock_Lock(lock);
+}
+static CYTHON_INLINE void __Pyx_Locks_PyThreadTypeLock_LockGil(__Pyx_Locks_PyThreadTypeLock lock) {
+    __Pyx__Locks_PyThreadTypeLock_LockGil(lock);
+}
+
+////////////////////// PyThreadTypeLock ////////////////
+
+static void __Pyx__Locks_PyThreadTypeLock_LockGil_slow_spin(__Pyx_Locks_PyThreadTypeLock lock) {
+    while (1) {
+        // If we've been spinning for a while take a slower path, where
+        // we release the GIL, get the lock, release the lock, reacquire the GIL
+        // and then hope the lock is still available when we try to reacquire it.
+        Py_BEGIN_ALLOW_THREADS
+        (void)PyThread_acquire_lock(lock, WAIT_LOCK);
+        PyThread_release_lock(lock);
+        Py_END_ALLOW_THREADS
+        if (likely(PyThread_acquire_lock_timed(lock, 0, 0) == PY_LOCK_ACQUIRED)) {
+            // All good - we got the lock
+            return;
+        }
+    }
+}
+
+static void __Pyx__Locks_PyThreadTypeLock_LockGil_quick_spin(__Pyx_Locks_PyThreadTypeLock lock) {
+    for (int spin_count=0; spin_count<100; ++spin_count) {
+        // Release and re-acquire the GIL, try to get the lock again.
+        Py_BEGIN_ALLOW_THREADS
+        Py_END_ALLOW_THREADS
+        if (likely(PyThread_acquire_lock_timed(lock, 0, 0) == PY_LOCK_ACQUIRED)) {
+            // All good - we got the lock
+            return;
+        }
+    }
+    __Pyx__Locks_PyThreadTypeLock_LockGil_slow_spin(lock);
+}
+
+static CYTHON_INLINE void __Pyx__Locks_PyThreadTypeLock_LockGil(__Pyx_Locks_PyThreadTypeLock lock) {
+    if (likely(PyThread_acquire_lock_timed(lock, 0, 0) == PY_LOCK_ACQUIRED)) {
+        // All good - we got the lock
+        return;
+    }
+    __Pyx__Locks_PyThreadTypeLock_LockGil_quick_spin(lock);
+}
+
+static void __Pyx__Locks_PyThreadTypeLock_Lock(__Pyx_Locks_PyThreadTypeLock lock) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    // We can't tell if we have the GIL. Therefore make sure we do have it
+    // and then restore whatever state was there before.
+    PyGILState_STATE state = PyGILState_Ensure();
+    __Pyx_Locks_PyThreadTypeLock_LockNogil(lock);
+    PyGILState_Release(state);
+#else
+    if (PyGILState_Check()) {
+        __Pyx_Locks_PyThreadTypeLock_LockGil(lock);
+    } else {
+        __Pyx_Locks_PyThreadTypeLock_LockNogil(lock);
+    }
+#endif
+}
+
+////////////////////// PyMutex.proto ////////////////////
+//@proto_block: utility_code_proto_before_types
+//@requires: PyThreadTypeLock
+
+// We support two implementations - a Py3.13+ version using PyMutex and
+// an older version using PyThread_type_lock.
+// In principle it'd be possible to also use things like c++ std::mutex
+// (in the absence of PyMutex). I've decided against this for ABI reasons.
+
+// With the Limited API There is an ABI problem - if a lock is ever
+// shared between two modules then they must agree on the definition,
+// and so Limited API sharing with regular API will disagree.
+
+// Therefore I explicitly ban Limited API modules from using
+// CythonLockType in a public way. However, they can use
+// CythonCompatibleLockType which will always be PyThread_type_lock.
+
+#if PY_VERSION_HEX > 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API
+#define __Pyx_Locks_PyMutex PyMutex
+#define __Pyx_Locks_PyMutex_DECL {0}
+#define __Pyx_Locks_PyMutex_Init(l) (void)(l)
+#define __Pyx_Locks_PyMutex_Delete(l) (void)(l)
+// Py_Mutex takes care of all GIL handling itself
+#define __Pyx_Locks_PyMutex_Lock(l) PyMutex_Lock(&l)
+#define __Pyx_Locks_PyMutex_Unlock(l) PyMutex_Unlock(&l)
+#define __Pyx_Locks_PyMutex_LockGil(l) PyMutex_Lock(&l)
+#define  __Pyx_Locks_PyMutex_LockNogil(l) PyMutex_Lock(&l)
+
+#else
+
+#define __Pyx_Locks_PyMutex __Pyx_Locks_PyThreadTypeLock
+#define __Pyx_Locks_PyMutex_DECL __Pyx_Locks_PyThreadTypeLock_DECL
+#define __Pyx_Locks_PyMutex_Init(l) __Pyx_Locks_PyThreadTypeLock_Init(l)
+#define __Pyx_Locks_PyMutex_Delete(l) __Pyx_Locks_PyThreadTypeLock_Delete(l)
+#define __Pyx_Locks_PyMutex_Lock(l) __Pyx_Locks_PyThreadTypeLock_Lock(l)
+#define __Pyx_Locks_PyMutex_Unlock(l) __Pyx_Locks_PyThreadTypeLock_Unlock(l)
+#define __Pyx_Locks_PyMutex_LockGil(l) __Pyx_Locks_PyThreadTypeLock_LockGil(l)
+#define __Pyx_Locks_PyMutex_LockNogil(l) __Pyx_Locks_PyThreadTypeLock_LockNogil(l)
+
+#endif
+
+//////////////////////////// CythonPyMutexPublicCheck ///////////////////////////////////
+
+#ifndef CYTHON_UNSAFE_IGNORE_PYMUTEX_ABI_COMPATIBILITY
+#define CYTHON_UNSAFE_IGNORE_PYMUTEX_ABI_COMPATIBILITY 0
+#endif
+
+/* CYTHON_UNSAFE_IGNORE_PYMUTEX_ABI_COMPATIBILITY is left for an advanced user who
+ * wants to disable this error.  However, please don't complain to us when your code
+ * breaks.  Whatever you do, the Limited API version always uses the "compatible" lock
+ * type anyway, so you're only saving yourself a few extra characters typing.
+ */
+#if CYTHON_COMPILING_IN_LIMITED_API && !CYTHON_UNSAFE_IGNORE_PYMUTEX_ABI_COMPATIBILITY
+#error cython.pymutex is shared between multiple modules in the Limited API.\
+ This is intentionally disabled because it is not possible for regular API and Limited API\
+ modules to be compatible with each other.  Use cython.pythread_type_lock for a safe\
+ alternative lock type instead.
+#endif

Cython/Utility/MemoryView.pxd

@@ -0,0 +1,187 @@
+# from cpython cimport ...
+
+cimport cython
+cdef extern from "Python.h":
+    ctypedef struct PyObject
+    ctypedef void *PyThread_type_lock
+
+cdef extern from *:
+    ctypedef struct {{memviewslice_name}}:
+        pass
+
+    ctypedef struct __pyx_buffer "Py_buffer":
+        PyObject *obj
+
+    ctypedef struct __Pyx_TypeInfo:
+        pass
+
+    cdef struct __pyx_memoryview "__pyx_memoryview_obj":
+        Py_buffer view
+        PyObject *obj
+        const __Pyx_TypeInfo *typeinfo
+
+    ctypedef int __pyx_atomic_int_type
+
+    {{memviewslice_name}} slice_copy_contig "__pyx_memoryview_copy_new_contig"(
+                                 {{memviewslice_name}} *from_mvs,
+                                 char *mode, int ndim,
+                                 size_t sizeof_dtype, int contig_flag,
+                                 bint dtype_is_object) except * nogil
+    bint slice_is_contig "__pyx_memviewslice_is_contig" (
+                            {{memviewslice_name}} mvs, char order, int ndim) nogil
+    bint slices_overlap "__pyx_slices_overlap" ({{memviewslice_name}} *slice1,
+                                                {{memviewslice_name}} *slice2,
+                                                int ndim, size_t itemsize) nogil
+
+@cname("__pyx_array")
+cdef class array:
+
+    cdef:
+        char *data
+        Py_ssize_t len
+        char *format
+        int ndim
+        Py_ssize_t *_shape
+        Py_ssize_t *_strides
+        Py_ssize_t itemsize
+        unicode mode  # FIXME: this should have been a simple 'char'
+        bytes _format
+        void (*callback_free_data)(void *data) noexcept
+        # cdef object _memview
+        cdef bint free_data
+        cdef bint dtype_is_object
+
+    @cname('get_memview')
+    cdef get_memview(self)
+
+@cname("__pyx_array_allocate_buffer")
+cdef int _allocate_buffer(array self) except -1
+
+@cname("__pyx_array_new")
+cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, const char *c_mode, char *buf)
+
+@cname('__pyx_memoryview')
+cdef class memoryview:
+
+    cdef object obj
+    cdef object _size
+    cdef object _array_interface
+    cdef PyThread_type_lock lock
+    cdef __pyx_atomic_int_type acquisition_count
+    cdef Py_buffer view
+    cdef int flags
+    cdef bint dtype_is_object
+    cdef const __Pyx_TypeInfo *typeinfo
+
+    cdef char *get_item_pointer(memoryview self, object index) except NULL
+    cdef is_slice(self, obj)
+    cdef setitem_slice_assignment(self, dst, src)
+    cdef setitem_slice_assign_scalar(self, memoryview dst, value)
+    cdef setitem_indexed(self, index, value)
+    cdef convert_item_to_object(self, char *itemp)
+    cdef assign_item_from_object(self, char *itemp, object value)
+    cdef _get_base(self)
+
+@cname('__pyx_memoryview_new')
+cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, const __Pyx_TypeInfo *typeinfo)
+
+@cname('__pyx_memoryview_check')
+cdef inline bint memoryview_check(object o) noexcept:
+    return isinstance(o, memoryview)
+
+@cname('__pyx_memview_slice')
+cdef memoryview memview_slice(memoryview memview, object indices)
+
+@cname('__pyx_memoryview_slice_memviewslice')
+cdef int slice_memviewslice(
+        {{memviewslice_name}} *dst,
+        Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset,
+        int dim, int new_ndim, int *suboffset_dim,
+        Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step,
+        int have_start, int have_stop, int have_step,
+        bint is_slice) except -1 nogil
+
+@cname('__pyx_pybuffer_index')
+cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index,
+                          Py_ssize_t dim) except NULL
+
+@cname('__pyx_memslice_transpose')
+cdef int transpose_memslice({{memviewslice_name}} *memslice) except -1 nogil
+
+@cname('__pyx_memoryview_fromslice')
+cdef memoryview_fromslice({{memviewslice_name}} memviewslice,
+                          int ndim,
+                          object (*to_object_func)(char *),
+                          int (*to_dtype_func)(char *, object) except 0,
+                          bint dtype_is_object)
+
+@cname('__pyx_memoryview_get_slice_from_memoryview')
+cdef {{memviewslice_name}} *get_slice_from_memview(memoryview memview,
+                                                {{memviewslice_name}} *mslice) except NULL
+
+@cname('__pyx_memoryview_slice_copy')
+cdef void slice_copy(memoryview memview, {{memviewslice_name}} *dst) noexcept
+
+@cname('__pyx_memoryview_copy_object')
+cdef memoryview_copy(memoryview memview)
+
+@cname('__pyx_memoryview_copy_object_from_slice')
+cdef memoryview_copy_from_slice(memoryview memview, {{memviewslice_name}} *memviewslice)
+
+@cname('__pyx_get_best_slice_order')
+cdef char get_best_order({{memviewslice_name}} *mslice, int ndim) noexcept nogil
+
+@cname('__pyx_memoryview_slice_get_size')
+cdef Py_ssize_t slice_get_size({{memviewslice_name}} *src, int ndim) noexcept nogil
+
+@cname('__pyx_fill_contig_strides_array')
+cdef Py_ssize_t fill_contig_strides_array(
+                Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride,
+                int ndim, char order) noexcept nogil
+
+@cname('__pyx_memoryview_copy_data_to_temp')
+cdef void *copy_data_to_temp({{memviewslice_name}} *src,
+                             {{memviewslice_name}} *tmpslice,
+                             char order,
+                             int ndim) except NULL nogil
+
+@cname('__pyx_memoryview_err_extents')
+cdef int _err_extents(int i, Py_ssize_t extent1,
+                             Py_ssize_t extent2) except -1 with gil
+
+@cname('__pyx_memoryview_err_dim')
+cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil
+
+@cname('__pyx_memoryview_err')
+cdef int _err(PyObject *error, str msg) except -1 with gil
+
+@cname('__pyx_memoryview_err_no_memory')
+cdef int _err_no_memory() except -1 with gil
+
+@cname('__pyx_memoryview_copy_contents')
+cdef int memoryview_copy_contents({{memviewslice_name}} src,
+                                  {{memviewslice_name}} dst,
+                                  int src_ndim, int dst_ndim,
+                                  bint dtype_is_object) except -1 nogil
+
+@cname('__pyx_memoryview_broadcast_leading')
+cdef void broadcast_leading({{memviewslice_name}} *mslice,
+                            int ndim,
+                            int ndim_other) noexcept nogil
+
+@cname('__pyx_memoryview_refcount_copying')
+cdef void refcount_copying({{memviewslice_name}} *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil
+
+@cname('__pyx_memoryview_refcount_objects_in_slice')
+cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape,
+                                    Py_ssize_t *strides, int ndim, bint inc) noexcept
+
+@cname('__pyx_memoryview_slice_assign_scalar')
+cdef void slice_assign_scalar({{memviewslice_name}} *dst, int ndim,
+                              size_t itemsize, void *item,
+                              bint dtype_is_object) noexcept nogil
+
+@cname('__pyx_memoryview__slice_assign_scalar')
+cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape,
+                              Py_ssize_t *strides, int ndim,
+                              size_t itemsize, void *item) noexcept nogil