Cython 3.2.0__cp39-abi3-win32.whl

Cython/Includes/cpython/time.pxd

@@ -0,0 +1,129 @@
+"""
+Cython implementation of (parts of) the standard library time module.
+
+Note: On implementations that lack a C-API for monotonic/perfcounter clocks
+(like PyPy), the fallback code uses the system clock which may return absolute
+time values from a different value range, differing from those provided by
+Python's "time" module.
+"""
+
+from libc.stdint cimport int64_t
+from cpython.exc cimport PyErr_SetFromErrno
+
+cdef extern from *:
+    """
+    #if PY_VERSION_HEX >= 0x030d00b1 || defined(PyTime_t)
+        #define __Pyx_PyTime_t PyTime_t
+    #else
+        #define __Pyx_PyTime_t _PyTime_t
+    #endif
+
+    #if PY_VERSION_HEX >= 0x030d00b1 || defined(PyTime_TimeRaw)
+        static CYTHON_INLINE __Pyx_PyTime_t __Pyx_PyTime_TimeRaw(void) {
+            __Pyx_PyTime_t tic;
+            (void) PyTime_TimeRaw(&tic);
+            return tic;
+        }
+    #else
+        #define __Pyx_PyTime_TimeRaw()  _PyTime_GetSystemClock()
+    #endif
+
+    #if PY_VERSION_HEX >= 0x030d00b1 || defined(PyTime_MonotonicRaw)
+        static CYTHON_INLINE __Pyx_PyTime_t __Pyx_PyTime_MonotonicRaw(void) {
+            __Pyx_PyTime_t tic;
+            (void) PyTime_MonotonicRaw(&tic);
+            return tic;
+        }
+    #elif CYTHON_COMPILING_IN_PYPY && !defined(_PyTime_GetMonotonicClock)
+        #define __Pyx_PyTime_MonotonicRaw()  _PyTime_GetSystemClock()
+    #else
+        #define __Pyx_PyTime_MonotonicRaw()  _PyTime_GetMonotonicClock()
+    #endif
+
+    #if PY_VERSION_HEX >= 0x030d00b1 || defined(PyTime_PerfCounterRaw)
+        static CYTHON_INLINE __Pyx_PyTime_t __Pyx_PyTime_PerfCounterRaw(void) {
+            __Pyx_PyTime_t tic;
+            (void) PyTime_PerfCounterRaw(&tic);
+            return tic;
+        }
+    #elif CYTHON_COMPILING_IN_PYPY && !defined(_PyTime_GetPerfCounter)
+        #define __Pyx_PyTime_PerfCounterRaw()  __Pyx_PyTime_MonotonicRaw()
+    #else
+        #define __Pyx_PyTime_PerfCounterRaw()  _PyTime_GetPerfCounter()
+    #endif
+
+    #if PY_VERSION_HEX >= 0x030d00b1 || defined(PyTime_AsSecondsDouble)
+        #define __Pyx_PyTime_AsSecondsDouble(t)  PyTime_AsSecondsDouble(t)
+    #else
+        #define __Pyx_PyTime_AsSecondsDouble(t)  _PyTime_AsSecondsDouble(t)
+    #endif
+    """
+    ctypedef int64_t PyTime_t "__Pyx_PyTime_t"
+
+    ctypedef PyTime_t _PyTime_t "__Pyx_PyTime_t"  # legacy, use "PyTime_t" instead
+    PyTime_t PyTime_TimeUnchecked "__Pyx_PyTime_TimeRaw" () noexcept nogil  # legacy, use "PyTime_TimeRaw" instead
+
+    PyTime_t PyTime_TimeRaw "__Pyx_PyTime_TimeRaw" () noexcept nogil
+    PyTime_t PyTime_MonotonicRaw "__Pyx_PyTime_MonotonicRaw" () noexcept nogil
+    PyTime_t PyTime_PerfCounterRaw "__Pyx_PyTime_PerfCounterRaw" () noexcept nogil
+    double PyTime_AsSecondsDouble "__Pyx_PyTime_AsSecondsDouble" (PyTime_t t) noexcept nogil
+
+
+from libc.time cimport (
+    tm,
+    time_t,
+    localtime as libc_localtime,
+)
+
+
+cdef inline double time() noexcept nogil:
+    cdef PyTime_t tic = PyTime_TimeRaw()
+    return PyTime_AsSecondsDouble(tic)
+
+
+cdef inline int64_t time_ns() noexcept nogil:
+    return <int64_t> PyTime_TimeRaw()
+
+
+cdef inline double perf_counter() noexcept nogil:
+    cdef PyTime_t tic = PyTime_PerfCounterRaw()
+    return PyTime_AsSecondsDouble(tic)
+
+
+cdef inline int64_t perf_counter_ns() noexcept nogil:
+    return <int64_t> PyTime_PerfCounterRaw()
+
+
+cdef inline double monotonic() noexcept nogil:
+    cdef PyTime_t tic = PyTime_MonotonicRaw()
+    return PyTime_AsSecondsDouble(tic)
+
+
+cdef inline int64_t monotonic_ns() noexcept nogil:
+    return <int64_t> PyTime_MonotonicRaw()
+
+
+cdef inline int _raise_from_errno() except -1 with gil:
+    PyErr_SetFromErrno(RuntimeError)
+    return <int> -1  # Let the C compiler know that this function always raises.
+
+
+cdef inline tm localtime() except * nogil:
+    """
+    Analogue to the stdlib time.localtime.  The returned struct
+    has some entries that the stdlib version does not: tm_gmtoff, tm_zone
+    """
+    cdef:
+        time_t tic = <time_t>time()
+        tm* result
+
+    result = libc_localtime(&tic)
+    if result is NULL:
+        _raise_from_errno()
+    # Fix 0-based date values (and the 1900-based year).
+    # See tmtotuple() in https://github.com/python/cpython/blob/master/Modules/timemodule.c
+    result.tm_year += 1900
+    result.tm_mon += 1
+    result.tm_wday = <int> ((result.tm_wday + 6) % 7)
+    result.tm_yday += 1
+    return result[0]

