Cython 3.2.0__cp39-abi3-win32.whl

Cython/Includes/cpython/exc.pxd

@@ -0,0 +1,263 @@
+from .object cimport PyObject
+
+cdef extern from "Python.h":
+
+    #####################################################################
+    # 3. Exception Handling
+    #####################################################################
+
+    # The functions described in this chapter will let you handle and
+    # raise Python exceptions. It is important to understand some of
+    # the basics of Python exception handling. It works somewhat like
+    # the Unix errno variable: there is a global indicator (per
+    # thread) of the last error that occurred. Most functions don't
+    # clear this on success, but will set it to indicate the cause of
+    # the error on failure. Most functions also return an error
+    # indicator, usually NULL if they are supposed to return a
+    # pointer, or -1 if they return an integer (exception: the
+    # PyArg_*() functions return 1 for success and 0 for failure).
+
+    # When a function must fail because some function it called
+    # failed, it generally doesn't set the error indicator; the
+    # function it called already set it. It is responsible for either
+    # handling the error and clearing the exception or returning after
+    # cleaning up any resources it holds (such as object references or
+    # memory allocations); it should not continue normally if it is
+    # not prepared to handle the error. If returning due to an error,
+    # it is important to indicate to the caller that an error has been
+    # set. If the error is not handled or carefully propagated,
+    # additional calls into the Python/C API may not behave as
+    # intended and may fail in mysterious ways.
+
+    # The error indicator consists of three Python objects
+    # corresponding to the Python variables sys.exc_type,
+    # sys.exc_value and sys.exc_traceback. API functions exist to
+    # interact with the error indicator in various ways. There is a
+    # separate error indicator for each thread.
+
+    void PyErr_Print()
+    # Print a standard traceback to sys.stderr and clear the error
+    # indicator. Call this function only when the error indicator is
+    # set. (Otherwise it will cause a fatal error!)
+
+    PyObject* PyErr_Occurred()
+    # Return value: Borrowed reference.
+    # Test whether the error indicator is set. If set, return the
+    # exception type (the first argument to the last call to one of
+    # the PyErr_Set*() functions or to PyErr_Restore()). If not set,
+    # return NULL. You do not own a reference to the return value, so
+    # you do not need to Py_DECREF() it. Note: Do not compare the
+    # return value to a specific exception; use
+    # PyErr_ExceptionMatches() instead, shown below. (The comparison
+    # could easily fail since the exception may be an instance instead
+    # of a class, in the case of a class exception, or it may be a
+    # subclass of the expected exception.)
+
+    bint PyErr_ExceptionMatches(object exc)
+    # Equivalent to "PyErr_GivenExceptionMatches(PyErr_Occurred(),
+    # exc)". This should only be called when an exception is actually
+    # set; a memory access violation will occur if no exception has
+    # been raised.
+
+    bint PyErr_GivenExceptionMatches(object given, object exc)
+    # Return true if the given exception matches the exception in
+    # exc. If exc is a class object, this also returns true when given
+    # is an instance of a subclass. If exc is a tuple, all exceptions
+    # in the tuple (and recursively in subtuples) are searched for a
+    # match. If given is NULL, a memory access violation will occur.
+
+    void PyErr_NormalizeException(PyObject** exc, PyObject** val, PyObject** tb)
+    # Under certain circumstances, the values returned by
+    # PyErr_Fetch() below can be ``unnormalized'', meaning that *exc
+    # is a class object but *val is not an instance of the same
+    # class. This function can be used to instantiate the class in
+    # that case. If the values are already normalized, nothing
+    # happens. The delayed normalization is implemented to improve
+    # performance.
+
+    void PyErr_Clear()
+    # Clear the error indicator. If the error indicator is not set, there is no effect.
+
+    void PyErr_Fetch(PyObject** ptype, PyObject** pvalue, PyObject** ptraceback)
+    # Retrieve the error indicator into three variables whose
+    # addresses are passed. If the error indicator is not set, set all
+    # three variables to NULL. If it is set, it will be cleared and
+    # you own a reference to each object retrieved. The value and
+    # traceback object may be NULL even when the type object is
+    # not. Note: This function is normally only used by code that
+    # needs to handle exceptions or by code that needs to save and
+    # restore the error indicator temporarily.
+
+    PyObject* PyErr_GetHandledException()
+    void PyErr_SetHandledException(PyObject* exc)
+    PyObject* PyErr_GetRaisedException()
+    void PyErr_SetRaisedException(PyObject* exc)
+
+    void PyErr_Restore(PyObject* type, PyObject* value, PyObject* traceback)
+    # Set the error indicator from the three objects. If the error
+    # indicator is already set, it is cleared first. If the objects
+    # are NULL, the error indicator is cleared. Do not pass a NULL
+    # type and non-NULL value or traceback. The exception type should
+    # be a class. Do not pass an invalid exception type or
+    # value. (Violating these rules will cause subtle problems later.)
+    # This call takes away a reference to each object: you must own a
+    # reference to each object before the call and after the call you
+    # no longer own these references. (If you don't understand this,
+    # don't use this function. I warned you.) Note: This function is
+    # normally only used by code that needs to save and restore the
+    # error indicator temporarily; use PyErr_Fetch() to save the
+    # current exception state.
+
+    void PyErr_SetString(object type, char *message)
+    # This is the most common way to set the error indicator. The
+    # first argument specifies the exception type; it is normally one
+    # of the standard exceptions, e.g. PyExc_RuntimeError. You need
+    # not increment its reference count. The second argument is an
+    # error message; it is converted to a string object.
+
+    void PyErr_SetObject(object type, object value)
+    # This function is similar to PyErr_SetString() but lets you
+    # specify an arbitrary Python object for the ``value'' of the
+    # exception.
+
+    PyObject* PyErr_Format(object exception, char *format, ...) except NULL
+    # Return value: Always NULL.
+    # This function sets the error indicator and returns
+    # NULL. exception should be a Python exception (class, not an
+    # instance). format should be a string, containing format codes,
+    # similar to printf(). The width.precision before a format code is
+    # parsed, but the width part is ignored.
+
+    void PyErr_SetNone(object type)
+    # This is a shorthand for "PyErr_SetObject(type, Py_None)".
+
+    int PyErr_BadArgument() except 0
+
+    # This is a shorthand for "PyErr_SetString(PyExc_TypeError,
+    # message)", where message indicates that a built-in operation was
+    # invoked with an illegal argument. It is mostly for internal use.
+
+    PyObject* PyErr_NoMemory() except NULL
+    # Return value: Always NULL.
+    # This is a shorthand for "PyErr_SetNone(PyExc_MemoryError)"; it
+    # returns NULL so an object allocation function can write "return
+    # PyErr_NoMemory();" when it runs out of memory.
+
+    PyObject* PyErr_SetFromErrno(object type) except NULL
+    # Return value: Always NULL.
+    # This is a convenience function to raise an exception when a C
+    # library function has returned an error and set the C variable
+    # errno. It constructs a tuple object whose first item is the
+    # integer errno value and whose second item is the corresponding
+    # error message (gotten from strerror()), and then calls
+    # "PyErr_SetObject(type, object)". On Unix, when the errno value
+    # is EINTR, indicating an interrupted system call, this calls
+    # PyErr_CheckSignals(), and if that set the error indicator,
+    # leaves it set to that. The function always returns NULL, so a
+    # wrapper function around a system call can write "return
+    # PyErr_SetFromErrno(type);" when the system call returns an
+    # error.
+
+    PyObject* PyErr_SetFromErrnoWithFilenameObject(object type, object filenameObject) except NULL
+    # Similar to PyErr_SetFromErrno(), with the additional behavior
+    # that if filenameObject is not NULL, it is passed to the
+    # constructor of type as a third parameter.
+    # In the case of OSError exception, this is used to define
+    # the filename attribute of the exception instance.
+
+    PyObject* PyErr_SetFromErrnoWithFilename(object type, char *filename) except NULL
+    # Return value: Always NULL.  Similar to PyErr_SetFromErrno(),
+    # with the additional behavior that if filename is not NULL, it is
+    # passed to the constructor of type as a third parameter. In the
+    # case of exceptions such as IOError and OSError, this is used to
+    # define the filename attribute of the exception instance.
+
+    PyObject* PyErr_SetFromWindowsErr(int ierr) except NULL
+    # Return value: Always NULL.  This is a convenience function to
+    # raise WindowsError. If called with ierr of 0, the error code
+    # returned by a call to GetLastError() is used instead. It calls
+    # the Win32 function FormatMessage() to retrieve the Windows
+    # description of error code given by ierr or GetLastError(), then
+    # it constructs a tuple object whose first item is the ierr value
+    # and whose second item is the corresponding error message (gotten
+    # from FormatMessage()), and then calls
+    # "PyErr_SetObject(PyExc_WindowsError, object)". This function
+    # always returns NULL. Availability: Windows.
+
+    PyObject* PyErr_SetExcFromWindowsErr(object type, int ierr) except NULL
+    # Return value: Always NULL.  Similar to
+    # PyErr_SetFromWindowsErr(), with an additional parameter
+    # specifying the exception type to be raised. Availability:
+    # Windows. New in version 2.3.
+
+    PyObject* PyErr_SetFromWindowsErrWithFilename(int ierr, char *filename) except NULL
+    # Return value: Always NULL.  Similar to
+    # PyErr_SetFromWindowsErr(), with the additional behavior that if
+    # filename is not NULL, it is passed to the constructor of
+    # WindowsError as a third parameter. Availability: Windows.
+
+    PyObject* PyErr_SetExcFromWindowsErrWithFilename(object type, int ierr, char *filename) except NULL
+    # Return value: Always NULL.
+    # Similar to PyErr_SetFromWindowsErrWithFilename(), with an
+    # additional parameter specifying the exception type to be
+    # raised. Availability: Windows.
+
+    void PyErr_BadInternalCall()
+    # This is a shorthand for "PyErr_SetString(PyExc_TypeError,
+    # message)", where message indicates that an internal operation
+    # (e.g. a Python/C API function) was invoked with an illegal
+    # argument. It is mostly for internal use.
+
+    int PyErr_WarnEx(object category, char *message, int stacklevel) except -1
+    # Issue a warning message. The category argument is a warning
+    # category (see below) or NULL; the message argument is a message
+    # string. stacklevel is a positive number giving a number of stack
+    # frames; the warning will be issued from the currently executing
+    # line of code in that stack frame. A stacklevel of 1 is the
+    # function calling PyErr_WarnEx(), 2 is the function above that,
+    # and so forth.
+
+    int PyErr_WarnExplicit(object category, char *message, char *filename, int lineno, char *module, object registry) except -1
+    # Issue a warning message with explicit control over all warning
+    # attributes. This is a straightforward wrapper around the Python
+    # function warnings.warn_explicit(), see there for more
+    # information. The module and registry arguments may be set to
+    # NULL to get the default effect described there.
+
+    int PyErr_CheckSignals() except -1
+    # This function interacts with Python's signal handling. It checks
+    # whether a signal has been sent to the processes and if so,
+    # invokes the corresponding signal handler. If the signal module
+    # is supported, this can invoke a signal handler written in
+    # Python. In all cases, the default effect for SIGINT is to raise
+    # the KeyboardInterrupt exception. If an exception is raised the
+    # error indicator is set and the function returns 1; otherwise the
+    # function returns 0. The error indicator may or may not be
+    # cleared if it was previously set.
+
+    void PyErr_SetInterrupt() nogil
+    # This function simulates the effect of a SIGINT signal arriving
+    # -- the next time PyErr_CheckSignals() is called,
+    # KeyboardInterrupt will be raised. It may be called without
+    # holding the interpreter lock.
+
+    int PyErr_SetInterruptEx(int signum)
+
+    object PyErr_NewException(char *name, object base, object dict)
+    # Return value: New reference.
+    # This utility function creates and returns a new exception
+    # object. The name argument must be the name of the new exception,
+    # a C string of the form module.class. The base and dict arguments
+    # are normally NULL. This creates a class object derived from
+    # Exception (accessible in C as PyExc_Exception).
+
+    void PyErr_WriteUnraisable(object obj)
+    # This utility function prints a warning message to sys.stderr
+    # when an exception has been set but it is impossible for the
+    # interpreter to actually raise the exception. It is used, for
+    # example, when an exception occurs in an __del__() method.
+    #
+    # The function is called with a single argument obj that
+    # identifies the context in which the unraisable exception
+    # occurred. The repr of obj will be printed in the warning
+    # message.

