Cython 3.1.0__py3-none-any.whl

Cython/Includes/cpython/bytes.pxd

@@ -0,0 +1,200 @@
+from .object cimport PyObject
+
+cdef extern from "Python.h":
+    ctypedef struct va_list
+
+    ############################################################################
+    # 7.3.1 String Objects
+    ############################################################################
+
+    # These functions raise TypeError when expecting a string
+    # parameter and are called with a non-string parameter.
+    # PyStringObject
+    # This subtype of PyObject represents a Python bytes object.
+    # PyTypeObject PyBytes_Type
+    # This instance of PyTypeObject represents the Python bytes type;
+    # it is the same object as bytes and types.BytesType in the Python
+    # layer.
+
+    bint PyBytes_Check(object o)
+    # Return true if the object o is a string object or an instance of
+    # a subtype of the string type.
+
+    bint PyBytes_CheckExact(object o)
+    # Return true if the object o is a string object, but not an instance of a subtype of the string type.
+
+    bytes PyBytes_FromString(char *v)
+    # Return value: New reference.
+    # Return a new string object with the value v on success, and NULL
+    # on failure. The parameter v must not be NULL; it will not be
+    # checked.
+
+    bytes PyBytes_FromStringAndSize(char *v, Py_ssize_t len)
+    # Return value: New reference.
+    # Return a new string object with the value v and length len on
+    # success, and NULL on failure. If v is NULL, the contents of the
+    # string are uninitialized.
+
+    bytes PyBytes_FromFormat(char *format, ...)
+    # Return value: New reference.
+    # Take a C printf()-style format string and a variable number of
+    # arguments, calculate the size of the resulting Python string and
+    # return a string with the values formatted into it. The variable
+    # arguments must be C types and must correspond exactly to the
+    # format characters in the format string. The following format
+    # characters are allowed:
+    # Format Characters 	Type 	Comment
+    # %% 	n/a 	The literal % character.
+    # %c 	int 	A single character, represented as an C int.
+    # %d 	int 	Exactly equivalent to printf("%d").
+    # %u 	unsigned int 	Exactly equivalent to printf("%u").
+    # %ld 	long 	Exactly equivalent to printf("%ld").
+    # %lu 	unsigned long 	Exactly equivalent to printf("%lu").
+    # %zd 	Py_ssize_t 	Exactly equivalent to printf("%zd").
+    # %zu 	size_t 	Exactly equivalent to printf("%zu").
+    # %i 	int 	Exactly equivalent to printf("%i").
+    # %x 	int 	Exactly equivalent to printf("%x").
+    # %s 	char* 	A null-terminated C character array.
+
+    # %p 	void* 	The hex representation of a C pointer.
+    #    Mostly equivalent to printf("%p") except that it is guaranteed to
+    #    start with the literal 0x regardless of what the platform's printf
+    #    yields.
+    # An unrecognized format character causes all the rest of the
+    # format string to be copied as-is to the result string, and any
+    # extra arguments discarded.
+
+    bytes PyBytes_FromFormatV(char *format, va_list vargs)
+    # Return value: New reference.
+    # Identical to PyBytes_FromFormat() except that it takes exactly two arguments.
+
+    bytes PyBytes_FromObject(object o)
+    # Return value: New reference.
+    # Return the bytes representation of object o that implements the buffer protocol.
+
+    Py_ssize_t PyBytes_Size(object string) except -1
+    # Return the length of the string in string object string.
+
+    Py_ssize_t PyBytes_GET_SIZE(object string)
+    # Macro form of PyBytes_Size() but without error checking.
+
+    char* PyBytes_AsString(object string) except NULL
+    # Return a NUL-terminated representation of the contents of
+    # string. The pointer refers to the internal buffer of string, not
+    # a copy. The data must not be modified in any way, unless the
+    # string was just created using PyBytes_FromStringAndSize(NULL,
+    # size). It must not be deallocated. If string is a Unicode
+    # object, this function computes the default encoding of string
+    # and operates on that. If string is not a string object at all,
+    # PyBytes_AsString() returns NULL and raises TypeError.
+
+    char* PyBytes_AS_STRING(object string)
+    # Macro form of PyBytes_AsString() but without error
+    # checking. Only string objects are supported; no Unicode objects
+    # should be passed.
+
+    int PyBytes_AsStringAndSize(object obj, char **buffer, Py_ssize_t *length) except -1
+    # Return a NULL-terminated representation of the contents of the
+    # object obj through the output variables buffer and length.
+    #
+    # The function accepts both string and Unicode objects as
+    # input. For Unicode objects it returns the default encoded
+    # version of the object. If length is NULL, the resulting buffer
+    # may not contain NUL characters; if it does, the function returns
+    # -1 and a TypeError is raised.
+
+    # The buffer refers to an internal string buffer of obj, not a
+    # copy. The data must not be modified in any way, unless the
+    # string was just created using PyBytes_FromStringAndSize(NULL,
+    # size). It must not be deallocated. If string is a Unicode
+    # object, this function computes the default encoding of string
+    # and operates on that. If string is not a string object at all,
+    # PyBytes_AsStringAndSize() returns -1 and raises TypeError.
+
+    void PyBytes_Concat(PyObject **string, object newpart)
+    # Create a new string object in *string containing the contents of
+    # newpart appended to string; the caller will own the new
+    # reference. The reference to the old value of string will be
+    # stolen. If the new string cannot be created, the old reference
+    # to string will still be discarded and the value of *string will
+    # be set to NULL; the appropriate exception will be set.
+
+    void PyBytes_ConcatAndDel(PyObject **string, object newpart)
+    # Create a new string object in *string containing the contents of
+    # newpart appended to string. This version decrements the
+    # reference count of newpart.
+
+    int _PyBytes_Resize(PyObject **string, Py_ssize_t newsize) except -1
+    # A way to resize a string object even though it is
+    # ``immutable''. Only use this to build up a brand new string
+    # object; don't use this if the string may already be known in
+    # other parts of the code. It is an error to call this function if
+    # the refcount on the input string object is not one. Pass the
+    # address of an existing string object as an lvalue (it may be
+    # written into), and the new size desired. On success, *string
+    # holds the resized string object and 0 is returned; the address
+    # in *string may differ from its input value. If the reallocation
+    # fails, the original string object at *string is deallocated,
+    # *string is set to NULL, a memory exception is set, and -1 is
+    # returned.
+
+    bytes PyBytes_Format(object format, object args)
+    # Return value: New reference.  Return a new string object from
+    # format and args. Analogous to format % args. The args argument
+    # must be a tuple.
+
+    void PyBytes_InternInPlace(PyObject **string)
+    # Intern the argument *string in place. The argument must be the
+    # address of a pointer variable pointing to a Python string
+    # object. If there is an existing interned string that is the same
+    # as *string, it sets *string to it (decrementing the reference
+    # count of the old string object and incrementing the reference
+    # count of the interned string object), otherwise it leaves
+    # *string alone and interns it (incrementing its reference
+    # count). (Clarification: even though there is a lot of talk about
+    # reference counts, think of this function as
+    # reference-count-neutral; you own the object after the call if
+    # and only if you owned it before the call.)
+
+    bytes PyBytes_InternFromString(char *v)
+    # Return value: New reference.
+    # A combination of PyBytes_FromString() and
+    # PyBytes_InternInPlace(), returning either a new string object
+    # that has been interned, or a new (``owned'') reference to an
+    # earlier interned string object with the same value.
+
+    object PyBytes_Decode(char *s, Py_ssize_t size, char *encoding, char *errors)
+    #  Return value: New reference.
+    # Create an object by decoding size bytes of the encoded buffer s
+    # using the codec registered for encoding. encoding and errors
+    # have the same meaning as the parameters of the same name in the
+    # unicode() built-in function. The codec to be used is looked up
+    # using the Python codec registry. Return NULL if an exception was
+    # raised by the codec.
+
+    object PyBytes_AsDecodedObject(object str, char *encoding, char *errors)
+    # Return value: New reference.
+    # Decode a string object by passing it to the codec registered for
+    # encoding and return the result as Python object. encoding and
+    # errors have the same meaning as the parameters of the same name
+    # in the string encode() method. The codec to be used is looked up
+    # using the Python codec registry. Return NULL if an exception was
+    # raised by the codec.
+
+    object PyBytes_Encode(char *s, Py_ssize_t size, char *encoding, char *errors)
+    # Return value: New reference.
+    # Encode the char buffer of the given size by passing it to the
+    # codec registered for encoding and return a Python
+    # object. encoding and errors have the same meaning as the
+    # parameters of the same name in the string encode() method. The
+    # codec to be used is looked up using the Python codec
+    # registry. Return NULL if an exception was raised by the codec.
+
+    object PyBytes_AsEncodedObject(object str, char *encoding, char *errors)
+    # Return value: New reference.
+    # Encode a string object using the codec registered for encoding
+    # and return the result as Python object. encoding and errors have
+    # the same meaning as the parameters of the same name in the
+    # string encode() method. The codec to be used is looked up using
+    # the Python codec registry. Return NULL if an exception was
+    # raised by the codec.

