python-c-api

In a Python extension module I've written in C++, I use the following snippet of code to convert a NumPy array into an Armadillo array for use in the C++ portion of the code: static arma::mat convertPyArrayToArma(PyArrayObject* pyarr, int nrows, int ncols) { // Check if the dimensions are what I expect. if (!checkPyArrayDimensions(pyarr, nrows, ncols)) throw WrongDimensions(); const std::vector<int> dims = getPyArrayDimensions(pyarr); // Gets the dimensions using the API PyArray_Descr* reqDescr = PyArray_DescrFromType(NPY_DOUBLE); if (reqDescr == NULL) throw std::bad_alloc(); // Convert the

I wanted to implement a library I have written for python in C using the C-API of python. In python I can declare "constants" in my module by just stating: RED = "red" # Not really a constant, I know BLUE = "blue" # but suitable, nevertheless def solve(img_h): # Awesome computations return (RED, BLUE)[some_flag] Those constants are then later returned by the functions offered by the module. I have some trouble doing the same thing in C. Here is what I got so far: PyMODINIT_FUNC PyInit_puzzler(void) { PyObject* module = PyModule_Create(&Module); (void) PyModule_AddStringConstant(module, "BLUE",

The function PyObject* PyArray_TypeObjectFromType(int); converts the type number for a NumPy scalar type (NPY_BOOL, NPY_BYTE, ...) to the corresponding type object. How do you do the opposite conversion, from the type object for a NumPy scalar type to the corresponding type number? Edit: The following code is based on kwatford's answer. It accepts both type objects such as int and numpy.int16, and strings such as "int", u"int" and "int16". int numpyScalarTypeNumber(PyObject* obj) { PyArray_Descr* dtype; if(!PyArray_DescrConverter(obj, &dtype)) return NPY_NOTYPE; int typeNum = dtype->type_num;

I have a Python extension module which creates a tuple as an attribute of another object, and sets items in the tuple. Whenever I execute this module in Python, I keep getting the error SystemError: bad argument to internal function After reading over the docs for PyTuple , and debugging my program for a few hours, I still couldn't figure out what the hell was going on. Running my program through a debugger indicated the problem was occurring within a library call inside the Python interpreter. So, finally, I looked at the Python source code, and at long last I realized the problem. The

When messing around with Python.h I got this error: AttributeError: 'module' object has no attribute 'argv' C++ code: #include "stdafx.h" #include "C:/Python27/include/Python.h" #include <iostream> using namespace std; int main() { Py_Initialize(); PyRun_SimpleString("import sys\nprint sys.argv[0]"); } Which in Python is: import sys print sys.argv[0] What am I missing? Conceptually, sys.argv should contain the arguments that Python was called with (and what it was called under). What should it have if it were called like this, though? You can load the calling program's argv into sys , if you

How is __slots__ implemented in Python? Is this exposed in the C interface ? How do I get __slots__ behaviour when defining a Python class in C via PyTypeObject ? When creating Python classes, they by default have a __dict__ and you can set any attribute on them. The point of slots is to not create a __dict__ to save space. In the C interface it's the other way around, an extension class has by default no __dict__ , and you would instead explicitly have to add one and add getattr/setattr support to handle it (although luckily there are methods for this already, PyObject_GenericGetAttr and

The problem is that now, I have to use the Posix C getline function to get the line from the file, only then convert it to a Python Unicode Object using PyUnicode_DecodeUTF8 and cache it using my caching policy algorithm. This process is losing 23% of performance compared to Python builtin for line in file C implementation. If I remove the PyUnicode_DecodeUTF8 call from my code, then, my implementation using the Posix C getline becomes 5% faster than the Python builtin for line in file C implementation. So, if I can just make Python directly give me a Python Unicode String object, instead of

How to parse userdefined types (or types from an existing non-standard library) using PyArg_ParseTuple ? Instead of using the plain O format, as Martijn suggested, I normally prefer using the O& format . It allows you to pass a function that will be called to convert any PyObject* to an arbitrary C (double) pointer. Here is some example usage, in which I'm converting a passed value to a pointer to my own object type: /** * This method should return 0 if it does not work or 1 in case it does * PyArg_*() functions will handle the rest from there or let your program * continue in case things are