Cython/Includes/cpython/fileobject.pxd

@@ -0,0 +1,57 @@
+"""
+From https://docs.python.org/3.9/c-api/file.html
+
+These APIs are a minimal emulation of the Python 2 C API for built-in file objects,
+which used to rely on the buffered I/O (FILE*) support from the C standard library.
+In Python 3, files and streams use the new io module, which defines several layers
+over the low-level unbuffered I/O of the operating system. The functions described
+below are convenience C wrappers over these new APIs, and meant mostly for internal
+error reporting in the interpreter;
+
+third-party code is advised to access the io APIs instead.
+"""
+
+cdef extern from "Python.h":
+
+    ###########################################################################
+    # File Objects
+    ###########################################################################
+
+    object PyFile_FromFd(int fd, const char *name, const char *mode, int buffering,
+                         const char *encoding, const char *errors, const char *newline, int closefd)
+    # Return value: New reference.
+    # Create a Python file object from the file descriptor of an already
+    # opened file fd. The arguments name, encoding, errors and newline can be
+    # NULL to use the defaults; buffering can be -1 to use the default. name
+    # is ignored and kept for backward compatibility. Return NULL on failure.
+    # For a more comprehensive description of the arguments, please refer to
+    # the io.open() function documentation.
+
+    # Warning: Since Python streams have their own buffering layer, mixing
+    # them with OS-level file descriptors can produce various issues (such as
+    # unexpected ordering of data).
+
+    # Changed in version 3.2: Ignore name attribute.
+
+    object PyFile_GetLine(object p, int n)
+    # Return value: New reference.
+    # Equivalent to p.readline([n]), this function reads one line from the
+    # object p. p may be a file object or any object with a readline()
+    # method. If n is 0, exactly one line is read, regardless of the length of
+    # the line. If n is greater than 0, no more than n bytes will be read from
+    # the file; a partial line can be returned. In both cases, an empty string
+    # is returned if the end of the file is reached immediately. If n is less
+    # than 0, however, one line is read regardless of length, but EOFError is
+    # raised if the end of the file is reached immediately.
+
+    int PyFile_WriteObject(object obj, object p, int flags) except? -1
+    # Write object obj to file object p. The only supported flag for flags
+    # is Py_PRINT_RAW; if given, the str() of the object is written instead of
+    # the repr(). Return 0 on success or -1 on failure; the appropriate
+    # exception will be set.
+
+    int PyFile_WriteString(const char *s, object p) except? -1
+    # Write string s to file object p. Return 0 on success or -1 on failure;
+    # the appropriate exception will be set.
+
+    enum: Py_PRINT_RAW

