266 lines
8.7 KiB
C
266 lines
8.7 KiB
C
|
/*
|
||
|
|
pybind11/iostream.h -- Tools to assist with redirecting cout and cerr to Python
|
||
|
|
|
||
|
|
Copyright (c) 2017 Henry F. Schreiner
|
||
|
|
|
||
|
|
All rights reserved. Use of this source code is governed by a
|
||
|
|
BSD-style license that can be found in the LICENSE file.
|
||
|
|
|
||
|
|
WARNING: The implementation in this file is NOT thread safe. Multiple
|
||
|
|
threads writing to a redirected ostream concurrently cause data races
|
||
|
|
and potentially buffer overflows. Therefore it is currently a requirement
|
||
|
|
that all (possibly) concurrent redirected ostream writes are protected by
|
||
|
|
a mutex.
|
||
|
|
#HelpAppreciated: Work on iostream.h thread safety.
|
||
|
|
For more background see the discussions under
|
||
|
|
https://github.com/pybind/pybind11/pull/2982 and
|
||
|
|
https://github.com/pybind/pybind11/pull/2995.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#pragma once
|
||
|
|
|
||
|
|
#include "pybind11.h"
|
||
|
|
|
||
|
|
#include <algorithm>
|
||
|
|
#include <cstring>
|
||
|
|
#include <iostream>
|
||
|
|
#include <iterator>
|
||
|
|
#include <memory>
|
||
|
|
#include <ostream>
|
||
|
|
#include <streambuf>
|
||
|
|
#include <string>
|
||
|
|
#include <utility>
|
||
|
|
|
||
|
|
PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
|
||
|
|
PYBIND11_NAMESPACE_BEGIN(detail)
|
||
|
|
|
||
|
|
// Buffer that writes to Python instead of C++
|
||
|
|
class pythonbuf : public std::streambuf {
|
||
|
|
private:
|
||
|
|
using traits_type = std::streambuf::traits_type;
|
||
|
|
|
||
|
|
const size_t buf_size;
|
||
|
|
std::unique_ptr<char[]> d_buffer;
|
||
|
|
object pywrite;
|
||
|
|
object pyflush;
|
||
|
|
|
||
|
|
int overflow(int c) override {
|
||
|
|
if (!traits_type::eq_int_type(c, traits_type::eof())) {
|
||
|
|
*pptr() = traits_type::to_char_type(c);
|
||
|
|
pbump(1);
|
||
|
|
}
|
||
|
|
return sync() == 0 ? traits_type::not_eof(c) : traits_type::eof();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Computes how many bytes at the end of the buffer are part of an
|
||
|
|
// incomplete sequence of UTF-8 bytes.
|
||
|
|
// Precondition: pbase() < pptr()
|
||
|
|
size_t utf8_remainder() const {
|
||
|
|
const auto rbase = std::reverse_iterator<char *>(pbase());
|
||
|
|
const auto rpptr = std::reverse_iterator<char *>(pptr());
|
||
|
|
auto is_ascii = [](char c) { return (static_cast<unsigned char>(c) & 0x80) == 0x00; };
|
||
|
|
auto is_leading = [](char c) { return (static_cast<unsigned char>(c) & 0xC0) == 0xC0; };
|
||
|
|
auto is_leading_2b = [](char c) { return static_cast<unsigned char>(c) <= 0xDF; };
|
||
|
|
auto is_leading_3b = [](char c) { return static_cast<unsigned char>(c) <= 0xEF; };
|
||
|
|
// If the last character is ASCII, there are no incomplete code points
|
||
|
|
if (is_ascii(*rpptr)) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
// Otherwise, work back from the end of the buffer and find the first
|
||
|
|
// UTF-8 leading byte
|
||
|
|
const auto rpend = rbase - rpptr >= 3 ? rpptr + 3 : rbase;
|
||
|
|
const auto leading = std::find_if(rpptr, rpend, is_leading);
|
||
|
|
if (leading == rbase) {
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
const auto dist = static_cast<size_t>(leading - rpptr);
|
||
|
|
size_t remainder = 0;
|
||
|
|
|
||
|
|
if (dist == 0) {
|
||
|
|
remainder = 1; // 1-byte code point is impossible
|
||
|
|
} else if (dist == 1) {
|
||
|
|
remainder = is_leading_2b(*leading) ? 0 : dist + 1;
|
||
|
|
} else if (dist == 2) {
|
||
|
|
remainder = is_leading_3b(*leading) ? 0 : dist + 1;
|
||
|
|
}
|
||
|
|
// else if (dist >= 3), at least 4 bytes before encountering an UTF-8
|
||
|
|
// leading byte, either no remainder or invalid UTF-8.
|
||
|
|
// Invalid UTF-8 will cause an exception later when converting
|
||
|
|
// to a Python string, so that's not handled here.
|
||
|
|
return remainder;
|
||
|
|
}
|
||
|
|
|
||
|
|
// This function must be non-virtual to be called in a destructor.
|
||
|
|
int _sync() {
|
||
|
|
if (pbase() != pptr()) { // If buffer is not empty
|
||
|
|
gil_scoped_acquire tmp;
|
||
|
|
// This subtraction cannot be negative, so dropping the sign.
|
||
|
|
auto size = static_cast<size_t>(pptr() - pbase());
|
||
|
|
size_t remainder = utf8_remainder();
|
||
|
|
|
||
|
|
if (size > remainder) {
|
||
|
|
str line(pbase(), size - remainder);
|
||
|
|
pywrite(std::move(line));
|
||
|
|
pyflush();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Copy the remainder at the end of the buffer to the beginning:
|
||
|
|
if (remainder > 0) {
|
||
|
|
std::memmove(pbase(), pptr() - remainder, remainder);
|
||
|
|
}
|
||
|
|
setp(pbase(), epptr());
|
||
|
|
pbump(static_cast<int>(remainder));
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
int sync() override { return _sync(); }
|
||
|
|
|
||
|
|
public:
|
||
|
|
explicit pythonbuf(const object &pyostream, size_t buffer_size = 1024)
|
||
|
|
: buf_size(buffer_size), d_buffer(new char[buf_size]), pywrite(pyostream.attr("write")),
|
||
|
|
pyflush(pyostream.attr("flush")) {
|
||
|
|
setp(d_buffer.get(), d_buffer.get() + buf_size - 1);
|
||
|
|
}
|
||
|
|
|
||
|
|
pythonbuf(pythonbuf &&) = default;
|
||
|
|
|
||
|
|
/// Sync before destroy
|
||
|
|
~pythonbuf() override { _sync(); }
|
||
|
|
};
|
||
|
|
|
||
|
|
PYBIND11_NAMESPACE_END(detail)
|
||
|
|
|
||
|
|
/** \rst
|
||
|
|
This a move-only guard that redirects output.
|
||
|
|
|
||
|
|
.. code-block:: cpp
|
||
|
|
|
||
|
|
#include <pybind11/iostream.h>
|
||
|
|
|
||
|
|
...
|
||
|
|
|
||
|
|
{
|
||
|
|
py::scoped_ostream_redirect output;
|
||
|
|
std::cout << "Hello, World!"; // Python stdout
|
||
|
|
} // <-- return std::cout to normal
|
||
|
|
|
||
|
|
You can explicitly pass the c++ stream and the python object,
|
||
|
|
for example to guard stderr instead.
|
||
|
|
|
||
|
|
.. code-block:: cpp
|
||
|
|
|
||
|
|
{
|
||
|
|
py::scoped_ostream_redirect output{
|
||
|
|
std::cerr, py::module::import("sys").attr("stderr")};
|
||
|
|
std::cout << "Hello, World!";
|
||
|
|
}
|
||
|
|
\endrst */
|
||
|
|
class scoped_ostream_redirect {
|
||
|
|
protected:
|
||
|
|
std::streambuf *old;
|
||
|
|
std::ostream &costream;
|
||
|
|
detail::pythonbuf buffer;
|
||
|
|
|
||
|
|
public:
|
||
|
|
explicit scoped_ostream_redirect(std::ostream &costream = std::cout,
|
||
|
|
const object &pyostream
|
||
|
|
= module_::import("sys").attr("stdout"))
|
||
|
|
: costream(costream), buffer(pyostream) {
|
||
|
|
old = costream.rdbuf(&buffer);
|
||
|
|
}
|
||
|
|
|
||
|
|
~scoped_ostream_redirect() { costream.rdbuf(old); }
|
||
|
|
|
||
|
|
scoped_ostream_redirect(const scoped_ostream_redirect &) = delete;
|
||
|
|
scoped_ostream_redirect(scoped_ostream_redirect &&other) = default;
|
||
|
|
scoped_ostream_redirect &operator=(const scoped_ostream_redirect &) = delete;
|
||
|
|
scoped_ostream_redirect &operator=(scoped_ostream_redirect &&) = delete;
|
||
|
|
};
|
||
|
|
|
||
|
|
/** \rst
|
||
|
|
Like `scoped_ostream_redirect`, but redirects cerr by default. This class
|
||
|
|
is provided primary to make ``py::call_guard`` easier to make.
|
||
|
|
|
||
|
|
.. code-block:: cpp
|
||
|
|
|
||
|
|
m.def("noisy_func", &noisy_func,
|
||
|
|
py::call_guard<scoped_ostream_redirect,
|
||
|
|
scoped_estream_redirect>());
|
||
|
|
|
||
|
|
\endrst */
|
||
|
|
class scoped_estream_redirect : public scoped_ostream_redirect {
|
||
|
|
public:
|
||
|
|
explicit scoped_estream_redirect(std::ostream &costream = std::cerr,
|
||
|
|
const object &pyostream
|
||
|
|
= module_::import("sys").attr("stderr"))
|
||
|
|
: scoped_ostream_redirect(costream, pyostream) {}
|
||
|
|
};
|
||
|
|
|
||
|
|
PYBIND11_NAMESPACE_BEGIN(detail)
|
||
|
|
|
||
|
|
// Class to redirect output as a context manager. C++ backend.
|
||
|
|
class OstreamRedirect {
|
||
|
|
bool do_stdout_;
|
||
|
|
bool do_stderr_;
|
||
|
|
std::unique_ptr<scoped_ostream_redirect> redirect_stdout;
|
||
|
|
std::unique_ptr<scoped_estream_redirect> redirect_stderr;
|
||
|
|
|
||
|
|
public:
|
||
|
|
explicit OstreamRedirect(bool do_stdout = true, bool do_stderr = true)
|
||
|
|
: do_stdout_(do_stdout), do_stderr_(do_stderr) {}
|
||
|
|
|
||
|
|
void enter() {
|
||
|
|
if (do_stdout_) {
|
||
|
|
redirect_stdout.reset(new scoped_ostream_redirect());
|
||
|
|
}
|
||
|
|
if (do_stderr_) {
|
||
|
|
redirect_stderr.reset(new scoped_estream_redirect());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void exit() {
|
||
|
|
redirect_stdout.reset();
|
||
|
|
redirect_stderr.reset();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
PYBIND11_NAMESPACE_END(detail)
|
||
|
|
|
||
|
|
/** \rst
|
||
|
|
This is a helper function to add a C++ redirect context manager to Python
|
||
|
|
instead of using a C++ guard. To use it, add the following to your binding code:
|
||
|
|
|
||
|
|
.. code-block:: cpp
|
||
|
|
|
||
|
|
#include <pybind11/iostream.h>
|
||
|
|
|
||
|
|
...
|
||
|
|
|
||
|
|
py::add_ostream_redirect(m, "ostream_redirect");
|
||
|
|
|
||
|
|
You now have a Python context manager that redirects your output:
|
||
|
|
|
||
|
|
.. code-block:: python
|
||
|
|
|
||
|
|
with m.ostream_redirect():
|
||
|
|
m.print_to_cout_function()
|
||
|
|
|
||
|
|
This manager can optionally be told which streams to operate on:
|
||
|
|
|
||
|
|
.. code-block:: python
|
||
|
|
|
||
|
|
with m.ostream_redirect(stdout=true, stderr=true):
|
||
|
|
m.noisy_function_with_error_printing()
|
||
|
|
|
||
|
|
\endrst */
|
||
|
|
inline class_<detail::OstreamRedirect>
|
||
|
|
add_ostream_redirect(module_ m, const std::string &name = "ostream_redirect") {
|
||
|
|
return class_<detail::OstreamRedirect>(std::move(m), name.c_str(), module_local())
|
||
|
|
.def(init<bool, bool>(), arg("stdout") = true, arg("stderr") = true)
|
||
|
|
.def("__enter__", &detail::OstreamRedirect::enter)
|
||
|
|
.def("__exit__", [](detail::OstreamRedirect &self_, const args &) { self_.exit(); });
|
||
|
|
}
|
||
|
|
|
||
|
|
PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
|