feat: clean up old PR for new version of BTCPP

shaur-k · shaur-k · commit 47f067c86d0c · 2025-06-19T14:55:03.000-06:00
diff --git a/include/behaviortree_cpp/json_export.h b/include/behaviortree_cpp/json_export.h
@@ -78,6 +78,12 @@ class JsonExporter
   template <typename T>
   Expected<T> fromJson(const nlohmann::json& source) const;
 
+  template <typename T>
+  void fromJsonHelper(const nlohmann::json& src, T& dst) const
+  {
+    dst = *fromJson<T>(src);
+  }
+
   /// Register new JSON converters with addConverter<Foo>().
   /// You should have used first the macro BT_JSON_CONVERTER
   template <typename T>
diff --git a/include/behaviortree_cpp/python/types.h b/include/behaviortree_cpp/python/types.h
@@ -2,6 +2,7 @@
 
 #include <pybind11/pybind11.h>
 
+#include "behaviortree_cpp/basic_types.h"
 #include "behaviortree_cpp/json_export.h"
 #include "behaviortree_cpp/contrib/json.hpp"
 #include "behaviortree_cpp/contrib/pybind11_json.hpp"
@@ -19,9 +20,9 @@ namespace BT
 template <typename T>
 bool fromPythonObject(const pybind11::object& obj, T& dest)
 {
-  if constexpr (nlohmann::detail::is_getable<nlohmann::json, T>::value)
+  if constexpr(nlohmann::detail::is_getable<nlohmann::json, T>::value)
   {
-    JsonExporter::get().fromJson<T>(obj, dest);
+    JsonExporter::get().fromJsonHelper<T>(obj, dest);
     return true;
   }
 
@@ -36,4 +37,4 @@ bool fromPythonObject(const pybind11::object& obj, T& dest)
  */
 bool toPythonObject(const BT::Any& val, pybind11::object& dest);
 
-}   // namespace BT
+}  // namespace BT
diff --git a/include/behaviortree_cpp/tree_node.h b/include/behaviortree_cpp/tree_node.h
@@ -511,12 +511,6 @@ inline Expected<Timestamp> TreeNode::getInputStamped(const std::string& key,
     {
       try
       {
-        // Trivial conversion (T -> T)
-        if (val->type() == typeid(T))
-        {
-          destination = val->cast<T>();
-        }
-        else if (!std::is_same_v<T, std::string> && val->type() == typeid(std::string))
         destination = parseString<T>(port_value_str);
       }
       catch(std::exception& ex)
@@ -553,17 +547,17 @@ inline Expected<Timestamp> TreeNode::getInputStamped(const std::string& key,
         }
 #ifdef BTCPP_PYTHON
         // py::object -> C++
-        else if (val->type() == typeid(pybind11::object))
+        else if(any_value.type() == typeid(pybind11::object))
         {
-          if (!fromPythonObject<T>(val->cast<pybind11::object>(), destination))
+          if(!fromPythonObject<T>(any_value.cast<pybind11::object>(), destination))
           {
             return nonstd::make_unexpected("Cannot convert from Python object");
           }
         }
         // C++ -> py::object
-        else if constexpr (std::is_same_v<T, pybind11::object>)
+        else if constexpr(std::is_same_v<T, pybind11::object>)
         {
-          if (!toPythonObject(*val, destination))
+          if(!toPythonObject(any_value, destination))
           {
             return nonstd::make_unexpected("Cannot convert to Python object");
           }
diff --git a/sample_nodes/dummy_nodes.cpp b/sample_nodes/dummy_nodes.cpp
@@ -74,7 +74,7 @@ BT::NodeStatus SaySomethingSimple(BT::TreeNode& self)
 
 void to_json(nlohmann::json& j, const Vector3& p)
 {
-  j = nlohmann::json{{"x", p.x}, {"y", p.y}, {"z", p.z}};
+  j = nlohmann::json{ { "x", p.x }, { "y", p.y }, { "z", p.z } };
 }
 
 void from_json(const nlohmann::json& j, Vector3& p)
@@ -84,4 +84,4 @@ void from_json(const nlohmann::json& j, Vector3& p)
   j.at("z").get_to(p.z);
 }
 
-} // namespace DummyNodes
+}  // namespace DummyNodes
diff --git a/sample_nodes/dummy_nodes.h b/sample_nodes/dummy_nodes.h
@@ -134,46 +134,45 @@ void from_json(const nlohmann::json& j, Vector3& p);
 class RandomVector : public BT::SyncActionNode
 {
 public:
-  RandomVector(const std::string& name, const BT::NodeConfig& config) :
-    BT::SyncActionNode(name, config)
+  RandomVector(const std::string& name, const BT::NodeConfig& config)
+    : BT::SyncActionNode(name, config)
   {}
 
   // You must override the virtual function tick()
   NodeStatus tick() override
   {
-    setOutput("vector", Vector3{1.0, 2.0, 3.0});
+    setOutput("vector", Vector3{ 1.0, 2.0, 3.0 });
     return BT::NodeStatus::SUCCESS;
   }
 
   // It is mandatory to define this static method.
   static BT::PortsList providedPorts()
   {
-    return {BT::OutputPort<Vector3>("vector")};
+    return { BT::OutputPort<Vector3>("vector") };
   }
 };
 
 class PrintMapOfVectors : public BT::SyncActionNode
 {
 public:
-  PrintMapOfVectors(const std::string& name, const BT::NodeConfig& config) :
-    BT::SyncActionNode(name, config)
+  PrintMapOfVectors(const std::string& name, const BT::NodeConfig& config)
+    : BT::SyncActionNode(name, config)
   {}
 
   // You must override the virtual function tick()
   NodeStatus tick() override
   {
     auto input = getInput<std::unordered_map<std::string, Vector3>>("input");
-    if (input.has_value())
+    if(input.has_value())
     {
       std::cerr << "{";
-      for (const auto& [key, value] : *input)
+      for(const auto& [key, value] : *input)
       {
-        std::cerr << key << ": ("
-                  << value.x << ", "
-                  << value.y << ", "
-                  << value.z << "), ";
+        std::cerr << key << ": (" << value.x << ", " << value.y << ", " << value.z
+                  << "), ";
       }
-      std::cerr << "}" << std::endl;;
+      std::cerr << "}" << std::endl;
+      ;
     }
 
     return BT::NodeStatus::SUCCESS;
@@ -182,7 +181,7 @@ class PrintMapOfVectors : public BT::SyncActionNode
   // It is mandatory to define this static method.
   static BT::PortsList providedPorts()
   {
-    return {BT::InputPort<std::unordered_map<std::string, Vector3>>("input")};
+    return { BT::InputPort<std::unordered_map<std::string, Vector3>>("input") };
   }
 };
 
diff --git a/src/python/bindings.cpp b/src/python/bindings.cpp
@@ -21,8 +21,8 @@ namespace py = pybind11;
 class Py_SyncActionNode : public SyncActionNode
 {
 public:
-  Py_SyncActionNode(const std::string& name, const NodeConfig& config) :
-    SyncActionNode(name, config)
+  Py_SyncActionNode(const std::string& name, const NodeConfig& config)
+    : SyncActionNode(name, config)
   {}
 
   NodeStatus tick() override
@@ -34,8 +34,8 @@ class Py_SyncActionNode : public SyncActionNode
 class Py_StatefulActionNode : public StatefulActionNode
 {
 public:
-  Py_StatefulActionNode(const std::string& name, const NodeConfig& config) :
-    StatefulActionNode(name, config)
+  Py_StatefulActionNode(const std::string& name, const NodeConfig& config)
+    : StatefulActionNode(name, config)
   {}
 
   NodeStatus onStart() override
@@ -61,7 +61,7 @@ py::object Py_getInput(const TreeNode& node, const std::string& name)
 
   // The input could not exist on the blackboard, in which case we return Python
   // `None` instead of an invalid object.
-  if (!node.getInput(name, obj).has_value())
+  if(!node.getInput(name, obj).has_value())
   {
     return py::none();
   }
@@ -84,7 +84,7 @@ inline py::object convertFromString(StringView str)
     // dict, an object, etc.
     return py::eval(str);
   }
-  catch (py::error_already_set& e)
+  catch(py::error_already_set& e)
   {
     // If that fails, then assume it's a string literal with quotation marks
     // omitted.
@@ -97,15 +97,15 @@ PortsList extractPortsList(const py::type& type)
   PortsList ports;
 
   const auto input_ports = type.attr("input_ports").cast<py::list>();
-  for (const auto& name : input_ports)
+  for(const auto& name : input_ports)
   {
-    ports.insert(InputPort<PortInfo::AnyTypeAllowed>(name.cast<std::string>()));
+    ports.insert(InputPort<AnyTypeAllowed>(name.cast<std::string>()));
   }
 
   const auto output_ports = type.attr("output_ports").cast<py::list>();
-  for (const auto& name : output_ports)
+  for(const auto& name : output_ports)
   {
-    ports.insert(OutputPort<PortInfo::AnyTypeAllowed>(name.cast<std::string>()));
+    ports.insert(OutputPort<AnyTypeAllowed>(name.cast<std::string>()));
   }
 
   return ports;
@@ -114,8 +114,7 @@ PortsList extractPortsList(const py::type& type)
 NodeBuilder makeTreeNodeBuilderFn(const py::type& type, const py::args& args,
                                   const py::kwargs& kwargs)
 {
-  return [=](const auto& name, const auto& config) -> auto
-  {
+  return [=](const auto& name, const auto& config) -> auto {
     py::object obj;
     obj = type(name, config, *args, **kwargs);
 
@@ -125,7 +124,7 @@ NodeBuilder makeTreeNodeBuilderFn(const py::type& type, const py::args& args,
     // is destroyed, then the object will live forever.
     obj.inc_ref();
 
-    if (py::isinstance<ActionNodeBase>(obj))
+    if(py::isinstance<ActionNodeBase>(obj))
     {
       return std::unique_ptr<TreeNode>(obj.cast<ActionNodeBase*>());
     }
@@ -149,12 +148,16 @@ PYBIND11_MODULE(btpy_cpp, m)
              manifest.type = NodeType::ACTION;
              manifest.registration_ID = name;
              manifest.ports = extractPortsList(type);
-             manifest.description = "";
+             manifest.metadata = KeyValueVector{
+               { "description", "" },
+             };
 
              // Use the type's docstring as the node description, if it exists.
-             if (const auto doc = type.attr("__doc__"); !doc.is_none())
+             if(const auto doc = type.attr("__doc__"); !doc.is_none())
              {
-               manifest.description = doc.cast<std::string>();
+               manifest.metadata = KeyValueVector{
+                 { "description", doc.cast<std::string>() },
+               };
              }
 
              factory.registerBuilder(manifest, makeTreeNodeBuilderFn(type, args, kwargs));
@@ -202,4 +205,4 @@ PYBIND11_MODULE(btpy_cpp, m)
       .def("on_halted", &Py_StatefulActionNode::onHalted);
 }
 
-}   // namespace BT
+}  // namespace BT
diff --git a/src/python/types.cpp b/src/python/types.cpp
@@ -13,7 +13,7 @@ namespace BT
 bool toPythonObject(const BT::Any& val, pybind11::object& dest)
 {
   nlohmann::json json;
-  if (JsonExporter::get().toJson(val, json))
+  if(JsonExporter::get().toJson(val, json))
   {
     dest = json;
     return true;
@@ -22,4 +22,4 @@ bool toPythonObject(const BT::Any& val, pybind11::object& dest)
   return false;
 }
 
-}   // namespace BT
+}  // namespace BT

Original file line number	Diff line number	Diff line change
`@@ -511,12 +511,6 @@ inline Expected<Timestamp> TreeNode::getInputStamped(const std::string& key,`
`511`	`511`	`{`
`512`	`512`	`try`
`513`	`513`	`{`
`514`		`- // Trivial conversion (T -> T)`
`515`		`- if (val->type() == typeid(T))`
`516`		`- {`
`517`		`- destination = val->cast<T>();`
`518`		`- }`
`519`		`- else if (!std::is_same_v<T, std::string> && val->type() == typeid(std::string))`
`520`	`514`	`destination = parseString<T>(port_value_str);`
`521`	`515`	`}`
`522`	`516`	`catch(std::exception& ex)`
`@@ -553,17 +547,17 @@ inline Expected<Timestamp> TreeNode::getInputStamped(const std::string& key,`
`553`	`547`	`}`
`554`	`548`	`#ifdef BTCPP_PYTHON`
`555`	`549`	`// py::object -> C++`
`556`		`- else if (val->type() == typeid(pybind11::object))`
	`550`	`+ else if(any_value.type() == typeid(pybind11::object))`
`557`	`551`	`{`
`558`		`- if (!fromPythonObject<T>(val->cast<pybind11::object>(), destination))`
	`552`	`+ if(!fromPythonObject<T>(any_value.cast<pybind11::object>(), destination))`
`559`	`553`	`{`
`560`	`554`	`return nonstd::make_unexpected("Cannot convert from Python object");`
`561`	`555`	`}`
`562`	`556`	`}`
`563`	`557`	`// C++ -> py::object`
`564`		`- else if constexpr (std::is_same_v<T, pybind11::object>)`
	`558`	`+ else if constexpr(std::is_same_v<T, pybind11::object>)`
`565`	`559`	`{`
`566`		`- if (!toPythonObject(*val, destination))`
	`560`	`+ if(!toPythonObject(any_value, destination))`
`567`	`561`	`{`
`568`	`562`	`return nonstd::make_unexpected("Cannot convert to Python object");`
`569`	`563`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ BT::NodeStatus SaySomethingSimple(BT::TreeNode& self)`
`74`	`74`
`75`	`75`	`void to_json(nlohmann::json& j, const Vector3& p)`
`76`	`76`	`{`
`77`		`- j = nlohmann::json{{"x", p.x}, {"y", p.y}, {"z", p.z}};`
	`77`	`+ j = nlohmann::json{ { "x", p.x }, { "y", p.y }, { "z", p.z } };`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`void from_json(const nlohmann::json& j, Vector3& p)`
`@@ -84,4 +84,4 @@ void from_json(const nlohmann::json& j, Vector3& p)`
`84`	`84`	`j.at("z").get_to(p.z);`
`85`	`85`	`}`
`86`	`86`
`87`		`-} // namespace DummyNodes`
	`87`	`+} // namespace DummyNodes`
Original file line number	Diff line number	Diff line change
`@@ -134,46 +134,45 @@ void from_json(const nlohmann::json& j, Vector3& p);`
`134`	`134`	`class RandomVector : public BT::SyncActionNode`
`135`	`135`	`{`
`136`	`136`	`public:`
`137`		`- RandomVector(const std::string& name, const BT::NodeConfig& config) :`
`138`		`- BT::SyncActionNode(name, config)`
	`137`	`+ RandomVector(const std::string& name, const BT::NodeConfig& config)`
	`138`	`+ : BT::SyncActionNode(name, config)`
`139`	`139`	`{}`
`140`	`140`
`141`	`141`	`// You must override the virtual function tick()`
`142`	`142`	`NodeStatus tick() override`
`143`	`143`	`{`
`144`		`- setOutput("vector", Vector3{1.0, 2.0, 3.0});`
	`144`	`+ setOutput("vector", Vector3{ 1.0, 2.0, 3.0 });`
`145`	`145`	`return BT::NodeStatus::SUCCESS;`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`// It is mandatory to define this static method.`
`149`	`149`	`static BT::PortsList providedPorts()`
`150`	`150`	`{`
`151`		`- return {BT::OutputPort<Vector3>("vector")};`
	`151`	`+ return { BT::OutputPort<Vector3>("vector") };`
`152`	`152`	`}`
`153`	`153`	`};`
`154`	`154`
`155`	`155`	`class PrintMapOfVectors : public BT::SyncActionNode`
`156`	`156`	`{`
`157`	`157`	`public:`
`158`		`- PrintMapOfVectors(const std::string& name, const BT::NodeConfig& config) :`
`159`		`- BT::SyncActionNode(name, config)`
	`158`	`+ PrintMapOfVectors(const std::string& name, const BT::NodeConfig& config)`
	`159`	`+ : BT::SyncActionNode(name, config)`
`160`	`160`	`{}`
`161`	`161`
`162`	`162`	`// You must override the virtual function tick()`
`163`	`163`	`NodeStatus tick() override`
`164`	`164`	`{`
`165`	`165`	`auto input = getInput<std::unordered_map<std::string, Vector3>>("input");`
`166`		`- if (input.has_value())`
	`166`	`+ if(input.has_value())`
`167`	`167`	`{`
`168`	`168`	`std::cerr << "{";`
`169`		`- for (const auto& [key, value] : *input)`
	`169`	`+ for(const auto& [key, value] : *input)`
`170`	`170`	`{`
`171`		`- std::cerr << key << ": ("`
`172`		`- << value.x << ", "`
`173`		`- << value.y << ", "`
`174`		`- << value.z << "), ";`
	`171`	`+ std::cerr << key << ": (" << value.x << ", " << value.y << ", " << value.z`
	`172`	`+ << "), ";`
`175`	`173`	`}`
`176`		`- std::cerr << "}" << std::endl;;`
	`174`	`+ std::cerr << "}" << std::endl;`
	`175`	`+ ;`
`177`	`176`	`}`
`178`	`177`
`179`	`178`	`return BT::NodeStatus::SUCCESS;`
`@@ -182,7 +181,7 @@ class PrintMapOfVectors : public BT::SyncActionNode`
`182`	`181`	`// It is mandatory to define this static method.`
`183`	`182`	`static BT::PortsList providedPorts()`
`184`	`183`	`{`
`185`		`- return {BT::InputPort<std::unordered_map<std::string, Vector3>>("input")};`
	`184`	`+ return { BT::InputPort<std::unordered_map<std::string, Vector3>>("input") };`
`186`	`185`	`}`
`187`	`186`	`};`
`188`	`187`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ namespace BT`
`13`	`13`	`bool toPythonObject(const BT::Any& val, pybind11::object& dest)`
`14`	`14`	`{`
`15`	`15`	`nlohmann::json json;`
`16`		`- if (JsonExporter::get().toJson(val, json))`
	`16`	`+ if(JsonExporter::get().toJson(val, json))`
`17`	`17`	`{`
`18`	`18`	`dest = json;`
`19`	`19`	`return true;`
`@@ -22,4 +22,4 @@ bool toPythonObject(const BT::Any& val, pybind11::object& dest)`
`22`	`22`	`return false;`
`23`	`23`	`}`
`24`	`24`
`25`		`-} // namespace BT`
	`25`	`+} // namespace BT`