Add stateful action bindings.

Author: kylc

python_examples/ex03_stateful_nodes.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+
+"""
+Demonstration of stateful action nodes.
+
+To run, ensure that the `btpy_cpp` Python extension is on your `PYTHONPATH`
+variable. It is probably located in your build directory if you're building from
+source.
+"""
+
+import numpy as np
+from btpy import (
+    BehaviorTreeFactory,
+    StatefulActionNode,
+    SyncActionNode,
+    NodeStatus,
+    ports,
+)
+
+
+xml_text = """
+ <root BTCPP_format="4" >
+
+     <BehaviorTree ID="MainTree">
+        <Sequence>
+            <!-- Initialize the interpolated position -->
+            <SetBlackboard output_key="interpolated" value="None" />
+
+            <!-- Interpolate from the initial position to the final one printing
+                 at each step. -->
+            <ReactiveSequence name="root">
+                <Print value="{interpolated}" />
+                <Interpolate x0="[1.0, 0.0]" x1="[0.0, 1.0]" out="{interpolated}" />
+            </ReactiveSequence>
+        </Sequence>
+     </BehaviorTree>
+
+ </root>
+"""
+
+
+@ports(inputs=["x0", "x1"], outputs=["out"])
+class Interpolate(StatefulActionNode):
+    def on_start(self):
+        self.t = 0.0
+        self.x0 = np.asarray(self.get_input("x0"))
+        self.x1 = np.asarray(self.get_input("x1"))
+        return NodeStatus.RUNNING
+
+    def on_running(self):
+        if self.t < 1.0:
+            x = (1.0 - self.t) * self.x0 + self.t * self.x1
+            self.set_output("out", x)
+            self.t += 0.1
+            return NodeStatus.RUNNING
+        else:
+            return NodeStatus.SUCCESS
+
+    def on_halted(self):
+        pass
+
+
+@ports(inputs=["value"])
+class Print(SyncActionNode):
+    def tick(self):
+        print(self.get_input("value"))
+        return NodeStatus.SUCCESS
+
+
+factory = BehaviorTreeFactory()
+factory.register(Interpolate)
+factory.register(Print)
+
+tree = factory.create_tree_from_text(xml_text)
+tree.tick_while_running()

src/python_bindings.cpp

@@ -1,4 +1,5 @@
 #include <memory>
+#include <stdexcept>
 
 #include <pybind11/pybind11.h>
 #include <pybind11/gil.h>
@@ -43,6 +44,46 @@ class Py_SyncActionNode : public SyncActionNode
   }
 };
 
+class Py_StatefulActionNode final : public StatefulActionNode
+{
+public:
+  Py_StatefulActionNode(const std::string& name, const NodeConfig& config) :
+    StatefulActionNode(name, config)
+  {}
+
+  NodeStatus onStart() override
+  {
+    py::gil_scoped_acquire gil;
+    return py::get_overload(this, "on_start")().cast<NodeStatus>();
+  }
+
+  NodeStatus onRunning() override
+  {
+    py::gil_scoped_acquire gil;
+    return py::get_overload(this, "on_running")().cast<NodeStatus>();
+  }
+
+  void onHalted() override
+  {
+    py::gil_scoped_acquire gil;
+    py::get_overload(this, "on_halted")();
+  }
+
+  // TODO: Share these duplicated methods with other node types.
+  py::object Py_getInput(const std::string& name)
+  {
+    py::object obj;
+    getInput(name, obj);
+    return obj;
+  }
+
+  // TODO: Share these duplicated methods with other node types.
+  void Py_setOutput(const std::string& name, const py::object& value)
+  {
+    setOutput(name, value);
+  }
+};
+
 // Add a conversion specialization from string values into general py::objects
 // by evaluating as a Python expression.
 template <>
@@ -112,8 +153,18 @@ PYBIND11_MODULE(btpy_cpp, m)
                    // is destroyed, then the object will live forever.
                    obj.inc_ref();
 
-                   return std::unique_ptr<Py_SyncActionNode>(
-                       obj.cast<Py_SyncActionNode*>());
+                   if (py::isinstance<Py_SyncActionNode>(obj))
+                   {
+                     return std::unique_ptr<TreeNode>(obj.cast<Py_SyncActionNode*>());
+                   }
+                   else if (py::isinstance<Py_StatefulActionNode>(obj))
+                   {
+                     return std::unique_ptr<TreeNode>(obj.cast<Py_StatefulActionNode*>());
+                   }
+                   else
+                   {
+                     throw std::runtime_error("invalid node type of " + name);
+                   }
                  });
            })
       .def("create_tree_from_text",
@@ -142,6 +193,14 @@ PYBIND11_MODULE(btpy_cpp, m)
       .def("tick", &Py_SyncActionNode::tick)
       .def("get_input", &Py_SyncActionNode::Py_getInput)
       .def("set_output", &Py_SyncActionNode::Py_setOutput);
+
+  py::class_<Py_StatefulActionNode>(m, "StatefulActionNode")
+      .def(py::init<const std::string&, const NodeConfig&>())
+      .def("on_start", &Py_StatefulActionNode::onStart)
+      .def("on_running", &Py_StatefulActionNode::onRunning)
+      .def("on_halted", &Py_StatefulActionNode::onHalted)
+      .def("get_input", &Py_StatefulActionNode::Py_getInput)
+      .def("set_output", &Py_StatefulActionNode::Py_setOutput);
 }
 
 }   // namespace BT