pybind11 C++ Output Redirection to Python with Derived Class

[pa-beaufort]

Hello every1,

I'd like to expose a pure virtual class with a member method that deals with std::ostream& arguments:

class Animal {
public:
    virtual ~Animal() { }
  virtual std::ostream& go(std::ostream& out) const = 0;
};

I have another class that collects objects in a vector derived from this pure virtual class and calls the method dealing with std::ostream& for all collected objects:

class Zoo {
public:
  Zoo() {};
  void add(std::shared_ptr<Animal> animal)
  {
    faune.push_back(animal);
  }
  const std::vector<std::shared_ptr<Animal>>& get() const
  {
    return faune;
  }
  std::ostream& goall(std::ostream& out) const
  {
    out << "---------------\n";
    for(const auto& animal: faune)
      {
	animal->go(out);
	out << "\n";
      }
    out << "_______________\n";
    return out;
  }
private:
  std::vector<std::shared_ptr<Animal>> faune;
};

If I derive the pure virtual class in Python by implementing the member method and then add this object to the collecting class and call the goall method, it fails - while calling go for this derived class works:

class Cat(Animal):

    def go(self, out):
        out.write("meow!\n")
        return out

cat = Cat()
cat.go(sys.stdout)      # <---------------------------- it works

zoo = Zoo()
zoo.add(cat)

zoo.goall(sys.stdout)  # <---------------------------- it fails 

How can I fix the error?

terminate called after throwing an instance of 'pybind11::error_already_set'
  what():  SystemError: <built-in method write of _io.TextIOWrapper object at 0x7faeaf0b5cf0> returned a result with an error set
Aborted (core dumped)

The whole demo is provided below.
I can provide further information if requested :-)

Thanks for your time and help.

---

animals.cpp

//compile with:
//c++ -O3 -Wall -shared -std=c++11 -fPIC $(python3 -m pybind11 --includes) animals.cpp -o animals$(python3-config --extension-suffix)

#include <vector>
#include <memory>
#include <iostream>

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <pybind11/iostream.h>

namespace py = pybind11;


class Animal {
public:
    virtual ~Animal() { }
  virtual std::ostream& go(std::ostream& out) const = 0;
};

class Dog : public Animal {
public:
  std::ostream& go(std::ostream& out) const override {
      out << "woof! \n";
    return out;
  }
};

class Zoo {
public:
  Zoo() {};
  void add(std::shared_ptr<Animal> animal)
  {
    faune.push_back(animal);
  }
  const std::vector<std::shared_ptr<Animal>>& get() const
  {
    return faune;
  }
  std::ostream& goall(std::ostream& out) const
  {
    out << "---------------\n";
    for(const auto& animal: faune)
      {
	animal->go(out);
	out << "\n";
      }
    out << "_______________\n";
    return out;
  }
private:
  std::vector<std::shared_ptr<Animal>> faune;
};


class PyAnimal : public Animal {
public:
    /* Inherit the constructors */
    using Animal::Animal;

    /* Trampoline (need one for each virtual function) */
  std::ostream& go(std::ostream& out) const override {
        PYBIND11_OVERRIDE_PURE(
            std::ostream&, /* Return type */
            Animal,        /* Parent class */
            go,            /* Name of function in C++ (must match Python name) */
            out            /* Argument(s) */
        );
    }
};

class PyDog : public Dog {
public:
    /* Inherit the constructors */
    using Dog::Dog;

    /* Trampoline (need one for each virtual function) */
  std::ostream& go(std::ostream& out) const override {
        PYBIND11_OVERRIDE(
            std::ostream&, /* Return type */
            Dog,           /* Parent class */
            go,            /* Name of function in C++ (must match Python name) */
            out            /* Argument(s) */
        );
    }
};


PYBIND11_MODULE(animals, m) {
  py::class_<Animal, PyAnimal, std::shared_ptr<Animal>>(m, "Animal")
    .def(py::init<>())
    .def("go", &Animal::go);

  py::class_<Dog, Animal, PyDog, std::shared_ptr<Dog>>(m, "Dog")
    .def(py::init<>())
    .def("go",
	 [](const Dog& dog, pybind11::object io )
	 {
	   pybind11::detail::pythonbuf buffer{ io };
	   std::ostream                out{ &buffer };
	   dog.go(out);
	   return io;
	 });

  py::class_<Zoo>(m, "Zoo")
    .def(py::init<>())
    .def("add", &Zoo::add)
    .def("get", &Zoo::get)
    .def("goall",
	 [](const Zoo& zoo, pybind11::object io )
	 {
	   pybind11::detail::pythonbuf buffer{ io };
	   std::ostream                out{ &buffer };
	   zoo.goall(out);
	   return io;
	 });
}

test.py

from animals import Animal, Dog, Zoo
import sys

class Cat(Animal):
    def go(self, out):
        out.write("meow!\n")
        return out

zoo = Zoo()
dog = Dog()
dog.go(sys.stdout)
zoo.add(dog)
cat = Cat()
out = cat.go(sys.stdout)
out.write("??")
zoo.add(cat)


for i, animal in enumerate(zoo.get()):
    print(i, animal.go(sys.stdout))
myfile = open("thefile", "w")
zoo.goall(myfile)