Cython/Includes/cpython/cellobject.pxd

@@ -0,0 +1,35 @@
+from .object cimport PyObject
+
+cdef extern from "Python.h":
+
+    ############################################################################
+    # Cell Objects
+    ############################################################################
+
+    bint PyCell_Check(object ob)
+    # Return true if ob is a cell object; ob must not be NULL.
+
+    object PyCell_New(PyObject* ob)
+    # Return value: New reference.
+    # Create and return a new cell object containing the value ob. The
+    # parameter may be NULL.
+
+    object PyCell_Get(object cell)
+    # Return value: New reference.
+    # Return the contents of the cell object cell.
+
+    object PyCell_GET(object cell)
+    # Return value: Borrowed reference.
+    # Return the contents of the cell object cell, but without checking that
+    # cell is non-NULL and is a cell object.
+
+    int PyCell_Set(object cell, PyObject* value) except? -1
+    # Set the contents of the cell object cell to value. This releases the
+    # reference to any current content of the cell. value may be NULL. cell
+    # must be non-NULL; if it is not a cell object, -1 will be returned. On
+    # success, 0 will be returned.
+
+    void PyCell_SET(object cell, PyObject* value)
+    # Sets the value of the cell object cell to value. No reference counts are
+    # adjusted, and no checks are made for safety; cell must be non-NULL and
+    # must be a cell object.

