Python Namespace Reference

Functions
std::string	print_traceback ()
std::string	whichPython ()
void	initPython (const std::string &path)
void	initPython ()
void	initPythonAndNumpy ()
PyObject *	getClassRef (const std::string &moduleName, const std::string &className)
PyObject *	getFunctionRef (const std::string &moduleName, const std::string &funcName)
template<typename T >
PyObject *	convertToNumpy (const MultidimArray< T > &array)
void	initNumpy ()
template PyObject *	convertToNumpy< double > (MultidimArray< double > const &)
template PyObject *	convertToNumpy< int > (MultidimArray< int > const &)

Function Documentation

convertToNumpy()

template<typename T >

PyObject * Python::convertToNumpy

(

const MultidimArray< T > &

array

)

Create an Numpy reference array wrapper around data. This reference should be release using Py_DECREF() or Py_XDECREF()

Parameters

array

to be wrapped

Returns

a reference to the wrapper

Definition at line 112 of file python_utils.cpp.

                                                        {
    npy_intp dim[3];
    dim[0]=XSIZE(array);
    dim[1]=YSIZE(array);
    dim[2]=ZSIZE(array);
    if (std::is_same<T, int>::value) {
        return PyArray_SimpleNewFromData(3, dim, NPY_INT, array.data);
    } else if (std::is_same<T, double>::value){
       return PyArray_SimpleNewFromData(3, dim, NPY_DOUBLE, array.data);
    } else {
        REPORT_ERROR(ERR_TYPE_INCORRECT, "Not implemented");
    }
}

convertToNumpy< double >()

template PyObject* Python::convertToNumpy< double >

(

MultidimArray< double > const &

)

convertToNumpy< int >()

template PyObject* Python::convertToNumpy< int >

(

MultidimArray< int > const &

)

getClassRef()

PyObject * Python::getClassRef	(	const std::string &	moduleName,
		const std::string &	className
	)

Get a borrowed reference to a Python class This reference should be release using Py_DECREF() or Py_XDECREF()

Parameters

moduleName	name of the module (script file name)
className	name of the class within the module

Returns

a borrowed reference to the class on success or nullptr on error

Definition at line 91 of file python_utils.cpp.

                                                                               {
    PyObject * pName = PyUnicode_FromString(moduleName.c_str());
    PyObject * pModule = PyImport_Import(pName);
    PyObject * pDict = PyModule_GetDict(pModule);
    PyObject * pClass = PyDict_GetItemString(pDict, className.c_str());
    Py_DECREF(pName);
    Py_DECREF(pModule);
    Py_DECREF(pDict);
    return pClass;
}

getFunctionRef()

PyObject * Python::getFunctionRef	(	const std::string &	moduleName,
		const std::string &	funcName
	)

Get a new reference to a Python function This reference should be release using Py_DECREF() or Py_XDECREF()

Parameters

moduleName	name of the module (script file name)
funcName	name of the class within the module

Returns

a new reference to the function on success or nullptr on error

Definition at line 102 of file python_utils.cpp.

                                                                                  {
    PyObject * pName = PyUnicode_FromString(moduleName.c_str());
    PyObject * pModule = PyImport_Import(pName);
    PyObject * pFunc = PyObject_GetAttrString(pModule, funcName.c_str());
    Py_DECREF(pName);
    Py_DECREF(pModule);
    return pFunc;
}

initNumpy()

void Python::initNumpy

(

)

Initialize Numpy arrays. Needs to be called from each compile unit

See also

https://stackoverflow.com/questions/31971185/segfault-when-import-array-not-in-same-translation-unit

Definition at line 126 of file python_utils.cpp.

                 {
#ifndef NUMPY_IMPORT_ARRAY_RETVAL
#define NUMPY_IMPORT_ARRAY_RETVAL NULL
#endif
    auto init = []() -> std::nullptr_t { // explicit on purpose
        import_array();
        return nullptr;
    };
    init();
}

initPython() [1/2]

void Python::initPython

(

const std::string &

path

)

Initialize default Python path will point to the python which has been initialized

Definition at line 64 of file python_utils.cpp.

                                       {
#if PY_MAJOR_VERSION >= 3
#if PY_MINOR_VERSION > 4
    auto program = Py_DecodeLocale(path.c_str(), NULL);
#else // PY_MINOR_VERSION > 4
    std::vector<wchar_t> tmp(path.begin(), path.end());
    auto program = tmp.data();
#endif // PY_MINOR_VERSION > 4
#else // PY_MAJOR_VERSION >= 3
#error Python version >= 3 expected
#endif // PY_MAJOR_VERSION >= 3
    if (nullptr == program) {
        REPORT_ERROR(ERR_VALUE_INCORRECT, "Cannot decode the python path\n");
    }
    Py_SetProgramName(program);
    Py_Initialize();
}

initPython() [2/2]

void Python::initPython

(

)

Initialize default Python

Definition at line 82 of file python_utils.cpp.

                  {
    initPython(whichPython());
}

initPythonAndNumpy()

void Python::initPythonAndNumpy

(

)

Initialize default Python and Numpy

Definition at line 86 of file python_utils.cpp.

                          {
    initPython();
    initNumpy();
}

print_traceback()

std::string Python::print_traceback

(

)

This function outputs traceback of the last exception to the standard output

Definition at line 29 of file python_utils.cpp.

                            {
   PyObject* type;
   PyObject* value;
   PyObject* traceback;

   PyErr_Fetch(&type, &value, &traceback);
   PyErr_NormalizeException(&type, &value, &traceback);

   std::string fcn = "";
   fcn += "def get_pretty_traceback(exc_type, exc_value, exc_tb):\n";
   fcn += "    import sys, traceback\n";
   fcn += "    lines = []\n";
   fcn += "    lines = traceback.format_exception(exc_type, exc_value, exc_tb)\n";
   fcn += "    output = '\\n'.join(lines)\n";
   fcn += "    return output\n";

   PyRun_SimpleString(fcn.c_str());
   PyObject* mod = PyImport_ImportModule("__main__");
   PyObject* method = PyObject_GetAttrString(mod, "get_pretty_traceback");
   PyObject* outStr = PyObject_CallObject(method, Py_BuildValue("OOO", type, value, traceback));
   PyObject* str_exc_type = PyObject_Str(outStr); //Now a unicode
   return PyUnicode_AsUTF8(str_exc_type);
}

whichPython()

std::string Python::whichPython

(

)

Returns path to the default python intrepreter Equivalent to 'which python'

Definition at line 53 of file python_utils.cpp.

                        {
    char path[1035];
    FILE *fp = popen("which python", "r");
    if (fp == NULL)
        REPORT_ERROR(ERR_UNCLASSIFIED,"Cannot execute which python");
    if (fgets(path, sizeof(path)-1, fp) == NULL)
        REPORT_ERROR(ERR_UNCLASSIFIED,"Cannot find python");
    pclose(fp);
    return path;
}