1
from .object cimport PyObject
3
cdef extern from "Python.h":
5
############################################################################
6
# 6.3 Sequence Protocol
7
############################################################################
9
bint PySequence_Check(object o)
10
# Return 1 if the object provides sequence protocol, and 0
11
# otherwise. This function always succeeds.
13
Py_ssize_t PySequence_Size(object o) except -1
14
# Returns the number of objects in sequence o on success, and -1
15
# on failure. For objects that do not provide sequence protocol,
16
# this is equivalent to the Python expression "len(o)".
18
Py_ssize_t PySequence_Length(object o) except -1
19
# Alternate name for PySequence_Size().
21
object PySequence_Concat(object o1, object o2)
22
# Return value: New reference.
23
# Return the concatenation of o1 and o2 on success, and NULL on
24
# failure. This is the equivalent of the Python expression "o1 +
27
object PySequence_Repeat(object o, Py_ssize_t count)
28
# Return value: New reference.
29
# Return the result of repeating sequence object o count times, or
30
# NULL on failure. This is the equivalent of the Python expression
33
object PySequence_InPlaceConcat(object o1, object o2)
34
# Return value: New reference.
35
# Return the concatenation of o1 and o2 on success, and NULL on
36
# failure. The operation is done in-place when o1 supports
37
# it. This is the equivalent of the Python expression "o1 += o2".
39
object PySequence_InPlaceRepeat(object o, Py_ssize_t count)
40
# Return value: New reference.
41
# Return the result of repeating sequence object o count times, or
42
# NULL on failure. The operation is done in-place when o supports
43
# it. This is the equivalent of the Python expression "o *=
46
object PySequence_GetItem(object o, Py_ssize_t i)
47
# Return value: New reference.
48
# Return the ith element of o, or NULL on failure. This is the
49
# equivalent of the Python expression "o[i]".
51
object PySequence_GetSlice(object o, Py_ssize_t i1, Py_ssize_t i2)
52
# Return value: New reference.
53
# Return the slice of sequence object o between i1 and i2, or NULL
54
# on failure. This is the equivalent of the Python expression
57
int PySequence_SetItem(object o, Py_ssize_t i, object v) except -1
58
# Assign object v to the ith element of o. Returns -1 on
59
# failure. This is the equivalent of the Python statement "o[i] =
60
# v". This function does not steal a reference to v.
62
int PySequence_DelItem(object o, Py_ssize_t i) except -1
63
# Delete the ith element of object o. Returns -1 on failure. This
64
# is the equivalent of the Python statement "del o[i]".
66
int PySequence_SetSlice(object o, Py_ssize_t i1, Py_ssize_t i2, object v) except -1
67
# Assign the sequence object v to the slice in sequence object o
68
# from i1 to i2. This is the equivalent of the Python statement
71
int PySequence_DelSlice(object o, Py_ssize_t i1, Py_ssize_t i2) except -1
72
# Delete the slice in sequence object o from i1 to i2. Returns -1
73
# on failure. This is the equivalent of the Python statement "del
76
int PySequence_Count(object o, object value) except -1
77
# Return the number of occurrences of value in o, that is, return
78
# the number of keys for which o[key] == value. On failure, return
79
# -1. This is equivalent to the Python expression
82
int PySequence_Contains(object o, object value) except -1
83
# Determine if o contains value. If an item in o is equal to
84
# value, return 1, otherwise return 0. On error, return -1. This
85
# is equivalent to the Python expression "value in o".
87
Py_ssize_t PySequence_Index(object o, object value) except -1
88
# Return the first index i for which o[i] == value. On error,
89
# return -1. This is equivalent to the Python expression
92
object PySequence_List(object o)
93
# Return value: New reference.
94
# Return a list object with the same contents as the arbitrary
95
# sequence o. The returned list is guaranteed to be new.
97
object PySequence_Tuple(object o)
98
# Return value: New reference.
99
# Return a tuple object with the same contents as the arbitrary
100
# sequence o or NULL on failure. If o is a tuple, a new reference
101
# will be returned, otherwise a tuple will be constructed with the
102
# appropriate contents. This is equivalent to the Python
103
# expression "tuple(o)".
105
object PySequence_Fast(object o, char *m)
106
# Return value: New reference.
107
# Returns the sequence o as a tuple, unless it is already a tuple
108
# or list, in which case o is returned. Use
109
# PySequence_Fast_GET_ITEM() to access the members of the
110
# result. Returns NULL on failure. If the object is not a
111
# sequence, raises TypeError with m as the message text.
113
PyObject* PySequence_Fast_GET_ITEM(object o, Py_ssize_t i)
114
# Return value: Borrowed reference.
115
# Return the ith element of o, assuming that o was returned by
116
# PySequence_Fast(), o is not NULL, and that i is within bounds.
118
PyObject** PySequence_Fast_ITEMS(object o)
119
# Return the underlying array of PyObject pointers. Assumes that o
120
# was returned by PySequence_Fast() and o is not NULL.
122
object PySequence_ITEM(object o, Py_ssize_t i)
123
# Return value: New reference.
124
# Return the ith element of o or NULL on failure. Macro form of
125
# PySequence_GetItem() but without checking that
126
# PySequence_Check(o) is true and without adjustment for negative
129
Py_ssize_t PySequence_Fast_GET_SIZE(object o)
130
# Returns the length of o, assuming that o was returned by
131
# PySequence_Fast() and that o is not NULL. The size can also be
132
# gotten by calling PySequence_Size() on o, but
133
# PySequence_Fast_GET_SIZE() is faster because it can assume o is