Cython/Includes/cpython/ceval.pxd

@@ -0,0 +1,8 @@
+
+cdef extern from "Python.h":
+
+    void PyEval_InitThreads()
+        # Initialize and acquire the global interpreter lock.
+
+    int PyEval_ThreadsInitialized()
+        # Returns a non-zero value if PyEval_InitThreads() has been called.

Cython/Includes/cpython/codecs.pxd

@@ -0,0 +1,121 @@
+cdef extern from "Python.h":
+
+    ###########################################################################
+    # Codec registry and support functions
+    ###########################################################################
+
+    int PyCodec_Register(object search_function)
+    # Register a new codec search function.
+
+    # As side effect, this tries to load the encodings package, if not yet
+    # done, to make sure that it is always first in the list of search
+    # functions.
+
+    int PyCodec_KnownEncoding(const char *encoding)
+    # Return 1 or 0 depending on whether there is a registered codec for the
+    # given encoding. This function always succeeds.
+
+    object PyCodec_Encode(object o, const char *encoding, const char *errors)
+    # Return value: New reference.
+    # Generic codec based encoding API.
+
+    # o is passed through the encoder function found for the given encoding
+    # using the error handling method defined by errors. errors may be NULL
+    # to use the default method defined for the codec. Raises a LookupError
+    # if no encoder can be found.
+
+    object PyCodec_Decode(object o, const char *encoding, const char *errors)
+    # Return value: New reference.
+    # Generic codec based decoding API.
+
+    # o is passed through the decoder function found for the given encoding
+    # using the error handling method defined by errors. errors may be NULL
+    # to use the default method defined for the codec. Raises a LookupError
+    # if no encoder can be found.
+
+
+    # Codec lookup API
+
+    # In the following functions, the encoding string is looked up converted
+    # to all lower-case characters, which makes encodings looked up through
+    # this mechanism effectively case-insensitive. If no codec is found, a
+    # KeyError is set and NULL returned.
+
+    object PyCodec_Encoder(const char *encoding)
+    # Return value: New reference.
+    # Get an encoder function for the given encoding.
+
+    object PyCodec_Decoder(const char *encoding)
+    # Return value: New reference.
+    # Get a decoder function for the given encoding.
+
+    object PyCodec_IncrementalEncoder(const char *encoding, const char *errors)
+    # Return value: New reference.
+    # Get an IncrementalEncoder object for the given encoding.
+
+    object PyCodec_IncrementalDecoder(const char *encoding, const char *errors)
+    # Return value: New reference.
+    # Get an IncrementalDecoder object for the given encoding.
+
+    object PyCodec_StreamReader(const char *encoding, object stream, const char *errors)
+    # Return value: New reference.
+    # Get a StreamReader factory function for the given encoding.
+
+    object PyCodec_StreamWriter(const char *encoding, object stream, const char *errors)
+    # Return value: New reference.
+    # Get a StreamWriter factory function for the given encoding.
+
+
+    # Registry API for Unicode encoding error handlers
+
+    int PyCodec_RegisterError(const char *name, object error) except? -1
+    # Register the error handling callback function error under the given
+    # name. This callback function will be called by a codec when it
+    # encounters unencodable characters/undecodable bytes and name is
+    # specified as the error parameter in the call to the encode/decode
+    # function.
+
+    # The callback gets a single argument, an instance of
+    # UnicodeEncodeError, UnicodeDecodeError or UnicodeTranslateError that
+    # holds information about the problematic sequence of characters or bytes
+    # and their offset in the original string (see Unicode Exception Objects
+    # for functions to extract this information). The callback must either
+    # raise the given exception, or return a two-item tuple containing the
+    # replacement for the problematic sequence, and an integer giving the
+    # offset in the original string at which encoding/decoding should be
+    # resumed.
+
+    # Return 0 on success, -1 on error.
+
+    object PyCodec_LookupError(const char *name)
+    # Return value: New reference.
+    # Lookup the error handling callback function registered under name. As a
+    # special case NULL can be passed, in which case the error handling
+    # callback for "strict" will be returned.
+
+    object PyCodec_StrictErrors(object exc)
+    # Return value: Always NULL.
+    # Raise exc as an exception.
+
+    object PyCodec_IgnoreErrors(object exc)
+    # Return value: New reference.
+    # Ignore the unicode error, skipping the faulty input.
+
+    object PyCodec_ReplaceErrors(object exc)
+    # Return value: New reference.
+    # Replace the unicode encode error with "?" or "U+FFFD".
+
+    object PyCodec_XMLCharRefReplaceErrors(object exc)
+    # Return value: New reference.
+    # Replace the unicode encode error with XML character references.
+
+    object PyCodec_BackslashReplaceErrors(object exc)
+    # Return value: New reference.
+    # Replace the unicode encode error with backslash escapes ("\x", "\u"
+    # and "\U").
+
+    object PyCodec_NameReplaceErrors(object exc)
+    # Return value: New reference.
+    # Replace the unicode encode error with "\N{...}" escapes.
+
+    # New in version 3.5.

