C API : Creating a Py_Method object from a C function.

[Hugh Macdonald]

I've got a pure python module that parses a certain type of file. It
has a load() function that allows a callback function to be passed for
getting progress information.

In straight python, this works fine.

However, I'm now trying to use this from a C++ program. The current
flow that I'm trying to get is as follows:

C++ calls python interface function, passing a C++ function pointer
Python interface function stores C++ function pointer
Python interface function generates new Py_Object method pointer
pointing to a different C python function. (This different function
calls the stored C++ function pointer)
Python interface function calls python function
Python function calls the python method pointer it was passed
C python function then calls the stored C++ function pointer.
The problem in this workflow is taking the C python function that I've
defined (using the standard "static PyObject *someFunction(P yObject
*self, PyObject *args)" method) and converting this into a Py_Object.
Any ideas?

Py_Method doesn't seem to allow you to generate a new one with your own
pointers inside... and I can't see anything else in the docs that might
allow me to do this...
Thanks for any advice!

--
Hugh Macdonald

[Martin v. Löwis]

Hugh Macdonald wrote:

The problem in this workflow is taking the C python function that I've
defined (using the standard "static PyObject *someFunction(P yObject
*self, PyObject *args)" method) and converting this into a Py_Object.
Any ideas?

You should use PyCFunction_New (Ex), passing a static PyMethodDef
variable that you define along with your function definition.

Regards,
Martin

[Hugh Macdonald]

Thanks Martin - that worked wonderfully....
For the record (and for anyone searching for this in future), here's
the code that worked (with names changed to protect my job...)
myPython is the C++/Python interface class containing static methods
which pass on calls to the underlying python module. It's not really
commented, but if you're trying to do this kind of thing, it should
give you what you need.

----------------------------------------------------------------------------------------------------
// myPython.h

#ifndef ___MYPYTHON_H__ _
#define ___MYPYTHON_H__ _

#include <list>

using namespace std;

typedef struct _object PyObject;
typedef void (*loadCallback) (string message, int progress, void
*callbackData);

static PyObject *myPython_doLoa dCallback(PyObj ect *self,
PyObject *args);

class myPython {
public:
static list<string> *loadDetails(st ring file, loadCallback
callbackFunc = NULL, void *callbackData = NULL);
static void doLoadCallback( string message, int
progress);
private:
static PyObject *getResults(cha r *moduleName, char
*functionName, PyObject *args);

static loadCallback callbackFunc;
static void *callbackData;
};

#endif // ___MYPYTHON_H__ _
----------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------
// myPython.cpp

#include <myPython.h>
#include <Python.h>

loadCallback myPython::callb ackFunc = NULL;
void *myPython::call backData = NULL;

list<string> *myPython::load Details(string file, loadCallback
newCallbackFunc , void *newCallbackDat a)
{
PyObject *pArgs, *pResult;

callbackFunc = newCallbackFunc ;
callbackData = newCallbackData ;

PyMethodDef *callbackFuncti onDef = new PyMethodDef;
callbackFunctio nDef->ml_name = "doLoadCallback ";
callbackFunctio nDef->ml_meth = &myPython_doLoa dCallback;
callbackFunctio nDef->ml_flags = 1;

PyObject *pyCallbackFunc = PyCFunction_New (callbackFuncti onDef,
NULL);

pArgs = Py_BuildValue(" (sO)", file.c_str(), pyCallbackFunc) ;

pResult = getResults("myP ythonModule", "loadDetail s", pArgs);

if(!pResult)
{
Py_DECREF(pArgs );
return NULL;
}

if(PyList_Check (pResult))
{
// Convert pResult into a list<string> and return that.
}

return NULL;
}

PyObject *myPython_doLoa dCallback(PyObj ect *self, PyObject *args)
{
char *message;
int progress;

if(!PyArg_Parse Tuple(args, "si", &message, &progress))
return NULL;

myPython::doLoa dCallback(messa ge, progress);

return Py_None;
}

void myPython::doLoa dCallback(strin g message, int progress)
{
if(callbackFunc )
callbackFunc(me ssage, progress, callbackData);
}
----------------------------------------------------------------------------------------------------

[Martin v. Löwis]

Hugh Macdonald wrote:

PyMethodDef *callbackFuncti onDef = new PyMethodDef;
callbackFunctio nDef->ml_name = "doLoadCallback ";
callbackFunctio nDef->ml_meth = &myPython_doLoa dCallback;
callbackFunctio nDef->ml_flags = 1;

I think this gives a memory leak. I was rather thinking of

static PyMethodDef doLoadCallback = {
"doLoadCallback ", &myPython_doLoa dCallback, 1
};

PyObject *pyCallbackFunc = PyCFunction_New (&doLoadCallbac k,
NULL);

Since you have to write the C(++) functions statically, you can also
provide the PyMethodDef objects statically.

Regards,
Martin