Cython/Includes/cpython/float.pxd

@@ -0,0 +1,47 @@
+cdef extern from *:
+    """
+    #if PY_MAJOR_VERSION >= 3
+      #define __Pyx_PyFloat_FromString(obj)  PyFloat_FromString(obj)
+    #else
+      #define __Pyx_PyFloat_FromString(obj)  PyFloat_FromString(obj, NULL)
+    #endif
+    """
+
+cdef extern from "Python.h":
+    ############################################################################
+    # 7.2.3
+    ############################################################################
+    # PyFloatObject
+    #
+    # This subtype of PyObject represents a Python floating point object.
+
+    # PyTypeObject PyFloat_Type
+    #
+    # This instance of PyTypeObject represents the Python floating
+    # point type. This is the same object as float and
+    # types.FloatType.
+
+    bint PyFloat_Check(object p)
+    # Return true if its argument is a PyFloatObject or a subtype of
+    # PyFloatObject.
+
+    bint PyFloat_CheckExact(object p)
+    # Return true if its argument is a PyFloatObject, but not a
+    # subtype of PyFloatObject.
+
+    object PyFloat_FromString "__Pyx_PyFloat_FromString" (object str)
+    # Return value: New reference.
+    # Create a PyFloatObject object based on the string value in str,
+    # or NULL on failure. The pend argument is ignored. It remains
+    # only for backward compatibility.
+
+    object PyFloat_FromDouble(double v)
+    # Return value: New reference.
+    # Create a PyFloatObject object from v, or NULL on failure.
+
+    double PyFloat_AsDouble(object pyfloat) except? -1
+    # Return a C double representation of the contents of pyfloat.
+
+    double PyFloat_AS_DOUBLE(object pyfloat)
+    # Return a C double representation of the contents of pyfloat, but
+    # without error checking.

