Add namespace_ type and tests

Author: Jouke Witteveen

docs/advanced/pycpp/object.rst

@@ -9,17 +9,60 @@ Available wrappers
 All major Python types are available as thin C++ wrapper classes. These
 can also be used as function parameters -- see :ref:`python_objects_as_args`.
 
-Available types include :class:`handle`, :class:`object`, :class:`bool_`,
-:class:`int_`, :class:`float_`, :class:`str`, :class:`bytes`, :class:`tuple`,
-:class:`list`, :class:`dict`, :class:`slice`, :class:`none`, :class:`capsule`,
-:class:`iterable`, :class:`iterator`, :class:`function`, :class:`buffer`,
-:class:`array`, and :class:`array_t`.
+Available types include :class:`handle`, :class:`object`, :class:`namespace_`,
+:class:`bool_`, :class:`int_`, :class:`float_`, :class:`str`, :class:`bytes`,
+:class:`tuple`, :class:`list`, :class:`dict`, :class:`slice`, :class:`none`,
+:class:`capsule`, :class:`iterable`, :class:`iterator`, :class:`function`,
+:class:`buffer`, :class:`array`, and :class:`array_t`.
 
 .. warning::
 
     Be sure to review the :ref:`pytypes_gotchas` before using this heavily in
     your C++ API.
 
+.. _instantiating_compound_types:
+
+Instantiating compound Python types from C++
+============================================
+
+A tuple of python objects can be instantiated using :func:`py::make_tuple`:
+
+.. code-block:: cpp
+
+    py::tuple tup = py::make_tuple(42, py::none(), "spam");
+
+Each element is converted to a supported Python type.
+
+Dictionaries can be initialized in the :class:`dict` constructor:
+
+.. code-block:: cpp
+
+    using namespace pybind11::literals; // to bring in the `_a` literal
+    py::dict d("spam"_a=py::none(), "eggs"_a=42);
+
+A `simple namespace`_ can be instantiated in the :class:`namespace_`
+constructor:
+
+.. code-block:: cpp
+
+    using namespace pybind11::literals; // to bring in the `_a` literal
+    py::namespace_ ns("spam"_a=py::none(), "eggs"_a=42);
+
+The keys in the arguments to the :class:`namespace_` constructor become the
+attribute names in the resulting namespace. Attributes on a namespace can be
+modified with the :func:`py::delattr`, :func:`py::getattr`, and
+:func:`py::setattr` functions. Namespaces can be useful as stand-ins for class
+instances.
+
+.. note::
+
+    The ``namespace_`` type is not available in Python 2.
+
+.. versionchanged:: 2.7
+    ``namespace_`` added.
+
+.. _simple namespace: https://docs.python.org/3/library/types.html#types.SimpleNamespace
+
 .. _casting_back_and_forth:
 
 Casting back and forth
@@ -30,7 +73,7 @@ types to Python, which can be done using :func:`py::cast`:
 
 .. code-block:: cpp
 
-    MyClass *cls = ..;
+    MyClass *cls = ...;
     py::object obj = py::cast(cls);
 
 The reverse direction uses the following syntax:

include/pybind11/pytypes.h

@@ -763,6 +763,10 @@ inline bool PyUnicode_Check_Permissive(PyObject *o) { return PyUnicode_Check(o)
 #define PYBIND11_STR_CHECK_FUN PyUnicode_Check
 #endif
 
+#if PY_MAJOR_VERSION >= 3
+inline bool PyNamespace_Check(PyObject *o) { return isinstance(o, (PyObject *) &_PyNamespace_Type); }
+#endif
+
 inline bool PyStaticMethod_Check(PyObject *o) { return o->ob_type == &PyStaticMethod_Type; }
 
 class kwargs_proxy : public handle {
@@ -1326,6 +1330,18 @@ class dict : public object {
     }
 };
 
+#if PY_MAJOR_VERSION >= 3
+class namespace_ : public object {
+public:
+    PYBIND11_OBJECT(namespace_, object, detail::PyNamespace_Check)
+    template <typename... Args,
+              typename = detail::enable_if_t<args_are_all_keyword_or_ds<Args...>()>>
+    explicit namespace_(Args&&... args_) : object(_PyNamespace_New(dict(std::forward<Args>(args_)...).ptr()), stolen_t{}) {
+        if (!m_ptr) pybind11_fail("Could not allocate namespace object!");
+    }
+};
+#endif
+
 class sequence : public object {
 public:
     PYBIND11_OBJECT_DEFAULT(sequence, object, PySequence_Check)

tests/test_pytypes.cpp

@@ -75,6 +75,19 @@ TEST_SUBMODULE(pytypes, m) {
         return dict.contains(val);
     });
 
+    // test_tuple
+    m.def("get_tuple", []() { return py::make_tuple(42, py::none(), "spam"); });
+
+#if PY_MAJOR_VERSION >= 3
+    // test_namespace
+    m.def("get_namespace", []() {
+        py::namespace_ ns("attr"_a=42, "x"_a="foo", "wrong"_a=1);
+        py::delattr(ns, "wrong");
+        py::setattr(ns, "right", py::int_(2));
+        return ns;
+    });
+#endif
+
     // test_str
     m.def("str_from_string", []() { return py::str(std::string("baz")); });
     m.def("str_from_bytes", []() { return py::str(py::bytes("boo", 3)); });

tests/test_pytypes.py

@@ -98,6 +98,19 @@ def test_dict(capture, doc):
     assert m.dict_keyword_constructor() == {"x": 1, "y": 2, "z": 3}
 
 
+def test_tuple():
+    assert m.get_tuple() == (42, None, "spam")
+
+
+@pytest.mark.skipif("env.PY2")
+def test_namespace():
+    ns = m.get_namespace()
+    assert ns.attr == 42
+    assert ns.x == "foo"
+    assert ns.right == 2
+    assert not hasattr(ns, "wrong")
+
+
 def test_str(doc):
     assert m.str_from_string().encode().decode() == "baz"
     assert m.str_from_bytes().encode().decode() == "boo"