Cython/Includes/cpython/complex.pxd

@@ -0,0 +1,60 @@
+cimport cython as _cython
+
+cdef extern from "Python.h":
+
+    ctypedef struct Py_complex:
+        double imag
+        double real
+
+    ############################################################################
+    # 7.2.5.2 Complex Numbers as Python Objects
+    ############################################################################
+
+    # PyComplexObject
+    # This subtype of PyObject represents a Python complex number object.
+
+    ctypedef class __builtin__.complex [object PyComplexObject]:
+        cdef Py_complex cval
+
+        # unavailable in limited API
+        @property
+        @_cython.c_compile_guard("!CYTHON_COMPILING_IN_LIMITED_API")
+        cdef inline double real(self) noexcept:
+            return self.cval.real
+
+        # unavailable in limited API
+        @property
+        @_cython.c_compile_guard("!CYTHON_COMPILING_IN_LIMITED_API")
+        cdef inline double imag(self) noexcept:
+            return self.cval.imag
+
+    # PyTypeObject PyComplex_Type
+    # This instance of PyTypeObject represents the Python complex
+    # number type. It is the same object as complex and
+    # types.ComplexType.
+
+    bint PyComplex_Check(object p)
+    # Return true if its argument is a PyComplexObject or a subtype of
+    # PyComplexObject.
+
+    bint PyComplex_CheckExact(object p)
+    # Return true if its argument is a PyComplexObject, but not a subtype of PyComplexObject.
+
+    object PyComplex_FromCComplex(Py_complex v)
+    # Return value: New reference.
+    # Create a new Python complex number object from a C Py_complex value.
+
+    object PyComplex_FromDoubles(double real, double imag)
+    # Return value: New reference.
+    # Return a new PyComplexObject object from real and imag.
+
+    double PyComplex_RealAsDouble(object op) except? -1
+    # Return the real part of op as a C double.
+
+    double PyComplex_ImagAsDouble(object op) except? -1
+    # Return the imaginary part of op as a C double.
+
+    Py_complex PyComplex_AsCComplex(object op)
+    # Return the Py_complex value of the complex number op.
+    #
+    # Returns (-1+0i) in case of an error