Cython/Includes/cpython/tuple.pxd

@@ -0,0 +1,72 @@
+from .object cimport PyObject
+
+cdef extern from "Python.h":
+
+    ############################################################################
+    # Tuples
+    ############################################################################
+
+    bint PyTuple_Check(object  p)
+    # Return true if p is a tuple object or an instance of a subtype
+    # of the tuple type.
+
+    bint PyTuple_CheckExact(object  p)
+    # Return true if p is a tuple object, but not an instance of a subtype of the tuple type.
+
+    tuple PyTuple_New(Py_ssize_t len)
+    # Return value: New reference.
+    # Return a new tuple object of size len, or NULL on failure.
+
+    tuple PyTuple_Pack(Py_ssize_t n, ...)
+    # Return value: New reference.
+    # Return a new tuple object of size n, or NULL on failure. The
+    # tuple values are initialized to the subsequent n C arguments
+    # pointing to Python objects. "PyTuple_Pack(2, a, b)" is
+    # equivalent to "Py_BuildValue("(OO)", a, b)".
+
+    Py_ssize_t PyTuple_Size(object  p) except -1
+    # Take a pointer to a tuple object, and return the size of that tuple.
+
+    Py_ssize_t PyTuple_GET_SIZE(object  p)
+    # Return the size of the tuple p, which must be non-NULL and point
+    # to a tuple; no error checking is performed.
+
+    PyObject* PyTuple_GetItem(object  p, Py_ssize_t pos) except NULL
+    # Return value: Borrowed reference.
+    # Return the object at position pos in the tuple pointed to by
+    # p. If pos is out of bounds, return NULL and sets an IndexError
+    # exception.
+
+    PyObject* PyTuple_GET_ITEM(object  p, Py_ssize_t pos)
+    # Return value: Borrowed reference.
+    # Like PyTuple_GetItem(), but does no checking of its arguments.
+
+    tuple PyTuple_GetSlice(object  p, Py_ssize_t low, Py_ssize_t high)
+    # Return value: New reference.
+    # Take a slice of the tuple pointed to by p from low to high and return it as a new tuple.
+
+    int PyTuple_SetItem(object  p, Py_ssize_t pos, object  o) except -1
+    # Insert a reference to object o at position pos of the tuple
+    # pointed to by p. Return 0 on success.
+    #
+    # WARNING: This function _steals_ a reference to o.
+
+    void PyTuple_SET_ITEM(object  p, Py_ssize_t pos, object  o)
+    # Like PyTuple_SetItem(), but does no error checking, and should
+    # only be used to fill in brand new tuples.
+    #
+    # WARNING: This function _steals_ a reference to o.
+
+    int _PyTuple_Resize(PyObject **p, Py_ssize_t newsize) except -1
+    # Can be used to resize a tuple. newsize will be the new length of
+    # the tuple. Because tuples are supposed to be immutable, this
+    # should only be used if there is only one reference to the
+    # object. Do not use this if the tuple may already be known to
+    # some other part of the code. The tuple will always grow or
+    # shrink at the end. Think of this as destroying the old tuple and
+    # creating a new one, only more efficiently. Returns 0 on
+    # success. Client code should never assume that the resulting
+    # value of *p will be the same as before calling this function. If
+    # the object referenced by *p is replaced, the original *p is
+    # destroyed. On failure, returns -1 and sets *p to NULL, and
+    # raises MemoryError or SystemError.

Cython/Includes/cpython/type.pxd

@@ -0,0 +1,53 @@
+
+cdef extern from "Python.h":
+    # The C structure of the objects used to describe built-in types.
+
+    ############################################################################
+    # 7.1.1 Type Objects
+    ############################################################################
+
+    ctypedef class __builtin__.type [object PyTypeObject]:
+        pass
+
+    # PyObject* PyType_Type
+    # This is the type object for type objects; it is the same object
+    # as type and types.TypeType in the Python layer.
+
+    bint PyType_Check(object o)
+    # Return true if the object o is a type object, including
+    # instances of types derived from the standard type object. Return
+    # false in all other cases.
+
+    bint PyType_CheckExact(object o)
+    # Return true if the object o is a type object, but not a subtype
+    # of the standard type object. Return false in all other
+    # cases.
+
+    void PyType_Modified(type type)
+    # Invalidate the internal lookup cache for the type and all of its
+    # subtypes. This function must be called after any manual modification
+    # of the attributes or base classes of the type.
+
+    bint PyType_HasFeature(object o, int feature)
+    # Return true if the type object o sets the feature feature. Type
+    # features are denoted by single bit flags.
+
+    bint PyType_IS_GC(object o)
+    # Return true if the type object includes support for the cycle
+    # detector; this tests the type flag Py_TPFLAGS_HAVE_GC.
+
+    bint PyType_IsSubtype(type a, type b)
+    # Return true if a is a subtype of b.
+
+    object PyType_GenericAlloc(object type, Py_ssize_t nitems)
+    # Return value: New reference.
+
+    object PyType_GenericNew(type type, object args, object kwds)
+    # Return value: New reference.
+
+    bint PyType_Ready(type type) except -1
+    # Finalize a type object. This should be called on all type
+    # objects to finish their initialization. This function is
+    # responsible for adding inherited slots from a type's base
+    # class. Return 0 on success, or return -1 and sets an exception
+    # on error.