Add pybind11::bytearray

include/pybind11/pytypes.h

@@ -1059,6 +1059,35 @@ inline str::str(const bytes& b) {
     m_ptr = obj.release().ptr();
 }
 
+/// \addtogroup pytypes
+/// @{
+class bytearray : public object {
+public:
+    PYBIND11_OBJECT(bytearray, object, PyByteArray_Check)
+
+    bytearray()
+        : object(PyByteArray_FromStringAndSize("", (ssize_t) 0), stolen_t{}) {
+        if (!m_ptr) pybind11_fail("Could not allocate bytearray object!");
+    }
+
+    bytearray(const char *c, size_t n)
+        : object(PyByteArray_FromStringAndSize(c, (ssize_t) n), stolen_t{}) {
+        if (!m_ptr) pybind11_fail("Could not allocate bytearray object!");
+    }
+
+    // Allow implicit conversion:
+    bytearray(const std::string &s) : bytearray(s.data(), s.size()) { }
+
+    operator std::string() const {
+        char *buffer = PyByteArray_AS_STRING(m_ptr);
+        ssize_t size = PyByteArray_GET_SIZE(m_ptr);
+        return std::string(buffer, static_cast<size_t>(size));
+    }
+};
+// Note: breathe >= 4.17.0 will fail to build docs if the below two constructors
+// are included in the doxygen group; close here and reopen after as a workaround
+/// @} pytypes
+
 /// \addtogroup pytypes
 /// @{
 class none : public object {

tests/test_pytypes.cpp

@@ -90,6 +90,7 @@ TEST_SUBMODULE(pytypes, m) {
 
     // test_bytes
     m.def("bytes_from_string", []() { return py::bytes(std::string("foo")); });
+    m.def("bytearray_from_string", []() { return py::bytearray(std::string("foo")); });
     m.def("bytes_from_str", []() { return py::bytes(py::str("bar", 3)); });
 
     // test_capsule
@@ -210,6 +211,7 @@ TEST_SUBMODULE(pytypes, m) {
     m.def("default_constructors", []() {
         return py::dict(
             "bytes"_a=py::bytes(),
+            "bytearray"_a=py::bytearray(),
             "str"_a=py::str(),
             "bool"_a=py::bool_(),
             "int"_a=py::int_(),
@@ -224,6 +226,7 @@ TEST_SUBMODULE(pytypes, m) {
     m.def("converting_constructors", [](py::dict d) {
         return py::dict(
             "bytes"_a=py::bytes(d["bytes"]),
+            "bytearray"_a=py::bytearray(d["bytearray"]),
             "str"_a=py::str(d["str"]),
             "bool"_a=py::bool_(d["bool"]),
             "int"_a=py::int_(d["int"]),
@@ -240,6 +243,7 @@ TEST_SUBMODULE(pytypes, m) {
         // When converting between Python types, obj.cast<T>() should be the same as T(obj)
         return py::dict(
             "bytes"_a=d["bytes"].cast<py::bytes>(),
+            "bytearray"_a=d["bytearray"].cast<py::bytearray>(),
             "str"_a=d["str"].cast<py::str>(),
             "bool"_a=d["bool"].cast<py::bool_>(),
             "int"_a=d["int"].cast<py::int_>(),
@@ -258,6 +262,9 @@ TEST_SUBMODULE(pytypes, m) {
         if (type == "bytes") {
             return py::bytes(value);
         }
+        if (type == "bytearray") {
+            return py::bytearray(value);
+        }
         else if (type == "none") {
             return py::none(value);
         }

tests/test_pytypes.py

@@ -140,6 +140,10 @@ def test_bytes(doc):
     )
 
 
+def test_bytearray(doc):
+    assert m.bytearray_from_string().decode() == "foo"
+
+
 def test_capsule(capture):
     pytest.gc_collect()
     with capture:
@@ -220,7 +224,7 @@ def func(self, x, *args):
 
 def test_constructors():
     """C++ default and converting constructors are equivalent to type calls in Python"""
-    types = [bytes, str, bool, int, float, tuple, list, dict, set]
+    types = [bytes, bytearray, str, bool, int, float, tuple, list, dict, set]
     expected = {t.__name__: t() for t in types}
     if env.PY2:
         # Note that bytes.__name__ == 'str' in Python 2.
@@ -231,6 +235,7 @@ def test_constructors():
 
     data = {
         bytes: b"41",  # Currently no supported or working conversions.
+        bytearray: bytearray(b"41"),
         str: 42,
         bool: "Not empty",
         int: "42",
@@ -266,6 +271,7 @@ def test_constructors():
 def test_non_converting_constructors():
     non_converting_test_cases = [
         ("bytes", range(10)),
+        ("bytearray", range(10)),
         ("none", 42),
         ("ellipsis", 42),
     ]