Cython/Includes/cpython/contextvars.pxd

@@ -0,0 +1,145 @@
+from cpython.object cimport PyObject
+from cpython.ref cimport Py_XDECREF
+
+cimport cython as _cython
+
+cdef extern from *:
+    # Defining PyContextVar_Get() below to always return the default value for Py<3.7 and PyPy<7.3.6
+    # to make the inline functions sort-of work.
+    """
+    #if (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030600) && !defined(PyContextVar_Get)
+    #define PyContextVar_Get(var, d, v) \
+        ((d) ? \
+            ((void)(var), Py_INCREF(d), (v)[0] = (d), 0) : \
+            ((v)[0] = NULL, 0) \
+        )
+    #endif
+    """
+
+cdef extern from "Python.h":
+    ############################################################################
+    # Context Variables Objects
+    ############################################################################
+
+    # PyContext
+    # The C structure used to represent a `contextvars.Context` object.
+
+    # PyContextVar
+    # The C structure used to represent a `contextvars.ContextVar` object.
+
+    # PyContextToken
+    # The C structure used to represent a `contextvars.Token` object.
+
+    # PyTypeObject PyContext_Type
+    # Type object representing the `contextvars.Context` type.
+
+    # PyTypeObject PyContextVar_Type
+    # Type object representing the `contextvars.ContextVar` type.
+
+    # PyTypeObject PyContextToken_Type
+    # Type object representing the `contextvars.Token` type.
+
+    bint PyContext_CheckExact(object obj)
+    # Return `true` if `obj` is of type `PyContext_Type`.
+    # `obj` must not be NULL. This function always succeeds.
+
+    bint PyContextVar_CheckExact(object obj)
+    # Return `true` if `obj` is of type `PyContextVar_Type`.
+    # `obj` must not be NULL. This function always succeeds.
+
+    bint PyContextToken_CheckExact(object obj)
+    # Return `true` if `obj` is of type `PyContextToken_Type`.
+    # `obj` must not be NULL. This function always succeeds.
+
+    object PyContext_New()
+    # Return value: New reference.
+    # Create a new empty context object.
+    # Returns NULL if an error has occurred.
+
+    object PyContext_Copy(object ctx)
+    # Return value: New reference.
+    # Create a shallow copy of the passed `ctx` context object.
+    # Returns NULL if an error has occurred.
+
+    object PyContext_CopyCurrent()
+    # Return value: New reference.
+    # Create a shallow copy of the current thread context.
+    # Returns NULL if an error has occurred.
+
+    int PyContext_Enter(object ctx) except -1
+    # Set `ctx` as the current context for the current thread.
+    # Returns 0 on success, and -1 on error.
+
+    int PyContext_Exit(object ctx) except -1
+    # Deactivate the `ctx` context and restore the previous context
+    # as the current context for the current thread.
+    # Returns 0 on success, and -1 on error.
+
+    object PyContextVar_New(const char* name, PyObject* default_value)
+    # Return value: New reference.
+    # Create a new ContextVar object. The `name` parameter is used
+    # for introspection and debug purposes. The `default_value` parameter
+    # may optionally specify the default value for the context variable.
+    # If an error has occurred, this function returns NULL.
+
+    object PyContextVar_New_with_default "PyContextVar_New" (const char* name, object default_value)
+    # A different declaration of PyContextVar_New that requires a default value
+    # to be passed on call.
+
+    int PyContextVar_Get(object var, PyObject* default_value, PyObject** value) except -1
+    # Get the value of a context variable.
+    # Returns -1 if an error has occurred during lookup, and 0 if no error
+    # occurred, whether or not a value was found.
+    #
+    # If the context variable was found, `value` will be a pointer to it.
+    # If the context variable was not found, `value` will point to:
+    #
+    #   • `default_value`, if not NULL;
+    #   • the default value of `var`, if not NULL;
+    #   • NULL
+    int PyContextVar_Get_with_default "PyContextVar_Get" (object var, object default_value, PyObject** value) except -1
+    # A different declaration of PyContextVar_Get that requires a default value
+    # to be passed on call.
+
+    object PyContextVar_Set(object var, object value)
+    # Return value: New reference.
+    # Set the value of `var` to `value` in the current context.
+    # Returns a token object for this value change, or NULL if an error has occurred.
+
+    int PyContextVar_Reset(object var, object token) except -1
+    # Reset the state of the `var` context variable to that it was in
+    # before `PyContextVar_Set()` that returned `token` was called.
+    # This function returns 0 on success and -1 on error.
+
+
+@_cython.c_compile_guard("!CYTHON_COMPILING_IN_LIMITED_API")
+cdef inline object get_value(var, default_value=None):
+    """Return a new reference to the value of the context variable,
+    or the default value of the context variable,
+    or None if no such value or default was found.
+    """
+    cdef PyObject *value = NULL
+    PyContextVar_Get(var, NULL, &value)
+    if value is NULL:
+        # context variable does not have a default
+        pyvalue = default_value
+    else:
+        # value or default value of context variable
+        pyvalue = <object>value
+        Py_XDECREF(value)  # PyContextVar_Get() returned an owned reference as 'PyObject*'
+    return pyvalue
+
+
+@_cython.c_compile_guard("!CYTHON_COMPILING_IN_LIMITED_API")
+cdef inline object get_value_no_default(var, default_value=None):
+    """Return a new reference to the value of the context variable,
+    or the provided default value if no such value was found.
+
+    Ignores the default value of the context variable, if any.
+    """
+    cdef PyObject *value = NULL
+    PyContextVar_Get(var, <PyObject*>default_value, &value)
+    # value of context variable or 'default_value'
+    pyvalue = <object>value
+    Py_XDECREF(value)  # PyContextVar_Get() returned an owned reference as 'PyObject*'
+    return pyvalue