Cython/Includes/cpython/function.pxd

@@ -0,0 +1,65 @@
+from .object cimport PyObject
+
+cdef extern from "Python.h":
+
+    ############################################################################
+    # 7.5.3 Function Objects
+    ############################################################################
+    # There are a few functions specific to Python functions.
+
+    # PyFunctionObject
+    #
+    # The C structure used for functions.
+
+    # PyTypeObject PyFunction_Type
+    #
+    # This is an instance of PyTypeObject and represents the Python
+    # function type. It is exposed to Python programmers as
+    # types.FunctionType.
+
+    bint PyFunction_Check(object o)
+    # Return true if o is a function object (has type
+    # PyFunction_Type). The parameter must not be NULL.
+
+    object PyFunction_New(object code, object globals)
+    # Return value: New reference.
+    # Return a new function object associated with the code object
+    # code. globals must be a dictionary with the global variables
+    # accessible to the function.
+    # The function's docstring, name and __module__ are retrieved from
+    # the code object, the argument defaults and closure are set to
+    # NULL.
+
+    PyObject* PyFunction_GetCode(object op) except? NULL
+    # Return value: Borrowed reference.
+    # Return the code object associated with the function object op.
+
+    PyObject* PyFunction_GetGlobals(object op) except? NULL
+    # Return value: Borrowed reference.
+    # Return the globals dictionary associated with the function object op.
+
+    PyObject* PyFunction_GetModule(object op) except? NULL
+    # Return value: Borrowed reference.
+    # Return the __module__ attribute of the function object op. This
+    # is normally a string containing the module name, but can be set
+    # to any other object by Python code.
+
+    PyObject* PyFunction_GetDefaults(object op) except? NULL
+    # Return value: Borrowed reference.
+    # Return the argument default values of the function object
+    # op. This can be a tuple of arguments or NULL.
+
+    int PyFunction_SetDefaults(object op, object defaults) except -1
+    # Set the argument default values for the function object
+    # op. defaults must be Py_None or a tuple.
+    # Raises SystemError and returns -1 on failure.
+
+    PyObject* PyFunction_GetClosure(object op) except? NULL
+    # Return value: Borrowed reference.
+    # Return the closure associated with the function object op. This
+    # can be NULL or a tuple of cell objects.
+
+    int PyFunction_SetClosure(object op, object closure) except -1
+    # Set the closure associated with the function object op. closure
+    # must be Py_None or a tuple of cell objects.
+    # Raises SystemError and returns -1 on failure.

