Redirect std::cout

[henryiii]

I'm interested in redirecting std::cout for my functions (some of which are long running library functions that report on progress). Is there an officially sanctioned way to redirect std::cout to python's stdout? (other than the custom pybind11::print function)? Running inside of a Jupyter notebook, for example, requires the output go to Python's stdout to be visible.

After lots of googling and some playing around, I've come up with the following solution, which works well. I can make into a PR if this is useful and not already available. It's at https://github.com/GooFit/GooFit/blob/573044ea20eedc8444f38cc6a7ce66bef27d2524/python/Print.cpp .

[jagerman]

I'm assuming in such a case Python's stdout has been redirected somewhere else, but only at the Python level, not the C level.

I'm mostly just thinking out loud here, but I think it would be nifty if it adapted a RAII-type structure (like py::scoped_interpreter_guard, py::gil_scoped_acquire, etc.), so that you could do something like:

m.def("noisy_func", []() {
    py::scoped_output_redirect redir(std::cout, py::module::import("sys").attr("stdout"));
    call_noisy_func();
});

and have std::cout restored at the end of the call.

[henryiii]

That might be pretty easy to implement with the system I wrote, let me give it a try.

Being able to redirect globally is useful too, but maybe the latter is more in line with PyBind's design. In my case, I think only a few functions are noisy (not sure how often that's the case, but I expect it is somewhat common).

[jagerman]

You could do it globally (at least, as globally as the module loaded within the Python interpreter) with something like:

m.attr("redirect_output") = py::capsule(new py::scoped_output_redirect(...),
    [](void *sor) { delete static_cast<py::scoped_output_redirect *>(sor); });

or for an uglier but simpler version you could just leak the instance:

new py::scoped_output_redirect(...);

(though the latter would probably not work nicely if anything tried to print after the Python interpreter has gone away, i.e. during global destruction or after an embedded interpreter shutdown).