Custom Print for Enum

[jgannon65]

I have a lot of enum's that are being used as bitmasks in my program. I've created a _enum for them, and it works fine, except when there are multiple values set, the str and repr method outputs ???. I would like to override these methods, but it doesn't seem to be working. Is there a way to work around this?

[jiwaszki]

Hi @jgannon65 , you can always "reverse-engineer" original code of pybind11. So going to the code snippet:

#include <pybind11/pybind11.h>

namespace py = pybind11;

enum Animal
{
  Dog = 0,
  Cat = 1
};

enum House
{
  Door = 0,
  Floor = 1
};

PYBIND11_MODULE(foo, module)
{
  py::enum_<House> house(module, "House");

  house.value("Door", House::Door);
  house.value("Floor", House::Floor);
  house.export_values();

  py::enum_<Animal> animal(module, "Animal");

  animal.value("Dog", Animal::Dog);
  animal.value("Cat", Animal::Cat);
  animal.export_values();

  animal.def(
      "__str__", [](const py::object &arg) -> py::str
      {
        py::handle type = py::type::handle_of(arg);
        py::object type_name = type.attr("__name__");
        return py::str("{} called {} with number {}").format(type_name, py::detail::enum_name(arg), py::int_(arg));
      },
      py::name("__str__"), py::is_method(module));

  animal.def(
      "__repr__", [](const py::object &arg) -> py::str
      { return py::str("__repr__ of {}").format(py::int_(arg)); },
      py::name("__repr__"), py::is_method(module));
}

>>> print(foo.House.Door)
House.Door
>>> print(foo.House.Floor)
House.Floor
>>> foo.House.Door
<House.Door: 0>
>>> foo.House.Floor
<House.Floor: 1>
>>> print(foo.Animal.Dog)
Animal called Dog with number 0
>>> print(foo.Animal.Cat)
Animal called Cat with number 1
>>> foo.Animal.Dog
__repr__ of 0
>>> foo.Animal.Cat
__repr__ of 1

I added a House enum just to show that overloading affects only specific enum. What code will end inside lambda is up to you now 🚀 You can always override it in pybind11.h style, however I think that .def() is cleaner solution.

animal.attr("__repr__") = py::cpp_function([](const py::object &arg) -> py::str
                                            { return py::str("__repr__ of {}").format(py::int_(arg)); },
                                            py::name("__repr__"), py::is_method(module));

[jgannon65]

Thank you @jiwaszki, for the response. Adding py::is_method(handle) to my overload allowed it to work, but if I remove that it defaults to the built in str method for enums. Why is that?

[jiwaszki]

I guess this is how implementation works currently. To give some context on this here is the PR that changes the internals of enum_ class. The method __repr__ is now moved outside of the class itself to so called enum_base (which corresponds to handle mentioned by you, passed down from call to enum_ ctor). Since inside this base structure all the methods are annotated somehow, your code needs to align to it.

However you can easily overwrite existing function in enum_. If __repr__ was still a part of the class like in mentioned PR -- I assume that there would be more straight-forward approach to extend it.

animal.def_property_readonly("value", [](py::object value) { return 42; });