Cython/Includes/cpython/genobject.pxd

@@ -0,0 +1,25 @@
+from .pystate cimport PyFrameObject
+
+cdef extern from "Python.h":
+
+    ###########################################################################
+    # Generator Objects
+    ###########################################################################
+
+    bint PyGen_Check(object ob)
+    # Return true if ob is a generator object; ob must not be NULL.
+
+    bint PyGen_CheckExact(object ob)
+    # Return true if ob's type is PyGen_Type; ob must not be NULL.
+
+    object PyGen_New(PyFrameObject *frame)
+    # Return value: New reference.
+    # Create and return a new generator object based on the frame object. A
+    # reference to frame is stolen by this function. The argument must not be
+    # NULL.
+
+    object PyGen_NewWithQualName(PyFrameObject *frame, object name, object qualname)
+    # Return value: New reference.
+    # Create and return a new generator object based on the frame object, with
+    # __name__ and __qualname__ set to name and qualname. A reference to frame
+    # is stolen by this function. The frame argument must not be NULL.

Cython/Includes/cpython/getargs.pxd

@@ -0,0 +1,12 @@
+
+cdef extern from "Python.h":
+    #####################################################################
+    # 5.5 Parsing arguments and building values
+    #####################################################################
+    ctypedef struct va_list
+    int PyArg_ParseTuple(object args, char *format, ...) except 0
+    int PyArg_VaParse(object args, char *format, va_list vargs) except 0
+    int PyArg_ParseTupleAndKeywords(object args, object kw, char *format, char *keywords[], ...) except 0
+    int PyArg_VaParseTupleAndKeywords(object args, object kw, char *format, char *keywords[], va_list vargs) except 0
+    int PyArg_Parse(object args, char *format, ...) except 0
+    int PyArg_UnpackTuple(object args, char *name, Py_ssize_t min, Py_ssize_t max, ...) except 0

