python-c-api

I am trying to embed some python in my pet project. I have reduced my problem to the following code: #include <Python.h> #include "iostream" int main(int argc, char *argv[]) { Py_Initialize(); PyObject *globals = Py_BuildValue("{}"); PyObject *locals = Py_BuildValue("{}"); PyObject *string_result = PyRun_StringFlags( "a=5\n" "s='hello'\n" "d=dict()\n" , Py_file_input, globals, locals, NULL); if ( PyErr_Occurred() ) {PyErr_Print();PyErr_Clear();return 1;} return 0; } (I know I'm not cleaning up any references. This is an example.) it can be compiled by c++ $(python-config --includes) $(python

I am writing C extensions, and I'd like to make the signature of my methods visible for introspection. static PyObject* foo(PyObject *self, PyObject *args) { /* blabla [...] */ } PyDoc_STRVAR( foo_doc, "Great example function\n" "Arguments: (timeout, flags=None)\n" "Doc blahblah doc doc doc."); static PyMethodDef methods[] = { {"foo", foo, METH_VARARGS, foo_doc}, {NULL}, }; PyMODINIT_FUNC init_myexample(void) { (void) Py_InitModule3("_myexample", methods, "a simple example module"); } Now if (after building it...) I load the module and look at its help: >>> import _myexample >>> help(

The C API in Python 3.0 has changed (deprecated) many of the functions for File Objects. Before, in 2.X, you could use PyObject* PyFile_FromString(char *filename, char *mode) to create a Python file object, e.g: PyObject *myFile = PyFile_FromString("test.txt", "r"); ...but such function no longer exists in Python 3.0. What would be the Python 3.0 equivalent to such call? You can do it the old(new?)-fashioned way, by just calling the io module. This code works, but it does no error checking. See the docs for explanation. PyObject *ioMod, *openedFile; PyGILState_STATE gilState = PyGILState

So, I generally have a pretty good understanding of how the Global Interpreter Lock (GIL) in Python works. Essentially, while the interpreter is running, one thread holds the GIL for N ticks (where N can be set using sys.setcheckinterval ), at which point the GIL is released and another thread can acquire the GIL. The also happens if one thread begins an I/O operation. What I'm a bit confused about is how this all works with C extension modules. If you have a C extension module that acquires the GIL, and then executes some python code using PyEval_EvalCode , can the interpreter release the GIL

Consider the following class: class SquareErrorDistance(object): def __init__(self, dataSample): variance = var(list(dataSample)) if variance == 0: self._norm = 1.0 else: self._norm = 1.0 / (2 * variance) def __call__(self, u, v): # u and v are floats return (u - v) ** 2 * self._norm I use it to calculate the distance between two elements of a vector. I basically create one instance of that class for every dimension of the vector that uses this distance measure (there are dimensions that use other distance measures). Profiling reveals that the __call__ function of this class accounts for 90%

The standard convention in the Python C-API is that functions do not steal references from input arguments (that are objects) return values and output arguments (that are objects) own a reference Most functions in the Python C-API follow this convention. However, there are some exceptions. I have come across the following: Functions that steal a reference from an input argument PyModule_AddObject Functions with return values or output arguments that borrow a reference PyErr_Occurred PyTuple_GetItem PyTuple_GETITEM PyDict_GetItem PyDict_GetItemString PyDict_Next Is there a comprehensive list of