1 from cpython.ref cimport PyObject, PyTypeObject 2 from libc.stdio cimport FILE 3 4 cdef extern from "Python.h": 5 6 ##################################################################### 7 # 6.1 Object Protocol 8 ##################################################################### 9 int PyObject_Print(object o, FILE *fp, int flags) except -1 10 # Print an object o, on file fp. Returns -1 on error. The flags 11 # argument is used to enable certain printing options. The only 12 # option currently supported is Py_PRINT_RAW; if given, the str() 13 # of the object is written instead of the repr(). 14 15 bint PyObject_HasAttrString(object o, char *attr_name) 16 # Returns 1 if o has the attribute attr_name, and 0 17 # otherwise. This is equivalent to the Python expression 18 # "hasattr(o, attr_name)". This function always succeeds. 19 20 object PyObject_GetAttrString(object o, char *attr_name) 21 # Return value: New reference. Retrieve an attribute named 22 # attr_name from object o. Returns the attribute value on success, 23 # or NULL on failure. This is the equivalent of the Python 24 # expression "o.attr_name". 25 26 bint PyObject_HasAttr(object o, object attr_name) 27 # Returns 1 if o has the attribute attr_name, and 0 28 # otherwise. This is equivalent to the Python expression 29 # "hasattr(o, attr_name)". This function always succeeds. 30 31 object PyObject_GetAttr(object o, object attr_name) 32 # Return value: New reference. Retrieve an attribute named 33 # attr_name from object o. Returns the attribute value on success, 34 # or NULL on failure. This is the equivalent of the Python 35 # expression "o.attr_name". 36 37 int PyObject_SetAttrString(object o, char *attr_name, object v) except -1 38 # Set the value of the attribute named attr_name, for object o, to 39 # the value v. Returns -1 on failure. This is the equivalent of 40 # the Python statement "o.attr_name = v". 41 42 int PyObject_SetAttr(object o, object attr_name, object v) except -1 43 # Set the value of the attribute named attr_name, for object o, to 44 # the value v. Returns -1 on failure. This is the equivalent of 45 # the Python statement "o.attr_name = v". 46 47 int PyObject_DelAttrString(object o, char *attr_name) except -1 48 # Delete attribute named attr_name, for object o. Returns -1 on 49 # failure. This is the equivalent of the Python statement: "del 50 # o.attr_name". 51 52 int PyObject_DelAttr(object o, object attr_name) except -1 53 # Delete attribute named attr_name, for object o. Returns -1 on 54 # failure. This is the equivalent of the Python statement "del 55 # o.attr_name". 56 57 int Py_LT, Py_LE, Py_EQ, Py_NE, Py_GT, Py_GE 58 59 object PyObject_RichCompare(object o1, object o2, int opid) 60 # Return value: New reference. 61 # Compare the values of o1 and o2 using the operation specified by 62 # opid, which must be one of Py_LT, Py_LE, Py_EQ, Py_NE, Py_GT, or 63 # Py_GE, corresponding to <, <=, ==, !=, >, or >= 64 # respectively. This is the equivalent of the Python expression 65 # "o1 op o2", where op is the operator corresponding to 66 # opid. Returns the value of the comparison on success, or NULL on 67 # failure. 68 69 bint PyObject_RichCompareBool(object o1, object o2, int opid) except -1 70 # Compare the values of o1 and o2 using the operation specified by 71 # opid, which must be one of Py_LT, Py_LE, Py_EQ, Py_NE, Py_GT, or 72 # Py_GE, corresponding to <, <=, ==, !=, >, or >= 73 # respectively. Returns -1 on error, 0 if the result is false, 1 74 # otherwise. This is the equivalent of the Python expression "o1 75 # op o2", where op is the operator corresponding to opid. 76 77 int PyObject_Cmp(object o1, object o2, int *result) except -1 78 # Compare the values of o1 and o2 using a routine provided by o1, 79 # if one exists, otherwise with a routine provided by o2. The 80 # result of the comparison is returned in result. Returns -1 on 81 # failure. This is the equivalent of the Python statement "result 82 # = cmp(o1, o2)". 83 84 int PyObject_Compare(object o1, object o2) except * 85 # Compare the values of o1 and o2 using a routine provided by o1, 86 # if one exists, otherwise with a routine provided by o2. Returns 87 # the result of the comparison on success. On error, the value 88 # returned is undefined; use PyErr_Occurred() to detect an 89 # error. This is equivalent to the Python expression "cmp(o1, 90 # o2)". 91 92 object PyObject_Repr(object o) 93 # Return value: New reference. 94 # Compute a string representation of object o. Returns the string 95 # representation on success, NULL on failure. This is the 96 # equivalent of the Python expression "repr(o)". Called by the 97 # repr() built-in function and by reverse quotes. 98 99 object PyObject_Str(object o) 100 # Return value: New reference. 101 # Compute a string representation of object o. Returns the string 102 # representation on success, NULL on failure. This is the 103 # equivalent of the Python expression "str(o)". Called by the 104 # str() built-in function and by the print statement. 105 106 object PyObject_Unicode(object o) 107 # Return value: New reference. 108 # Compute a Unicode string representation of object o. Returns the 109 # Unicode string representation on success, NULL on failure. This 110 # is the equivalent of the Python expression "unicode(o)". Called 111 # by the unicode() built-in function. 112 113 bint PyObject_IsInstance(object inst, object cls) except -1 114 # Returns 1 if inst is an instance of the class cls or a subclass 115 # of cls, or 0 if not. On error, returns -1 and sets an 116 # exception. If cls is a type object rather than a class object, 117 # PyObject_IsInstance() returns 1 if inst is of type cls. If cls 118 # is a tuple, the check will be done against every entry in 119 # cls. The result will be 1 when at least one of the checks 120 # returns 1, otherwise it will be 0. If inst is not a class 121 # instance and cls is neither a type object, nor a class object, 122 # nor a tuple, inst must have a __class__ attribute -- the class 123 # relationship of the value of that attribute with cls will be 124 # used to determine the result of this function. 125 126 # Subclass determination is done in a fairly straightforward way, 127 # but includes a wrinkle that implementors of extensions to the 128 # class system may want to be aware of. If A and B are class 129 # objects, B is a subclass of A if it inherits from A either 130 # directly or indirectly. If either is not a class object, a more 131 # general mechanism is used to determine the class relationship of 132 # the two objects. When testing if B is a subclass of A, if A is 133 # B, PyObject_IsSubclass() returns true. If A and B are different 134 # objects, B's __bases__ attribute is searched in a depth-first 135 # fashion for A -- the presence of the __bases__ attribute is 136 # considered sufficient for this determination. 137 138 bint PyObject_IsSubclass(object derived, object cls) except -1 139 # Returns 1 if the class derived is identical to or derived from 140 # the class cls, otherwise returns 0. In case of an error, returns 141 # -1. If cls is a tuple, the check will be done against every 142 # entry in cls. The result will be 1 when at least one of the 143 # checks returns 1, otherwise it will be 0. If either derived or 144 # cls is not an actual class object (or tuple), this function uses 145 # the generic algorithm described above. New in version 146 # 2.1. Changed in version 2.3: Older versions of Python did not 147 # support a tuple as the second argument. 148 149 bint PyCallable_Check(object o) 150 # Determine if the object o is callable. Return 1 if the object is 151 # callable and 0 otherwise. This function always succeeds. 152 153 object PyObject_Call(object callable_object, object args, object kw) 154 # Return value: New reference. 155 # Call a callable Python object callable_object, with arguments 156 # given by the tuple args, and named arguments given by the 157 # dictionary kw. If no named arguments are needed, kw may be 158 # NULL. args must not be NULL, use an empty tuple if no arguments 159 # are needed. Returns the result of the call on success, or NULL 160 # on failure. This is the equivalent of the Python expression 161 # "apply(callable_object, args, kw)" or "callable_object(*args, 162 # **kw)". 163 164 object PyObject_CallObject(object callable_object, object args) 165 # Return value: New reference. 166 # Call a callable Python object callable_object, with arguments 167 # given by the tuple args. If no arguments are needed, then args 168 # may be NULL. Returns the result of the call on success, or NULL 169 # on failure. This is the equivalent of the Python expression 170 # "apply(callable_object, args)" or "callable_object(*args)". 171 172 object PyObject_CallFunction(object callable, char *format, ...) 173 # Return value: New reference. 174 # Call a callable Python object callable, with a variable number 175 # of C arguments. The C arguments are described using a 176 # Py_BuildValue() style format string. The format may be NULL, 177 # indicating that no arguments are provided. Returns the result of 178 # the call on success, or NULL on failure. This is the equivalent 179 # of the Python expression "apply(callable, args)" or 180 # "callable(*args)". Note that if you only pass object args, 181 # PyObject_CallFunctionObjArgs is a faster alternative. 182 183 object PyObject_CallMethod(object o, char *method, char *format, ...) 184 # Return value: New reference. 185 # Call the method named method of object o with a variable number 186 # of C arguments. The C arguments are described by a 187 # Py_BuildValue() format string that should produce a tuple. The 188 # format may be NULL, indicating that no arguments are 189 # provided. Returns the result of the call on success, or NULL on 190 # failure. This is the equivalent of the Python expression 191 # "o.method(args)". Note that if you only pass object args, 192 # PyObject_CallMethodObjArgs is a faster alternative. 193 194 #object PyObject_CallFunctionObjArgs(object callable, ..., NULL) 195 object PyObject_CallFunctionObjArgs(object callable, ...) 196 # Return value: New reference. 197 # Call a callable Python object callable, with a variable number 198 # of PyObject* arguments. The arguments are provided as a variable 199 # number of parameters followed by NULL. Returns the result of the 200 # call on success, or NULL on failure. 201 202 #PyObject* PyObject_CallMethodObjArgs(object o, object name, ..., NULL) 203 object PyObject_CallMethodObjArgs(object o, object name, ...) 204 # Return value: New reference. 205 # Calls a method of the object o, where the name of the method is 206 # given as a Python string object in name. It is called with a 207 # variable number of PyObject* arguments. The arguments are 208 # provided as a variable number of parameters followed by 209 # NULL. Returns the result of the call on success, or NULL on 210 # failure. 211 212 long PyObject_Hash(object o) except? -1 213 # Compute and return the hash value of an object o. On failure, 214 # return -1. This is the equivalent of the Python expression 215 # "hash(o)". 216 217 bint PyObject_IsTrue(object o) except -1 218 # Returns 1 if the object o is considered to be true, and 0 219 # otherwise. This is equivalent to the Python expression "not not 220 # o". On failure, return -1. 221 222 bint PyObject_Not(object o) except -1 223 # Returns 0 if the object o is considered to be true, and 1 224 # otherwise. This is equivalent to the Python expression "not 225 # o". On failure, return -1. 226 227 object PyObject_Type(object o) 228 # Return value: New reference. 229 # When o is non-NULL, returns a type object corresponding to the 230 # object type of object o. On failure, raises SystemError and 231 # returns NULL. This is equivalent to the Python expression 232 # type(o). This function increments the reference count of the 233 # return value. There's really no reason to use this function 234 # instead of the common expression o->ob_type, which returns a 235 # pointer of type PyTypeObject*, except when the incremented 236 # reference count is needed. 237 238 bint PyObject_TypeCheck(object o, PyTypeObject *type) 239 # Return true if the object o is of type type or a subtype of 240 # type. Both parameters must be non-NULL. 241 242 Py_ssize_t PyObject_Length(object o) except -1 243 Py_ssize_t PyObject_Size(object o) except -1 244 # Return the length of object o. If the object o provides either 245 # the sequence and mapping protocols, the sequence length is 246 # returned. On error, -1 is returned. This is the equivalent to 247 # the Python expression "len(o)". 248 249 object PyObject_GetItem(object o, object key) 250 # Return value: New reference. 251 # Return element of o corresponding to the object key or NULL on 252 # failure. This is the equivalent of the Python expression 253 # "o[key]". 254 255 int PyObject_SetItem(object o, object key, object v) except -1 256 # Map the object key to the value v. Returns -1 on failure. This 257 # is the equivalent of the Python statement "o[key] = v". 258 259 int PyObject_DelItem(object o, object key) except -1 260 # Delete the mapping for key from o. Returns -1 on failure. This 261 # is the equivalent of the Python statement "del o[key]". 262 263 int PyObject_AsFileDescriptor(object o) except -1 264 # Derives a file-descriptor from a Python object. If the object is 265 # an integer or long integer, its value is returned. If not, the 266 # object's fileno() method is called if it exists; the method must 267 # return an integer or long integer, which is returned as the file 268 # descriptor value. Returns -1 on failure. 269 270 object PyObject_Dir(object o) 271 # Return value: New reference. 272 # This is equivalent to the Python expression "dir(o)", returning 273 # a (possibly empty) list of strings appropriate for the object 274 # argument, or NULL if there was an error. If the argument is 275 # NULL, this is like the Python "dir()", returning the names of 276 # the current locals; in this case, if no execution frame is 277 # active then NULL is returned but PyErr_Occurred() will return 278 # false. 279 280 object PyObject_GetIter(object o) 281 # Return value: New reference. 282 # This is equivalent to the Python expression "iter(o)". It 283 # returns a new iterator for the object argument, or the object 284 # itself if the object is already an iterator. Raises TypeError 285 # and returns NULL if the object cannot be iterated. 286 287 Py_ssize_t Py_SIZE(object o) 288 289 object PyObject_Format(object obj, object format_spec) 290 # Takes an arbitrary object and returns the result of calling 291 # obj.__format__(format_spec). 292 # Added in Py2.6 293