Cython/Includes/cpython/instance.pxd

@@ -0,0 +1,25 @@
+cdef extern from "Python.h":
+
+    ############################################################################
+    # 7.5.2 Instance Objects
+    ############################################################################
+
+    # PyTypeObject PyInstance_Type
+    #
+    # Type object for class instances.
+
+    int PyInstance_Check(object obj)
+    # Return true if obj is an instance.
+
+    object PyInstance_New(object cls, object arg, object kw)
+    # Return value: New reference.
+    # Create a new instance of a specific class. The parameters arg
+    # and kw are used as the positional and keyword parameters to the
+    # object's constructor.
+
+    object PyInstance_NewRaw(object cls, object dict)
+    # Return value: New reference.
+    # Create a new instance of a specific class without calling its
+    # constructor. class is the class of new object. The dict
+    # parameter will be used as the object's __dict__; if NULL, a new
+    # dictionary will be created for the instance.

Cython/Includes/cpython/iterator.pxd

@@ -0,0 +1,36 @@
+cdef extern from "Python.h":
+
+    ############################################################################
+    # 6.5 Iterator Protocol
+    ############################################################################
+    bint PyIter_Check(object o)
+    # Return true if the object o supports the iterator protocol.
+
+    object PyIter_Next(object o)
+    # Return value: New reference.
+    # Return the next value from the iteration o. If the object is an
+    # iterator, this retrieves the next value from the iteration, and
+    # returns NULL with no exception set if there are no remaining
+    # items. If the object is not an iterator, TypeError is raised, or
+    # if there is an error in retrieving the item, returns NULL and
+    # passes along the exception.
+
+    # To write a loop which iterates over an iterator, the C code should look something like this:
+    # PyObject *iterator = PyObject_GetIter(obj);
+    # PyObject *item;
+    # if (iterator == NULL) {
+    # /* propagate error */
+    # }
+    # while (item = PyIter_Next(iterator)) {
+    # /* do something with item */
+    # ...
+    # /* release reference when done */
+    # Py_DECREF(item);
+    # }
+    # Py_DECREF(iterator);
+    # if (PyErr_Occurred()) {
+    # /* propagate error */
+    # }
+    # else {
+    # /* continue doing useful work */
+    # }

Cython/Includes/cpython/iterobject.pxd

@@ -0,0 +1,24 @@
+cdef extern from "Python.h":
+
+    ###########################################################################
+    # Iterator Objects
+    ###########################################################################
+
+    bint PySeqIter_Check(object op)
+    # Return true if the type of op is PySeqIter_Type.
+
+    object PySeqIter_New(object seq)
+    # Return value: New reference.
+    # Return an iterator that works with a general sequence object, seq. The
+    # iteration ends when the sequence raises IndexError for the subscripting
+    # operation.
+
+    bint PyCallIter_Check(object op)
+    # Return true if the type of op is PyCallIter_Type.
+
+    object PyCallIter_New(object callable, object sentinel)
+    # Return value: New reference.
+    # Return a new iterator. The first parameter, callable, can be any Python
+    # callable object that can be called with no parameters; each call to it
+    # should return the next item in the iteration. When callable returns a
+    # value equal to sentinel, the iteration will be terminated.

