Fix construction of G3FrameObject maps and vectors

Pybind11 performs a series of type conversions when passing python arguments to C++
functions.  These conversions do not behave appropriately when the argument is a base
G3FrameObject.  This commit overrides all of the functions in the G3MapFrameObject
and G3VectorFrameObject classes that take G3FrameObject objects as input arguments.
Type conversion is disabled on any argument that is a G3FrameObject, and the
overridden functions are used in place of the standard ones.

Author: arahlin

core/CMakeLists.txt

@@ -106,6 +106,7 @@ add_spt3g_test(pipeline_module)
 add_spt3g_test(multiproc)
 add_spt3g_test(frames)
 add_spt3g_test(frame_types)
+add_spt3g_test(frameobjects)
 add_spt3g_test(datatypes)
 if(FLAC_FOUND)
 	add_spt3g_test(ts_nanencoding)

core/src/G3Map.cxx

@@ -255,8 +255,39 @@ PYBINDINGS("core", scope) {
 	register_g3map<G3MapVectorTime>(scope, "G3MapVectorTime", "Mapping from "
 	    "strings to lists of G3 time objects.");
 
-	register_g3map<G3MapFrameObject>(scope, "G3MapFrameObject", "Mapping "
-	    "strings to generic frame objects. Can lead to a variety of "
+	auto cls = register_g3map<G3MapFrameObject>(scope, "G3MapFrameObject",
+	    "Mapping strings to generic frame objects. Can lead to a variety of "
 	    "paradoxes; please avoid general use of this class.");
+
+	// overrides to avoid type conversion
+	cls.attr("__init__") = py::cpp_function(
+	    [](py::detail::value_and_holder &v_h) {
+		v_h.value_ptr() = new G3MapFrameObject();
+	    }, py::name("__init__"), py::is_method(cls),
+	    py::detail::is_new_style_constructor());
+	cls.def(py::init<const G3MapFrameObject&>(), "Copy constructor");
+	cls.def(py::init([](const py::iterable &d) {
+		auto v = py::cast(G3MapFrameObjectPtr(new G3MapFrameObject()));
+		for (auto item: py::dict(d))
+			v.attr("__setitem__")(item.first, item.second);
+		return py::cast<G3MapFrameObject>(v);
+	    }), "Iterable constructor");
+
+	cls.attr("__setitem__") = py::cpp_function(
+	    [](G3MapFrameObject &m, const std::string &k, G3FrameObjectPtr v) {
+		m[k] = v;
+	    }, py::name("__setitem__"), py::is_method(cls),
+	    py::arg("key"), py::arg("item").noconvert());
+
+	cls.attr("update") = py::cpp_function(
+	    [](py::object &m, const py::iterable &v, py::kwargs kw) {
+		for (auto it: py::dict(v))
+			m.attr("__setitem__")(it.first, it.second);
+		for (auto it: kw)
+			m.attr("__setitem__")(it.first, it.second);
+	    }, py::name("update"), py::is_method(cls),
+	    py::arg("items")=py::list(),
+	    "Update mapping from iterable/mapping.");
+
 }
 

core/src/G3Vector.cxx

@@ -189,16 +189,64 @@ PYBINDINGS("core", scope) {
 	register_g3vector<G3VectorVectorString>(scope, "G3VectorVectorString",
 	    "List of lists of strings.");
 
-	register_g3vector<G3VectorFrameObject>(scope, "G3VectorFrameObject",
-	    "List of generic frame objects. Can lead to paradoxes; avoid use of "
-	    "this class unless you are sure you need it.");
-
 	register_vector_of<unsigned char>(scope, "UnsignedChar");
 	register_g3vector<G3VectorUnsignedChar>(scope, "G3VectorUnsignedChar",
 	    "List of 8-bit integers");
 
 	register_vector_of<G3Time>(scope, "G3Time", py::buffer_protocol());
 	register_g3vector<G3VectorTime>(scope, "G3VectorTime", py::buffer_protocol(),
 	    "List of times.");
+
+	auto cls = register_g3vector<G3VectorFrameObject>(scope, "G3VectorFrameObject",
+	    "List of generic frame objects. Can lead to paradoxes; avoid use of "
+	    "this class unless you are sure you need it.");
+
+	// overrides to avoid type conversion
+	cls.attr("__init__") = py::cpp_function(
+	    [](py::detail::value_and_holder &v_h) {
+		v_h.value_ptr() = new G3VectorFrameObject();
+	    }, py::name("__init__"), py::is_method(cls),
+	    py::detail::is_new_style_constructor());
+	cls.def(py::init<const G3VectorFrameObject&>(), "Copy constructor");
+	cls.def(py::init([](const py::iterable &d) {
+		auto v = py::cast(G3VectorFrameObjectPtr(new G3VectorFrameObject()));
+		for (auto item: d)
+			v.attr("append")(item);
+		return py::cast<G3VectorFrameObject>(v);
+	    }), "Iterable constructor");
+
+	cls.def("__setitem__",
+	    [](G3VectorFrameObject &v, ssize_t i, G3FrameObjectPtr x) {
+		if (i < 0)
+			i += v.size();
+		if (i < 0 || (size_t) i >= v.size())
+			throw py::index_error();
+		v[(size_t)i] = x;
+	    }, py::arg("i"), py::arg("x").noconvert(), py::prepend());
+
+	cls.attr("insert") = py::cpp_function(
+	    [](G3VectorFrameObject &v, ssize_t i, G3FrameObjectPtr x) {
+		if (i < 0)
+			i += v.size();
+		if (i < 0 || (size_t) i > v.size())
+			throw py::index_error();
+		v.insert(v.begin() + i, x);
+	    }, py::name("insert"), py::is_method(cls),
+	    py::arg("i"), py::arg("x").noconvert(),
+	    "Insert an item at a given position.");
+
+	cls.attr("append") = py::cpp_function(
+	    [](G3VectorFrameObject &v, G3FrameObjectPtr x) {
+		v.push_back(x);
+	    }, py::name("append"), py::is_method(cls),
+	    py::arg("x").noconvert(),
+	    "Add an item to the end of the list");
+
+	cls.attr("extend") = py::cpp_function(
+	    [](G3VectorFrameObject &v, const G3VectorFrameObject &src) {
+		v.insert(v.end(), src.begin(), src.end());
+	    }, py::name("extend"), py::is_method(cls),
+	    py::arg("L").noconvert(),
+	    "Extend the list by appending all the items in the given list");
 }
 

core/tests/frameobjects.py

@@ -0,0 +1,59 @@
+from spt3g import core
+import numpy as np
+
+vi = core.G3VectorInt([1, 2, 3])
+mi = core.G3MapInt({"a": 1, "b": 2, "c": 3})
+
+# test default constructor
+m = core.G3MapFrameObject()
+
+# test modifiers
+m["v"] = vi
+assert isinstance(m["v"], core.G3VectorInt)
+np.testing.assert_array_equal(m["v"], vi)
+m.update(m=mi)
+assert isinstance(m["m"], core.G3MapInt)
+np.testing.assert_array_equal(list(m["m"].keys()), list(mi.keys()))
+np.testing.assert_array_equal(list(m["m"].values()), list(mi.values()))
+
+# test constructor from iterable
+m2 = core.G3MapFrameObject({"v": vi, "m": mi})
+assert isinstance(m2["v"], core.G3VectorInt)
+assert isinstance(m2["m"], core.G3MapInt)
+np.testing.assert_array_equal(list(m.keys()), list(m2.keys()))
+np.testing.assert_array_equal(list(m.values()), list(m2.values()))
+
+# test copy constructor
+m3 = core.G3MapFrameObject(m2)
+assert isinstance(m3["v"], core.G3VectorInt)
+assert isinstance(m3["m"], core.G3MapInt)
+np.testing.assert_array_equal(list(m3.keys()), list(m2.keys()))
+np.testing.assert_array_equal(list(m3.values()), list(m2.values()))
+
+# test default constructor
+v = core.G3VectorFrameObject()
+
+# test modifiers
+v.append(vi)
+assert isinstance(v[0], core.G3VectorInt)
+np.testing.assert_array_equal(v[0], vi)
+v.insert(0, mi)
+assert isinstance(v[0], core.G3MapInt)
+np.testing.assert_array_equal(list(v[0].keys()), list(mi.keys()))
+np.testing.assert_array_equal(list(v[0].values()), list(mi.values()))
+v[0] = vi
+assert isinstance(v[0], core.G3VectorInt)
+v[1] = mi
+assert isinstance(v[1], core.G3MapInt)
+
+# test constructor from iterable
+v2 = core.G3VectorFrameObject([vi, mi])
+assert isinstance(v2[0], core.G3VectorInt)
+assert isinstance(v2[1], core.G3MapInt)
+np.testing.assert_array_equal(v2, v)
+
+# test copy constructor
+v3 = core.G3VectorFrameObject(v2)
+assert isinstance(v3[0], core.G3VectorInt)
+assert isinstance(v3[1], core.G3MapInt)
+np.testing.assert_array_equal(v3, v)