Cython/Includes/cpython/conversion.pxd

@@ -0,0 +1,36 @@
+# From https://docs.python.org/3/c-api/conversion.html
+
+from .object cimport PyObject
+
+cdef extern from "Python.h":
+    ctypedef struct va_list
+
+    int PyOS_snprintf(char *str, size_t size, const char *format, ...)
+    # Output not more than size bytes to str according to the format
+    # string format and the extra arguments. See the Unix man page snprintf(2).
+
+    int PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va)
+    # Output not more than size bytes to str according to the format
+    # string format and the variable argument list va. Unix man page vsnprintf(2).
+
+    double PyOS_string_to_double(const char *s, char **endptr, PyObject *overflow_exception) except? -1.0
+    # Convert a string s to a double, raising a Python exception on failure. The set of
+    # accepted strings corresponds to the set of strings accepted by Python’s float()
+    # constructor, except that s must not have leading or trailing whitespace.
+    # The conversion is independent of the current locale.
+
+    enum:
+        Py_DTSF_SIGN
+        Py_DTSF_ADD_DOT_0
+        Py_DTSF_ALT
+
+    char* PyOS_double_to_string(double val, char format_code, int precision, int flags, int *ptype) except NULL
+    # Convert a double val to a string using supplied format_code, precision, and flags.
+
+    int PyOS_stricmp(const char *s1, const char *s2)
+    # Case insensitive comparison of strings. The function works almost identically
+    # to strcmp() except that it ignores the case.
+
+    int PyOS_strnicmp(const char *s1, const char *s2, Py_ssize_t  size)
+    # Case insensitive comparison of strings. The function works almost identically
+    # to strncmp() except that it ignores the case.