#
5.3 Pure Embedding

The first program aims to execute a function in a Python script. Like in the section about the very high level interface, the Python interpreter does not directly interact with the application (but that will change in th next section).

The code to run a function defined in a Python script is:

      #include <Python.h>

      int
      main(int argc, char *argv[])
      {
          PyObject *pName, *pModule, *pDict, *pFunc;
          PyObject *pArgs, *pValue;
          int i, result;

          if (argc < 3) {
              fprintf(stderr,"Usage: call pythonfile funcname [args]\n");
              return 1;
          }

          Py_Initialize();
          pName = PyString_FromString(argv[1]);
          /* Error checking of pName left out */

          pModule = PyImport_Import(pName);
          if (pModule != NULL) {
              pDict = PyModule_GetDict(pModule);
              /* pDict is a borrowed reference */

              pFunc = PyDict_GetItemString(pDict, argv[2]);
              /* pFun: Borrowed reference */

              if (pFunc && PyCallable_Check(pFunc)) {
                  pArgs = PyTuple_New(argc - 3);
                  for (i = 0; i < argc - 3; ++i) {
                      pValue = PyInt_FromLong(atoi(argv[i + 3]));
                      if (!pValue) {
                          fprintf(stderr, "Cannot convert argument\n");
                          return 1;
                      }
                      /* pValue reference stolen here: */
                      PyTuple_SetItem(pArgs, i, pValue);
                  }
                  pValue = PyObject_CallObject(pFunc, pArgs);
                  if (pValue != NULL) {
                      printf("Result of call: %ld\n", PyInt_AsLong(pValue));
                      Py_DECREF(pValue);
                  }
                  else {
                      PyErr_Print();
                      fprintf(stderr,"Call failed\n");
                      return 1;
                  }
                  Py_DECREF(pArgs);
                  /* pDict and pFunc are borrowed and must not be Py_DECREF-ed */
              }
              else {
                  PyErr_Print();
                  fprintf(stderr, "Cannot find function \"%s\"\n", argv[2]);
              }
              Py_DECREF(pModule);
          }
          else {
              PyErr_Print();
              fprintf(stderr, "Failed to load \"%s\"\n", argv[1]);
              return 1;
          }
          Py_DECREF(pName);
          Py_Finalize();
          return 0;
      }

This code loads a Python script using `argv[1]`, and calls the function named in `argv[2]`. Its integer arguments are the other values of the `argv` array. If you compile and link this program (let's call the finished executable call), and use it to execute a Python script, such as:

      def multiply(a,b):
          print "Thy shall add", a, "times", b
          c = 0
          for i in range(0, a):
              c = c + b
          return c

then the result should be:

      $ call multiply 3 2
      Thy shall add 3 times 2
      Result of call: 6

Although the program is quite large for its functionality, most of the code is for data conversion between Python and C, and for error reporting. The interesting part with respect to embedding Python starts with

          Py_Initialize();
          pName = PyString_FromString(argv[1]);
          /* Error checking of pName left out */
          pModule = PyImport_Import(pName);

After initializing the interpreter, the script is loaded using `PyImport_Import()`. This routine needs a Python string as its argument, which is constructed using the `PyString_FromString()` data conversion routine.

          pDict = PyModule_GetDict(pModule);
          /* pDict is a borrowed reference */

          pFunc = PyDict_GetItemString(pDict, argv[2]);
          /* pFun is a borrowed reference */

          if (pFunc && PyCallable_Check(pFunc)) {
              ...
          }

Once the script is loaded, its dictionary is retrieved with `PyModule_GetDict()`. The dictionary is then searched using the normal dictionary access routines for the function name. If the name exists, and the object returned is callable, you can safely assume that it is a function. The program then proceeds by constructing a tuple of arguments as normal. The call to the python function is then made with:

          pValue = PyObject_CallObject(pFunc, pArgs);

Upon return of the function, `pValue` is either `NULL` or it contains a reference to the return value of the function. Be sure to release the reference after examining the value.