Bump meta and pybind11 deps; improve parser::visitor bindings.

src/metapy_analyzers.cpp

@@ -14,6 +14,7 @@
 #include <mutex>
 
 #include "metapy_analyzers.h"
+#include "metapy_identifiers.h"
 #include "metapy_probe_map.h"
 
 #include "cpptoml.h"

src/metapy_embeddings.cpp

@@ -14,6 +14,7 @@
 #include "cpptoml.h"
 #include "meta/embeddings/word_embeddings.h"
 #include "metapy_embeddings.h"
+#include "metapy_identifiers.h"
 
 namespace py = pybind11;
 using namespace meta;

src/metapy_index.cpp

@@ -12,6 +12,7 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
+#include "metapy_identifiers.h"
 #include "metapy_index.h"
 
 #include "cpptoml.h"

src/metapy_parser.cpp

@@ -30,6 +30,7 @@
 
 #include "meta/parser/io/ptb_reader.h"
 
+#include "metapy_identifiers.h"
 #include "metapy_parser.h"
 
 namespace py = pybind11;
@@ -143,6 +144,7 @@ void metapy_bind_parser(py::module& m)
 
     py::class_<leaf_node, node>{m_parse, "LeafNode"}
         .def(py::init<class_label, std::string>())
+        .def(py::init<const leaf_node&>())
         .def("word", [](const leaf_node& ln) { return *ln.word(); });
 
     py::class_<internal_node, node>{m_parse, "InternalNode"}
@@ -172,9 +174,28 @@ void metapy_bind_parser(py::module& m)
              [](internal_node& n, const node* descendent) {
                  n.head_constituent(descendent);
              })
-        .def("each_child", [](internal_node& n, std::function<void(node*)> fn) {
-            n.each_child(fn);
-        });
+        // weirdness: need to ensure that the child nodes passed down to
+        // the python lambda preserve the lifetime of the current internal
+        // node in case they are stored internally
+        .def("each_child",
+             [](internal_node& n, py::function fn) {
+                 n.each_child([&](node* child) {
+                     auto handle = py::cast(
+                         *child, py::return_value_policy::reference_internal,
+                         py::cast(n));
+                     fn(handle);
+                 });
+             })
+        .def("__getitem__",
+             [](internal_node& n, int64_t offset) {
+                 uint64_t idx = offset >= 0 ? static_cast<uint64_t>(offset)
+                                            : n.num_children() + offset;
+                 if (idx >= n.num_children())
+                     throw py::index_error();
+                 return n.child(idx);
+             },
+             py::keep_alive<0, 1>())
+        .def("__len__", &internal_node::num_children);
 
     py::class_<parse_tree>{m_parse, "ParseTree"}
         .def("__init__",
@@ -194,9 +215,14 @@ void metapy_bind_parser(py::module& m)
                  tree.pretty_print(ss);
                  return ss.str();
              })
-        .def("visit", [](parse_tree& tree, parser::visitor<py::object>& vtor) {
-            return tree.visit(vtor);
-        });
+        // keep_alive here is to ensure that the visitor keeps the tree
+        // alive as long as it is still referenced, since it might hold an
+        // internal pointer into the tree
+        .def("visit",
+             [](parse_tree& tree, parser::visitor<py::object>& vtor) {
+                 return tree.visit(vtor);
+             },
+             py::keep_alive<2, 1>());
 
     py::implicitly_convertible<node, parse_tree>();
 

src/metapy_sequence.cpp

@@ -17,6 +17,9 @@
 #include "meta/sequence/perceptron.h"
 #include "meta/sequence/sequence.h"
 
+#include "metapy_identifiers.h"
+#include "metapy_sequence.h"
+
 namespace py = pybind11;
 using namespace meta;
 
@@ -56,14 +59,20 @@ void metapy_bind_sequence(py::module& m)
         .def("add_observation", &sequence::sequence::add_observation)
         .def("add_symbol", &sequence::sequence::add_symbol)
         .def("__getitem__",
-             [](sequence::sequence& seq, sequence::sequence::size_type idx) {
+             [](sequence::sequence& seq, int64_t offset) {
+                 std::size_t idx = offset >= 0
+                                       ? static_cast<std::size_t>(offset)
+                                       : seq.size() + offset;
                  if (idx >= seq.size())
                      throw py::index_error();
                  return seq[idx];
              })
         .def("__setitem__",
-             [](sequence::sequence& seq, sequence::sequence::size_type idx,
+             [](sequence::sequence& seq, int64_t offset,
                 sequence::observation obs) {
+                 std::size_t idx = offset >= 0
+                                       ? static_cast<std::size_t>(offset)
+                                       : seq.size() + offset;
                  if (idx >= seq.size())
                      throw py::index_error();
                  seq[idx] = std::move(obs);