Cython/Includes/cpython/list.pxd

@@ -0,0 +1,92 @@
+from .object cimport PyObject
+
+cdef extern from "Python.h":
+
+    ############################################################################
+    # Lists
+    ############################################################################
+    list PyList_New(Py_ssize_t len)
+    # Return a new list of length len on success, or NULL on failure.
+    #
+    # Note: If length is greater than zero, the returned list object's
+    # items are set to NULL. Thus you cannot use abstract API
+    # functions such as PySequence_SetItem() or expose the object to
+    # Python code before setting all items to a real object with
+    # PyList_SetItem().
+
+    bint PyList_Check(object p)
+    # Return true if p is a list object or an instance of a subtype of
+    # the list type.
+
+    bint PyList_CheckExact(object p)
+    # Return true if p is a list object, but not an instance of a
+    # subtype of the list type.
+
+    Py_ssize_t PyList_Size(object list) except -1
+    # Return the length of the list object in list; this is equivalent
+    # to "len(list)" on a list object.
+
+    Py_ssize_t PyList_GET_SIZE(object list)
+    # Macro form of PyList_Size() without error checking.
+
+    PyObject* PyList_GetItem(object list, Py_ssize_t index) except NULL
+    # Return value: Borrowed reference.
+    # Return the object at position pos in the list pointed to by
+    # p. The position must be positive, indexing from the end of the
+    # list is not supported. If pos is out of bounds, return NULL and
+    # set an IndexError exception.
+
+    PyObject* PyList_GET_ITEM(object list, Py_ssize_t i)
+    # Return value: Borrowed reference.
+    # Macro form of PyList_GetItem() without error checking.
+
+    int PyList_SetItem(object list, Py_ssize_t index, object item) except -1
+    # Set the item at index index in list to item. Return 0 on success
+    # or -1 on failure.
+    #
+    # WARNING: This function _steals_ a reference to item and discards a
+    # reference to an item already in the list at the affected position.
+
+    void PyList_SET_ITEM(object list, Py_ssize_t i, object o)
+    # Macro form of PyList_SetItem() without error checking. This is
+    # normally only used to fill in new lists where there is no
+    # previous content.
+    #
+    # WARNING: This function _steals_ a reference to item, and, unlike
+    # PyList_SetItem(), does not discard a reference to any item that
+    # it being replaced; any reference in list at position i will be *leaked*.
+
+    int PyList_Insert(object list, Py_ssize_t index, object item) except -1
+    # Insert the item item into list list in front of index
+    # index. Return 0 if successful; return -1 and set an exception if
+    # unsuccessful. Analogous to list.insert(index, item).
+
+    int PyList_Append(object list, object item) except -1
+    # Append the object item at the end of list list. Return 0 if
+    # successful; return -1 and set an exception if
+    # unsuccessful. Analogous to list.append(item).
+
+    list PyList_GetSlice(object list, Py_ssize_t low, Py_ssize_t high)
+    # Return value: New reference.
+    # Return a list of the objects in list containing the objects
+    # between low and high. Return NULL and set an exception if
+    # unsuccessful. Analogous to list[low:high].
+
+    int PyList_SetSlice(object list, Py_ssize_t low, Py_ssize_t high, object itemlist) except -1
+    # Set the slice of list between low and high to the contents of
+    # itemlist. Analogous to list[low:high] = itemlist. The itemlist
+    # may be NULL, indicating the assignment of an empty list (slice
+    # deletion). Return 0 on success, -1 on failure.
+
+    int PyList_Sort(object list) except -1
+    # Sort the items of list in place. Return 0 on success, -1 on
+    # failure. This is equivalent to "list.sort()".
+
+    int PyList_Reverse(object list) except -1
+    # Reverse the items of list in place. Return 0 on success, -1 on
+    # failure. This is the equivalent of "list.reverse()".
+
+    tuple PyList_AsTuple(object list)
+    # Return value: New reference.
+    # Return a new tuple object containing the contents of list;
+    # equivalent to "tuple(list)".