src/dynamic_graph/convert-dg-to-py.cc

+// Copyright 2010, Florent Lamiraux, Thomas Moulard, LAAS-CNRS.
+
+#include "dynamic-graph/python/convert-dg-to-py.hh"
+
+#include <dynamic-graph/signal-base.h>
+#include <dynamic-graph/signal-caster.h>
+#include <dynamic-graph/signal.h>
+
+#include <boost/python.hpp>
+#include <boost/python/stl_iterator.hpp>
+#include <iostream>
+#include <sstream>
+
+#include "dynamic-graph/python/python-compat.hh"
+
+namespace dynamicgraph {
+
+using ::dynamicgraph::SignalBase;
+
+namespace python {
+namespace convert {
+
+namespace bp = boost::python;
+
+command::Value toValue(bp::object o, const command::Value::Type& valueType) {
+  using command::Value;
+  switch (valueType) {
+    case (Value::BOOL):
+      return Value(bp::extract<bool>(o));
+    case (Value::UNSIGNED):
+      return Value(bp::extract<unsigned>(o));
+    case (Value::INT):
+      return Value(bp::extract<int>(o));
+    case (Value::FLOAT):
+      return Value(bp::extract<float>(o));
+    case (Value::DOUBLE):
+      return Value(bp::extract<double>(o));
+    case (Value::STRING):
+      return Value(bp::extract<std::string>(o));
+    case (Value::VECTOR):
+      // TODO for backward compatibility, support tuple or list ?
+      // I don't think so
+      return Value(bp::extract<Vector>(o));
+    case (Value::MATRIX):
+      // TODO for backward compatibility, support tuple or list ?
+      // I don't think so
+      return Value(bp::extract<Matrix>(o));
+    case (Value::MATRIX4D):
+      return Value(bp::extract<Eigen::Matrix4d>(o));
+    case (Value::VALUES):
+      // TODO the vector of values cannot be built since
+      // - the value type inside the vector are not know
+      // - inferring the value type from the Python type is not implemented.
+      throw std::invalid_argument(
+          "not implemented: cannot create a vector of values");
+      break;
+    default:
+      std::cerr << "Only int, double and string are supported." << std::endl;
+  }
+  return Value();
+}
+
+bp::object fromValue(const command::Value& value) {
+  using command::Value;
+  switch (value.type()) {
+    case (Value::BOOL):
+      return bp::object(value.boolValue());
+    case (Value::UNSIGNED):
+      return bp::object(value.unsignedValue());
+    case (Value::INT):
+      return bp::object(value.intValue());
+    case (Value::FLOAT):
+      return bp::object(value.floatValue());
+    case (Value::DOUBLE):
+      return bp::object(value.doubleValue());
+    case (Value::STRING):
+      return bp::object(value.stringValue());
+    case (Value::VECTOR):
+      return bp::object(value.vectorValue());
+    case (Value::MATRIX):
+      return bp::object(value.matrixXdValue());
+    case (Value::MATRIX4D):
+      return bp::object(value.matrix4dValue());
+    case (Value::VALUES): {
+      bp::list list;
+      for (const Value& v : value.constValuesValue()) list.append(fromValue(v));
+      return list;
+    }
+    case (Value::NONE):
+    default:
+      return bp::object();
+  }
+}
+
+}  // namespace convert
+}  // namespace python
+}  // namespace dynamicgraph

src/dynamic_graph/debug-py.cc

+// Copyright 2019, Olivier Stasse, LAAS-CNRS.
+//
+// See LICENSE
+
+#include <iostream>
+
+#define ENABLE_RT_LOG
+#include <dynamic-graph/entity.h>
+#include <dynamic-graph/pool.h>
+#include <dynamic-graph/real-time-logger.h>
+
+#include <boost/shared_ptr.hpp>
+#include <map>
+#include <vector>
+
+#include "dynamic-graph/python/dynamic-graph-py.hh"
+
+typedef boost::shared_ptr<std::ofstream> ofstreamShrPtr;
+
+namespace dynamicgraph {
+namespace python {
+
+namespace debug {
+
+std::map<std::string, ofstreamShrPtr> mapOfFiles_;
+
+void addLoggerFileOutputStream(const char* filename) {
+  std::ofstream* aofs = new std::ofstream;
+  ofstreamShrPtr ofs_shrptr = boost::shared_ptr<std::ofstream>(aofs);
+  aofs->open(filename, std::ofstream::out);
+  dynamicgraph::RealTimeLogger::instance();
+  dgADD_OSTREAM_TO_RTLOG(*aofs);
+  dgRTLOG() << "Added " << filename << " as an output stream \n";
+  mapOfFiles_[filename] = ofs_shrptr;
+}
+
+void closeLoggerFileOutputStream() {
+  for (const auto& el : mapOfFiles_) el.second->close();
+}
+
+void addLoggerCoutOutputStream() { dgADD_OSTREAM_TO_RTLOG(std::cout); }
+
+void realTimeLoggerDestroy() { RealTimeLogger::destroy(); }
+
+void realTimeLoggerSpinOnce() { RealTimeLogger::instance().spinOnce(); }
+
+void realTimeLoggerInstance() { RealTimeLogger::instance(); }
+
+}  // namespace debug
+}  // namespace python
+}  // namespace dynamicgraph

src/dynamic_graph/dynamic-graph-py.cc

+// Copyright 2010, Florent Lamiraux, Thomas Moulard, LAAS-CNRS.
+
+#include "dynamic-graph/python/dynamic-graph-py.hh"
+
+#include <dynamic-graph/command.h>
+#include <dynamic-graph/debug.h>
+#include <dynamic-graph/entity.h>
+#include <dynamic-graph/exception-factory.h>
+#include <dynamic-graph/factory.h>
+#include <dynamic-graph/pool.h>
+#include <dynamic-graph/signal-base.h>
+#include <dynamic-graph/signal-time-dependent.h>
+#include <dynamic-graph/signal.h>
+#include <dynamic-graph/tracer.h>
+
+#include <Eigen/Geometry>
+#include <boost/python.hpp>
+#include <boost/python/raw_function.hpp>
+#include <boost/python/suite/indexing/map_indexing_suite.hpp>
+#include <eigenpy/eigenpy.hpp>
+#include <eigenpy/geometry.hpp>
+#include <iostream>
+#include <sstream>
+
+#include "dynamic-graph/python/convert-dg-to-py.hh"
+#include "dynamic-graph/python/module.hh"
+#include "dynamic-graph/python/signal-wrapper.hh"
+
+namespace dynamicgraph {
+namespace python {
+
+/**
+   \brief plug a signal into another one.
+*/
+void plug(SignalBase<int>* signalOut, SignalBase<int>* signalIn) {
+  signalIn->plug(signalOut);
+}
+
+void enableTrace(bool enable, const char* filename) {
+  if (enable)
+    DebugTrace::openFile(filename);
+  else
+    DebugTrace::closeFile(filename);
+}
+
+}  // namespace python
+}  // namespace dynamicgraph
+
+namespace bp = boost::python;
+namespace dg = dynamicgraph;
+
+typedef bp::return_value_policy<bp::manage_new_object> manage_new_object;
+typedef bp::return_value_policy<bp::reference_existing_object>
+    reference_existing_object;
+
+typedef dg::PoolStorage::Entities MapOfEntities;
+
+struct MapOfEntitiesPairToPythonConverter {
+  static PyObject* convert(const MapOfEntities::value_type& pair) {
+    return bp::incref(bp::make_tuple(pair.first, bp::ptr(pair.second)).ptr());
+  }
+};
+
+MapOfEntities* getEntityMap() {
+  return const_cast<MapOfEntities*>(
+      &dg::PoolStorage::getInstance()->getEntityMap());
+}
+
+dg::SignalBase<int>* getSignal(dg::Entity& e, const std::string& name) {
+  return &e.getSignal(name);
+}
+
+class PythonEntity : public dg::Entity {
+  DYNAMIC_GRAPH_ENTITY_DECL();
+
+ public:
+  using dg::Entity::Entity;
+
+  void signalRegistration(dg::SignalBase<int>& signal) {
+    dg::Entity::signalRegistration(signal);
+  }
+  void signalDeregistration(const std::string& name) {
+    dg::Entity::signalDeregistration(name);
+  }
+};
+
+DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(PythonEntity, "PythonEntity");
+
+void exposeEntityBase() {
+  using namespace dynamicgraph;
+  bp::enum_<LoggerVerbosity>("LoggerVerbosity")
+      .value("VERBOSITY_ALL", VERBOSITY_ALL)
+      .value("VERBOSITY_INFO_WARNING_ERROR", VERBOSITY_INFO_WARNING_ERROR)
+      .value("VERBOSITY_WARNING_ERROR", VERBOSITY_WARNING_ERROR)
+      .value("VERBOSITY_ERROR", VERBOSITY_ERROR)
+      .value("VERBOSITY_NONE", VERBOSITY_NONE)
+      .export_values();
+
+  bp::class_<Entity, boost::noncopyable>("Entity", bp::no_init)
+      .add_property("name",
+                    bp::make_function(
+                        &Entity::getName,
+                        bp::return_value_policy<bp::copy_const_reference>()))
+      .add_property("className",
+                    bp::make_function(
+                        &Entity::getClassName,
+                        bp::return_value_policy<bp::copy_const_reference>()),
+                    "the class name of the Entity")
+      .add_property("__doc__", &Entity::getDocString)
+
+      .def("setLoggerVerbosityLevel", &Entity::setLoggerVerbosityLevel)
+      .def("getLoggerVerbosityLevel", &Entity::getLoggerVerbosityLevel)
+      .add_property("loggerVerbosityLevel", &Entity::setLoggerVerbosityLevel,
+                    &Entity::getLoggerVerbosityLevel,
+                    "the verbosity level of the entity")
+      .def("setTimeSample", &Entity::setTimeSample)
+      .def("getTimeSample", &Entity::getTimeSample)
+      .add_property("timeSample", &Entity::getTimeSample,
+                    &Entity::setTimeSample,
+                    "the time sample for printing debugging information")
+      .def("setStreamPrintPeriod", &Entity::setStreamPrintPeriod)
+      .def("getStreamPrintPeriod", &Entity::getStreamPrintPeriod)
+      .add_property("streamPrintPeriod", &Entity::getStreamPrintPeriod,
+                    &Entity::setStreamPrintPeriod,
+                    "set the period at which debugging information are printed")
+
+      .def(
+          "__str__",
+          +[](const Entity& e) -> std::string {
+            std::ostringstream os;
+            e.display(os);
+            return os.str();
+          })
+      .def(
+          "signals",
+          +[](const Entity& e) -> bp::list {
+            bp::list ret;
+            for (auto& el : e.getSignalMap()) ret.append(bp::ptr(el.second));
+            return ret;
+          },
+          "Return the list of signals.")
+      //.def("signal", +[](Entity& e, const std::string &name) { return
+      //&e.getSignal(name); },
+      // reference_existing_object())
+      .def("signal", &getSignal, reference_existing_object(),
+           "get signal by name from an Entity", bp::arg("name"))
+      .def("hasSignal", &Entity::hasSignal,
+           "return True if the entity has a signal with the given name")
+
+      .def(
+          "displaySignals",
+          +[](const Entity& e) {
+            Entity::SignalMap signals(e.getSignalMap());
+            std::cout << "--- <" << e.getName();
+            if (signals.empty())
+              std::cout << "> has no signal\n";
+            else
+              std::cout << "> signal list:\n";
+            for (const auto& el : signals)
+              el.second->display(std::cout << "    |-- <") << '\n';
+          },
+          "Print the list of signals into standard output: temporary.")
+
+      /*
+      .def("__getattr__", +[](Entity& e, const std::string &name) ->
+      SignalBase<int>* { return &e.getSignal(name); },
+          reference_existing_object())
+      def __getattr__(self, name):
+          try:
+              return self.signal(name)
+          except Exception:
+              try:
+                  object.__getattr__(self, name)
+              except AttributeError:
+                  raise AttributeError("'%s' entity has no attribute %s\n" %
+      (self.name, name) + '  entity attributes are usually either\n' + '    -
+      commands,\n' + '    - signals or,\n' + '    - user defined attributes')
+                                       */
+      /*
+      .def("__setattr__", +[](bp::object self, const std::string &name,
+      bp::object value) { Entity& e = bp::extract<Entity&> (self); if
+      (e.hasSignal(name)) throw std::invalid_argument(name + " already
+      designates a signal. " "It is not advised to set a new attribute of the
+      same name.");
+            // TODO How do you do that ? I am sure it is possible.
+            //object.__setattr__(self, name, value)
+          })
+          */
+
+      /* TODO ?
+      def boundNewCommand(self, cmdName):
+          """
+          At construction, all existing commands are bound directly in the
+      class. This method enables to bound new commands dynamically. These new
+      bounds are not made with the class, but directly with the object instance.
+          """
+      def boundAllNewCommands(self):
+          """
+          For all commands that are not attribute of the object instance nor of
+      the class, a new attribute of the instance is created to bound the
+      command.
+          """
+          */
+
+      // For backward compat
+      .add_static_property(
+          "entities",
+          bp::make_function(&getEntityMap, reference_existing_object()));
+
+  python::exposeEntity<PythonEntity, bp::bases<Entity>, 0>()
+      .def("signalRegistration", &PythonEntity::signalRegistration)
+      .def("signalDeregistration", &PythonEntity::signalDeregistration);
+
+  python::exposeEntity<python::PythonSignalContainer, bp::bases<Entity>, 0>()
+      .def("rmSignal", &python::PythonSignalContainer::rmSignal,
+           "Remove a signal", bp::arg("signal_name"));
+}
+
+void exposeCommand() {
+  using dg::command::Command;
+  bp::class_<Command, boost::noncopyable>("Command", bp::no_init)
+      .def("__call__", bp::raw_function(dg::python::entity::executeCmd, 1),
+           "execute the command")
+      .add_property("__doc__", &Command::getDocstring);
+}
+
+void exposeOldAPI() {
+  bp::def("plug", dynamicgraph::python::plug,
+          "plug an output signal into an input signal",
+          (bp::arg("signalOut"), "signalIn"));
+  bp::def("enableTrace", dynamicgraph::python::enableTrace,
+          "Enable or disable tracing debug info in a file");
+  // Signals
+  bp::def("create_signal_wrapper",
+          dynamicgraph::python::signalBase::createSignalWrapper,
+          reference_existing_object(), "create a SignalWrapper C++ object");
+  // Entity
+  bp::def("factory_get_entity_class_list",
+          dynamicgraph::python::factory::getEntityClassList,
+          "return the list of entity classes");
+  bp::def("writeGraph", dynamicgraph::python::pool::writeGraph,
+          "Write the graph of entities in a filename.");
+  bp::def("get_entity_list", dynamicgraph::python::pool::getEntityList,
+          "return the list of instanciated entities");
+  bp::def("addLoggerFileOutputStream",
+          dynamicgraph::python::debug::addLoggerFileOutputStream,
+          "add a output file stream to the logger by filename");
+  bp::def("addLoggerCoutOutputStream",
+          dynamicgraph::python::debug::addLoggerCoutOutputStream,
+          "add std::cout as output stream to the logger");
+  bp::def("closeLoggerFileOutputStream",
+          dynamicgraph::python::debug::closeLoggerFileOutputStream,
+          "close all the loggers file output streams.");
+  bp::def("real_time_logger_destroy",
+          dynamicgraph::python::debug::realTimeLoggerDestroy,
+          "Destroy the real time logger.");
+  bp::def("real_time_logger_spin_once",
+          dynamicgraph::python::debug::realTimeLoggerSpinOnce,
+          "Destroy the real time logger.");
+  bp::def("real_time_logger_instance",
+          dynamicgraph::python::debug::realTimeLoggerInstance,
+          "Starts the real time logger.");
+}
+
+void enableEigenPy() {
+  eigenpy::enableEigenPy();
+
+  if (!eigenpy::register_symbolic_link_to_registered_type<Eigen::Quaterniond>())
+    eigenpy::exposeQuaternion();
+  if (!eigenpy::register_symbolic_link_to_registered_type<Eigen::AngleAxisd>())
+    eigenpy::exposeAngleAxis();
+
+  eigenpy::enableEigenPySpecific<Eigen::Matrix4d>();
+}
+
+BOOST_PYTHON_MODULE(wrap) {
+  enableEigenPy();
+
+  exposeOldAPI();
+
+  dg::python::exposeSignals();
+  exposeEntityBase();
+  exposeCommand();
+
+  typedef dg::PoolStorage::Entities MapOfEntities;
+  bp::class_<MapOfEntities>("MapOfEntities")
+      .def("__len__", &MapOfEntities::size)
+      .def(
+          "keys",
+          +[](const MapOfEntities& m) -> bp::tuple {
+            bp::list res;
+            for (const auto& el : m) res.append(el.first);
+            return bp::tuple(res);
+          })
+      .def(
+          "values",
+          +[](const MapOfEntities& m) -> bp::tuple {
+            bp::list res;
+            for (const auto& el : m) res.append(bp::ptr(el.second));
+            return bp::tuple(res);
+          })
+      .def("__getitem__",
+           static_cast<dg::Entity*& (MapOfEntities::*)(const std::string& k)>(
+               &MapOfEntities::at),
+           reference_existing_object())
+      .def(
+          "__setitem__", +[](MapOfEntities& m, const std::string& n,
+                             dg::Entity* e) { m.emplace(n, e); })
+      .def("__iter__", bp::iterator<MapOfEntities>())
+      .def(
+          "__contains__",
+          +[](const MapOfEntities& m, const std::string& n) -> bool {
+            return m.count(n);
+          });
+  bp::to_python_converter<MapOfEntities::value_type,
+                          MapOfEntitiesPairToPythonConverter>();
+}

src/dynamic_graph/entity-py.cc

+// Copyright 2010, Florent Lamiraux, Thomas Moulard, LAAS-CNRS.
+
+#include <dynamic-graph/command.h>
+#include <dynamic-graph/entity.h>
+#include <dynamic-graph/factory.h>
+#include <dynamic-graph/linear-algebra.h>
+#include <dynamic-graph/pool.h>
+#include <dynamic-graph/value.h>
+
+#include <iostream>
+
+#include "dynamic-graph/python/convert-dg-to-py.hh"
+#include "dynamic-graph/python/dynamic-graph-py.hh"
+
+// Ignore "dereferencing type-punned pointer will break strict-aliasing rules"
+// warnings on gcc caused by Py_RETURN_TRUE and Py_RETURN_FALSE.
+#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+namespace bp = boost::python;
+
+using dynamicgraph::Entity;
+using dynamicgraph::Matrix;
+using dynamicgraph::SignalBase;
+using dynamicgraph::Vector;
+using dynamicgraph::command::Command;
+using dynamicgraph::command::Value;
+
+namespace dynamicgraph {
+namespace python {
+
+using namespace convert;
+
+namespace entity {
+
+/// \param obj an Entity object
+void addCommands(bp::object obj) {
+  Entity& entity = bp::extract<Entity&>(obj);
+  for (const auto& el : entity.getNewStyleCommandMap())
+    obj.attr(el.first.c_str()) = bp::object(bp::ptr(el.second));
+}
+
+/// \param obj an Entity object
+void addSignals(bp::object obj) {
+  Entity& entity = bp::extract<Entity&>(obj);
+  for (const auto& el : entity.getSignalMap())
+    // obj.attr(el.first.c_str()) = bp::make_function(
+    //+[&entity,el]() { return &entity.getSignal(el.first); },
+    // bp::return_value_policy<bp::reference_existing_object>());
+    obj.attr(el.first.c_str()) = bp::object(bp::ptr(el.second));
+}
+
+/**
+   \brief Create an instance of Entity
+*/
+Entity* create(const char* className, const char* instanceName) {
+  Entity* obj = NULL;
+  /* Try to find if the corresponding object already exists. */
+  if (dynamicgraph::PoolStorage::getInstance()->existEntity(instanceName,
+                                                            obj)) {
+    if (obj->getClassName() != className) {
+      throw std::invalid_argument("Found an object named " +
+                                  std::string(instanceName) +
+                                  ",\n"
+                                  "but this object is of type " +
+                                  std::string(obj->getClassName()) +
+                                  " and not " + std::string(className));
+    }
+  } else /* If not, create a new object. */
+  {
+    obj = dynamicgraph::FactoryStorage::getInstance()->newEntity(
+        std::string(className), std::string(instanceName));
+  }
+
+  return obj;
+}
+
+bp::object executeCmd(bp::tuple args, bp::dict) {
+  Command& command = bp::template extract<Command&>(args[0]);
+  if (bp::len(args) != int(command.valueTypes().size() + 1))
+    // TODO Put expected and given number of args
+    throw std::out_of_range("Wrong number of arguments");
+  std::vector<Value> values;
+  values.reserve(command.valueTypes().size());
+  for (int i = 1; i < bp::len(args); ++i)
+    values.push_back(convert::toValue(args[i], command.valueTypes()[i - 1]));
+  command.setParameterValues(values);
+  return convert::fromValue(command.execute());
+}
+
+}  // namespace entity
+}  // namespace python
+}  // namespace dynamicgraph

src/dynamic_graph/entity.py

+# Copyright (C) 2020 CNRS
+#
+# Author: Florent Lamiraux, Nicolas Mansard
+
+from __future__ import print_function
+
+# for backward compat
+from .wrap import LoggerVerbosity as VerbosityLevel  # noqa
+from .wrap import Entity  # noqa

src/dynamic_graph/factory-py.cc

+// Copyright 2010, Florent Lamiraux, Thomas Moulard, LAAS-CNRS.
+
+#include <dynamic-graph/factory.h>
+
+#include <iostream>
+
+#include "dynamic-graph/python/dynamic-graph-py.hh"
+
+using dynamicgraph::Entity;
+using dynamicgraph::ExceptionAbstract;
+
+namespace dynamicgraph {
+namespace python {
+
+namespace factory {
+
+/**
+   \brief Get name of entity
+*/
+bp::tuple getEntityClassList() {
+  std::vector<std::string> classNames;
+  dynamicgraph::FactoryStorage::getInstance()->listEntities(classNames);
+  return to_py_tuple(classNames.begin(), classNames.end());
+}
+
+}  // namespace factory
+}  // namespace python
+}  // namespace dynamicgraph

src/dynamic_graph/pool-py.cc

+// Copyright 2011, 2012, Florent Lamiraux, LAAS-CNRS.
+
+#include <dynamic-graph/entity.h>
+#include <dynamic-graph/pool.h>
+
+#include <vector>
+
+#include "dynamic-graph/python/dynamic-graph-py.hh"
+
+namespace dynamicgraph {
+namespace python {
+
+namespace pool {
+
+void writeGraph(const char* filename) {
+  PoolStorage::getInstance()->writeGraph(filename);
+}
+
+const std::map<std::string, Entity*>* getEntityMap() {
+  return &PoolStorage::getInstance()->getEntityMap();
+}
+
+/**
+   \brief Get list of entities
+*/
+bp::list getEntityList() {
+  std::vector<std::string> entityNames;
+  bp::list res;
+  const PoolStorage::Entities& listOfEntities =
+      PoolStorage::getInstance()->getEntityMap();
+
+  for (const auto& el : listOfEntities) res.append(el.second->getName());
+  return res;
+}
+
+}  // namespace pool
+}  // namespace python
+}  // namespace dynamicgraph

src/dynamic_graph/python-compat.cc

+#include "dynamic-graph/python/python-compat.hh"
+
+// Get any PyObject and get its str() representation as an std::string
+std::string obj_to_str(PyObject* o) {
+  std::string ret;
+  PyObject* os;
+#if PY_MAJOR_VERSION >= 3
+  os = PyObject_Str(o);
+  assert(os != NULL);
+  assert(PyUnicode_Check(os));
+  ret = PyUnicode_AsUTF8(os);
+#else
+  os = PyObject_Unicode(o);
+  assert(os != NULL);
+  assert(PyUnicode_Check(os));
+  PyObject* oss = PyUnicode_AsUTF8String(os);
+  assert(oss != NULL);
+  ret = PyString_AsString(oss);
+  Py_DECREF(oss);
+#endif
+  Py_DECREF(os);
+  return ret;
+}

src/dynamic_graph/script_shortcuts.py

+# Defines the following shortcuts:
+# signal.name -> return the shortname
+# signal      -> display nicely the content of the signal
+# signal(3)   -> recompute the signal at time 3, and display nicely
+# signal +1   -> increment the signal time of 1, recompute, and display.
+# signal.deps -> display the graph dependancy up to the default value (3)
+# signal.deps(6) -> same, but with depth = 6.
+# entity      -> same as print(entity)
+# change the prompt to be '%'
+
+from __future__ import print_function
+
+# Changing prompt
+import sys
+
+from .entity import Entity
+from .signal_base import SignalBase
+
+
+# Enables shortcut "name"
+def sig_short_name(self):
+    return self.getName().split(":")[-1]
+
+
+setattr(SignalBase, "name", property(sig_short_name))
+
+
+# Enables shortcuts "m"
+# This code implements a pseudo function 'm' in the class signal_base,
+# with no args, or optional args. Three calls can be made:
+#    - sig.m : print the current value.
+#    - sig.m(time): recompute at given <time>, and display the current value
+#    - sig.m +time: recompute at <time> after current time, and display.
+class PrettySignalPrint:
+    sig = None
+
+    def __init__(self, sig):
+        self.sig = sig
+
+    def __str__(self):
+        return self.sig.name + " = " + str(self.sig.value)
+
+    def __repr__(self):
+        return str(self)
+
+    def __call__(self, iter):
+        self.sig.recompute(iter)
+        return self
+
+    def __add__(self, iter):
+        self.sig.recompute(self.sig.time + iter)
+        return self
+
+
+def sigMatPrint(sig):
+    return PrettySignalPrint(sig)
+
+
+setattr(SignalBase, "m", property(PrettySignalPrint))
+
+
+# Enable the same as 'm', but directly on the signal object.
+def sigRepr(self):
+    return self.name + " = " + str(self.value)
+
+
+def sigCall(sig, iter):
+    sig.recompute(iter)
+    print(sigRepr(sig))
+
+
+def sigTimeIncr(sig, iter):
+    sig.recompute(sig.time + iter)
+    print(sigRepr(sig))
+
+
+setattr(SignalBase, "__repr__", sigRepr)
+setattr(SignalBase, "__call__", sigCall)
+setattr(SignalBase, "__add__", sigTimeIncr)
+
+
+# Enables shortcut "deps"
+# Implements the peudo function 'deps', that can be called without arg,
+# or specifying a specific depth to be printed.
+class SignalDepPrint:
+    defaultDepth = 2
+    sig = None
+
+    def __init__(self, sig):
+        self.sig = sig
+
+    def __repr__(self):
+        return self.sig.displayDependencies(self.defaultDepth)
+
+    def __call__(self, depth):
+        self.defaultDepth = depth
+        return self
+
+
+setattr(SignalBase, "deps", property(SignalDepPrint))
+
+setattr(Entity, "sigs", property(Entity.displaySignals))
+setattr(Entity, "__repr__", Entity.__str__)
+
+sys.ps1 = "% "
+
+
+# Enable function that can be call without()def optionalparentheses(f):
+def optionalparentheses(f):
+    class decoclass:
+        def __init__(self, f):
+            self.functor = f
+
+        def __repr__(self):
+            res = self.functor()
+            if isinstance(res, str):
+                return res
+            else:
+                return ""
+
+        def __call__(self, *arg):
+            return self.functor(*arg)
+
+    return decoclass(f)

src/dynamic_graph/signal-base-py.cc

+// Copyright 2010, Florent Lamiraux, Thomas Moulard, LAAS-CNRS.
+
+#include <dynamic-graph/linear-algebra.h>
+#include <dynamic-graph/signal-base.h>
+#include <dynamic-graph/signal-ptr.h>
+#include <dynamic-graph/signal-time-dependent.h>
+#include <dynamic-graph/signal.h>
+#include <dynamic-graph/value.h>
+
+#include <boost/python.hpp>
+#include <iostream>
+#include <sstream>
+
+#include "dynamic-graph/python/dynamic-graph-py.hh"
+#include "dynamic-graph/python/signal-wrapper.hh"
+#include "dynamic-graph/python/signal.hh"
+
+using dynamicgraph::SignalBase;
+
+namespace bp = boost::python;
+
+namespace dynamicgraph {
+namespace python {
+
+typedef int time_type;
+
+typedef Eigen::AngleAxis<double> VectorUTheta;
+typedef Eigen::Quaternion<double> Quaternion;
+
+typedef Eigen::VectorXd Vector;
+typedef Eigen::Vector3d Vector3;
+typedef Eigen::Matrix<double, 7, 1> Vector7;
+
+typedef Eigen::MatrixXd Matrix;
+typedef Eigen::Matrix<double, 3, 3> MatrixRotation;
+typedef Eigen::Matrix<double, 4, 4> Matrix4;
+typedef Eigen::Transform<double, 3, Eigen::Affine> MatrixHomogeneous;
+typedef Eigen::Matrix<double, 6, 6> MatrixTwist;
+
+template <typename Time>
+void exposeSignalBase(const char* name) {
+  typedef SignalBase<Time> S_t;
+  bp::class_<S_t, boost::noncopyable>(name, bp::no_init)
+      .add_property("time",
+                    bp::make_function(
+                        &S_t::getTime,
+                        bp::return_value_policy<bp::copy_const_reference>()),
+                    &S_t::setTime)
+      .add_property("name",
+                    bp::make_function(
+                        &S_t::getName,
+                        bp::return_value_policy<bp::copy_const_reference>()))
+
+      .def("getName", &S_t::getName,
+           bp::return_value_policy<bp::copy_const_reference>())
+      .def(
+          "getClassName",
+          +[](const S_t& s) -> std::string {
+            std::string ret;
+            s.getClassName(ret);
+            return ret;
+          })
+
+      .def("plug", &S_t::plug, "Plug the signal to another signal")
+      .def("unplug", &S_t::unplug, "Unplug the signal")
+      .def("isPlugged", &S_t::isPlugged, "Whether the signal is plugged")
+      .def("getPlugged", &S_t::getPluged,
+           bp::return_value_policy<bp::reference_existing_object>(),
+           "To which signal the signal is plugged")
+
+      .def("recompute", &S_t::recompute, "Recompute the signal at given time")
+
+      .def(
+          "__str__",
+          +[](const S_t& s) -> std::string {
+            std::ostringstream oss;
+            s.display(oss);
+            return oss.str();
+          })
+      .def(
+          "displayDependencies",
+          +[](const S_t& s, int time) -> std::string {
+            std::ostringstream oss;
+            s.displayDependencies(oss, time);
+            return oss.str();
+          },
+          "Print the signal dependencies in a string");
+}
+
+template <>
+auto exposeSignal<MatrixHomogeneous, time_type>(const std::string& name) {
+  typedef Signal<MatrixHomogeneous, time_type> S_t;
+  bp::class_<S_t, bp::bases<SignalBase<time_type> >, boost::noncopyable> obj(
+      name.c_str(), bp::init<std::string>());
+  obj.add_property(
+      "value",
+      +[](const S_t& signal) -> Matrix4 {
+        return signal.accessCopy().matrix();
+      },
+      +[](S_t& signal, const Matrix4& v) {
+        // TODO it isn't hard to support pinocchio::SE3 type here.
+        // However, this adds a dependency to pinocchio.
+        signal.setConstant(MatrixHomogeneous(v));
+      },
+      "the signal value.");
+  return obj;
+}
+
+void exposeSignals() {
+  exposeSignalBase<time_type>("SignalBase");
+
+  exposeSignalsOfType<bool, time_type>("Bool");
+  exposeSignalsOfType<int, time_type>("Int");
+  exposeSignalsOfType<double, time_type>("Double");
+
+  exposeSignalsOfType<Vector, time_type>("Vector");
+  exposeSignalsOfType<Vector3, time_type>("Vector3");
+  exposeSignalsOfType<Vector7, time_type>("Vector7");
+
+  exposeSignalsOfType<Matrix, time_type>("Matrix");
+  exposeSignalsOfType<MatrixRotation, time_type>("MatrixRotation");
+  exposeSignalsOfType<MatrixHomogeneous, time_type>("MatrixHomogeneous");
+  exposeSignalsOfType<MatrixTwist, time_type>("MatrixTwist");
+
+  exposeSignalsOfType<Quaternion, time_type>("Quaternion");
+  exposeSignalsOfType<VectorUTheta, time_type>("VectorUTheta");
+}
+
+namespace signalBase {
+
+template <class T>
+SignalWrapper<T, int>* createSignalWrapperTpl(const char* name, bp::object o,
+                                              std::string& error) {
+  typedef SignalWrapper<T, int> SignalWrapper_t;
+  if (!SignalWrapper_t::checkCallable(o, error)) {
+    return NULL;
+  }
+
+  SignalWrapper_t* obj = new SignalWrapper_t(name, o);
+  return obj;
+}
+
+PythonSignalContainer* getPythonSignalContainer() {
+  Entity* obj = entity::create("PythonSignalContainer", "python_signals");
+  return dynamic_cast<PythonSignalContainer*>(obj);
+}
+
+#define SIGNAL_WRAPPER_TYPE(IF, Enum, Type)                               \
+  IF(command::Value::typeName(command::Value::Enum).compare(type) == 0) { \
+    obj = createSignalWrapperTpl<Type>(name, object, error);              \
+  }
+
+/**
+   \brief Create an instance of SignalWrapper
+*/
+SignalBase<int>* createSignalWrapper(const char* name, const char* type,
+                                     bp::object object) {
+  PythonSignalContainer* psc = getPythonSignalContainer();
+  if (psc == NULL) return NULL;
+
+  SignalBase<int>* obj = NULL;
+  std::string error;
+  SIGNAL_WRAPPER_TYPE(if, BOOL, bool)
+  // SIGNAL_WRAPPER_TYPE(else if, UNSIGNED ,bool)
+  SIGNAL_WRAPPER_TYPE(else if, INT, int)
+  SIGNAL_WRAPPER_TYPE(else if, FLOAT, float)
+  SIGNAL_WRAPPER_TYPE(else if, DOUBLE, double)
+  // SIGNAL_WRAPPER_TYPE(else if, STRING   ,bool)
+  SIGNAL_WRAPPER_TYPE(else if, VECTOR, Vector)
+  // SIGNAL_WRAPPER_TYPE(else if, MATRIX   ,bool)
+  // SIGNAL_WRAPPER_TYPE(else if, MATRIX4D ,bool)
+  else {
+    error = "Type not understood";
+  }
+
+  if (obj == NULL) throw std::runtime_error(error);
+  // Register signal into the python signal container
+  psc->signalRegistration(*obj);
+
+  // Return the pointer
+  return obj;
+}
+
+}  // namespace signalBase
+}  // namespace python
+}  // namespace dynamicgraph

src/dynamic_graph/signal-wrapper.cc

+// Copyright (c) 2018, Joseph Mirabel
+// Authors: Joseph Mirabel (joseph.mirabel@laas.fr)
+
+#include "dynamic-graph/python/signal-wrapper.hh"
+
+#include <dynamic-graph/command-bind.h>
+#include <dynamic-graph/factory.h>
+
+namespace dynamicgraph {
+namespace python {
+void PythonSignalContainer::signalRegistration(
+    const SignalArray<int>& signals) {
+  Entity::signalRegistration(signals);
+}
+
+void PythonSignalContainer::rmSignal(const std::string& name) {
+  Entity::signalDeregistration(name);
+}
+
+DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(PythonSignalContainer,
+                                   "PythonSignalContainer");
+
+template <class T, class Time>
+bool SignalWrapper<T, Time>::checkCallable(pyobject c, std::string& error) {
+  if (PyCallable_Check(c.ptr()) == 0) {
+    error = boost::python::extract<std::string>(c.attr("__str__")());
+    error += " is not callable";
+    return false;
+  }
+  return true;
+}
+
+template class SignalWrapper<bool, int>;
+template class SignalWrapper<int, int>;
+template class SignalWrapper<float, int>;
+template class SignalWrapper<double, int>;
+template class SignalWrapper<Vector, int>;
+}  // namespace python
+}  // namespace dynamicgraph

src/dynamic_graph/signal_base.py

+# Copyright (C) 2020 CNRS
+#
+# Author: Joseph Mirabel
+
+from __future__ import print_function
+
+# I kept what follows for backward compatibility but I think it should be
+# removed
+import re
+
+from .wrap import SignalBase  # noqa
+from .wrap import create_signal_wrapper as SignalWrapper  # noqa
+
+
+def stringToTuple(vector):
+    """
+    Transform a string of format '[n](x_1,x_2,...,x_n)' into a tuple of numbers.
+    """
+    # Find vector length
+    a = re.match(r"\[(\d+)\]", vector)
+    size = int(a.group(1))
+    # remove '[n]' prefix
+    vector = vector[len(a.group(0)) :]
+    # remove '(' and ')' at beginning and end
+    vector = vector.lstrip("(").rstrip(")\n")
+    # split string by ','
+    vector = vector.split(",")
+    # check size
+    if len(vector) != size:
+        raise TypeError(
+            "displayed size "
+            + str(size)
+            + " of vector does not fit actual size: "
+            + str(len(vector))
+        )
+    res = map(float, vector)
+    return tuple(res)
+
+
+def tupleToString(vector):
+    """
+    Transform a tuple of numbers into a string of format
+    '[n](x_1, x_2, ..., x_n)'
+    """
+    string = "[%d](" % len(vector)
+    for x in vector[:-1]:
+        string += "%f," % x
+    string += "%f)" % vector[-1]
+    return string
+
+
+def stringToMatrix(string):
+    """
+    Transform a string of format
+    '[n,m]((x_11,x_12,...,x_1m),...,(x_n1,x_n2,...,x_nm))' into a tuple
+    of tuple of numbers.
+    """
+    # Find matrix size
+    a = re.search(r"\[(\d+),(\d+)]", string)
+    nRows = int(a.group(1))
+    nCols = int(a.group(2))
+    # Remove '[n,m]' prefix
+    string = string[len(a.group(0)) :]
+    rows = string.split("),(")
+    if len(rows) != nRows:
+        raise TypeError(
+            "displayed nb rows "
+            + nRows
+            + " of matrix does not fit actual nb rows: "
+            + str(len(rows))
+        )
+    m = []
+    for rstr in rows:
+        rstr = rstr.lstrip("(").rstrip(")\n")
+        r = map(float, rstr.split(","))
+        if len(r) != nCols:
+            raise TypeError(
+                "one row length "
+                + len(r)
+                + " of matrix does not fit displayed nb cols: "
+                + nCols
+            )
+        m.append(tuple(r))
+    return tuple(m)
+
+
+def matrixToString(matrix):
+    """
+    Transform a tuple of tuple of numbers into a string of format
+    '[n,m]((x_11,x_12,...,x_1m),...,(x_n1,x_n2,...,x_nm))'.
+    """
+    nRows = len(matrix)
+    if nRows == 0:
+        return "[0,0](())"
+    nCols = len(matrix[0])
+    string = "[%d,%d](" % (nRows, nCols)
+    for r in range(nRows):
+        string += "("
+        for c in range(nCols):
+            string += str(float(matrix[r][c]))
+            if c != nCols - 1:
+                string += ","
+        string += ")"
+        if r != nRows - 1:
+            string += ","
+    string += ")"
+    return string
+
+
+def objectToString(obj):
+    """
+    Transform an object to a string. Object is either
+      - an entity (more precisely a sub-class named Feature)
+      - a matrix
+      - a vector or
+      - a floating point number,
+      - an integer,
+      - a boolean,
+    """
+    if hasattr(obj, "__iter__"):
+        # matrix or vector
+        if len(obj) == 0:
+            return ""
+        else:
+            if hasattr(obj[0], "__iter__"):
+                # matrix
+                return matrixToString(obj)
+            else:
+                # vector
+                return tupleToString(obj)
+    elif hasattr(obj, "name"):
+        return obj.name
+    else:
+        return str(obj)
+
+
+def stringToObject(string):
+    """
+    Convert a string into one of the following types
+      - a matrix (tuple of tuple),
+      - a vector,
+      - an integer,
+      - a floating point number.
+    Successively attempts conversion in the above order and return
+    on success. If no conversion fits, the string is returned.
+    """
+    if isinstance(string, float):
+        return string
+    if isinstance(string, int):
+        return string
+    if isinstance(string, tuple):
+        return string
+    try:
+        return stringToMatrix(string)
+    except Exception:
+        pass
+    try:
+        return stringToTuple(string)
+    except Exception:
+        pass
+    try:
+        return int(string)
+    except Exception:
+        pass
+    try:
+        return float(string)
+    except Exception:
+        return string

src/dynamic_graph/tools.py

+# -*- coding: utf-8 -*-
+# Copyright 2011, Florent Lamiraux, Thomas Moulard, JRL, CNRS/AIST
+
+from __future__ import print_function
+
+
+def addTrace(robot, trace, entityName, signalName, autoRecompute=True):
+    """
+    Add a signal to a tracer and recompute it automatically if necessary.
+    """
+    signal = "{0}.{1}".format(entityName, signalName)
+    filename = "{0}-{1}".format(entityName, signalName).replace("/", "_")
+    trace.add(signal, filename)
+    if autoRecompute:
+        robot.device.after.addSignal(signal)

src/dynamic_graph/tracer/wrap.cc

+#include <dynamic-graph/tracer.h>
+
+#include "dynamic-graph/python/module.hh"
+
+BOOST_PYTHON_MODULE(wrap) {
+  using dynamicgraph::Tracer;
+
+  bp::import("dynamic_graph");
+  dynamicgraph::python::exposeEntity<Tracer>().def("addSignal",
+                                                   &Tracer::addSignalToTrace);
+}

src/dynamic_graph/tracer_real_time/wrap.cc

+#include <dynamic-graph/tracer-real-time.h>
+
+#include "dynamic-graph/python/module.hh"
+
+BOOST_PYTHON_MODULE(wrap) {
+  using dynamicgraph::Tracer;
+  using dynamicgraph::TracerRealTime;
+
+  bp::import("dynamic_graph.tracer");
+  dynamicgraph::python::exposeEntity<TracerRealTime, bp::bases<Tracer> >();
+}

src/interpreter.cc

+// -*- mode: c++ -*-
+// Copyright 2011, Florent Lamiraux, CNRS.
+
+#ifdef WIN32
+#include <Windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+#include <iostream>
+
+#include "dynamic-graph/debug.h"
+#include "dynamic-graph/python/interpreter.hh"
+
+std::ofstream dg_debugfile("/tmp/dynamic-graph-traces.txt",
+                           std::ios::trunc& std::ios::out);
+
+// Python initialization commands
+namespace dynamicgraph {
+namespace python {
+static const std::string pythonPrefix[8] = {
+    "from __future__ import print_function\n",
+    "import traceback\n",
+    "class StdoutCatcher:\n"
+    "    def __init__(self):\n"
+    "        self.data = ''\n"
+    "    def write(self, stuff):\n"
+    "        self.data = self.data + stuff\n"
+    "    def fetch(self):\n"
+    "        s = self.data[:]\n"
+    "        self.data = ''\n"
+    "        return s\n",
+    "stdout_catcher = StdoutCatcher()\n",
+    "stderr_catcher = StdoutCatcher()\n",
+    "import sys\n",
+    "sys.stdout = stdout_catcher",
+    "sys.stderr = stderr_catcher"};
+
+bool HandleErr(std::string& err, PyObject* globals_, int PythonInputType) {
+  dgDEBUGIN(15);
+  err = "";
+  bool lres = false;
+
+  if (PyErr_Occurred() != NULL) {
+    bool is_syntax_error = PyErr_ExceptionMatches(PyExc_SyntaxError);
+    PyErr_Print();
+    PyObject* stderr_obj = PyRun_String("stderr_catcher.fetch()", Py_eval_input,
+                                        globals_, globals_);
+    err = obj_to_str(stderr_obj);
+    Py_DECREF(stderr_obj);
+
+    // Here if there is a syntax error and
+    // and the interpreter input is set to Py_eval_input,
+    // it is maybe a statement instead of an expression.
+    // Therefore we indicate to re-evaluate the command.
+    if (is_syntax_error && PythonInputType == Py_eval_input) {
+      dgDEBUG(15) << "Detected a syntax error " << std::endl;
+      lres = false;
+    } else
+      lres = true;
+
+    PyErr_Clear();
+  } else {
+    dgDEBUG(15) << "no object generated but no error occured." << std::endl;
+  }
+  return lres;
+}
+
+Interpreter::Interpreter() {
+  // load python dynamic library
+  // this is silly, but required to be able to import dl module.
+#ifndef WIN32
+  dlopen(PYTHON_LIBRARY, RTLD_LAZY | RTLD_GLOBAL);
+#endif
+  Py_Initialize();
+#if PY_MAJOR_VERSION < 3 || PY_MINOR_VERSION < 7
+  PyEval_InitThreads();
+#endif
+  mainmod_ = PyImport_AddModule("__main__");
+  Py_INCREF(mainmod_);
+  globals_ = PyModule_GetDict(mainmod_);
+  assert(globals_);
+  Py_INCREF(globals_);
+  PyRun_SimpleString(pythonPrefix[0].c_str());
+  PyRun_SimpleString(pythonPrefix[1].c_str());
+  PyRun_SimpleString(pythonPrefix[2].c_str());
+  PyRun_SimpleString(pythonPrefix[3].c_str());
+  PyRun_SimpleString(pythonPrefix[4].c_str());
+  PyRun_SimpleString(pythonPrefix[5].c_str());
+  PyRun_SimpleString(pythonPrefix[6].c_str());
+  PyRun_SimpleString(pythonPrefix[7].c_str());
+  PyRun_SimpleString("import linecache");
+
+  // Allow threads
+  _pyState = PyEval_SaveThread();
+}
+
+Interpreter::~Interpreter() {
+  PyEval_RestoreThread(_pyState);
+
+  // Ideally, we should call Py_Finalize but this is not really supported by
+  // Python.
+  // Instead, we merelly remove variables.
+  // Code was taken here:
+  // https://github.com/numpy/numpy/issues/8097#issuecomment-356683953
+  {
+    PyObject* poAttrList = PyObject_Dir(mainmod_);
+    PyObject* poAttrIter = PyObject_GetIter(poAttrList);
+    PyObject* poAttrName;
+
+    while ((poAttrName = PyIter_Next(poAttrIter)) != NULL) {
+      std::string oAttrName(obj_to_str(poAttrName));
+
+      // Make sure we don't delete any private objects.
+      if (oAttrName.compare(0, 2, "__") != 0 ||
+          oAttrName.compare(oAttrName.size() - 2, 2, "__") != 0) {
+        PyObject* poAttr = PyObject_GetAttr(mainmod_, poAttrName);
+
+        // Make sure we don't delete any module objects.
+        if (poAttr && poAttr->ob_type != mainmod_->ob_type)
+          PyObject_SetAttr(mainmod_, poAttrName, NULL);
+
+        Py_DECREF(poAttr);
+      }
+
+      Py_DECREF(poAttrName);
+    }
+
+    Py_DECREF(poAttrIter);
+    Py_DECREF(poAttrList);
+  }
+
+  Py_DECREF(mainmod_);
+  Py_DECREF(globals_);
+  // Py_Finalize();
+}
+
+std::string Interpreter::python(const std::string& command) {
+  std::string lerr(""), lout(""), lres("");
+  python(command, lres, lout, lerr);
+  return lres;
+}
+
+void Interpreter::python(const std::string& command, std::string& res,
+                         std::string& out, std::string& err) {
+  res = "";
+  out = "";
+  err = "";
+
+  // Check if the command is not a python comment or empty.
+  std::string::size_type iFirstNonWhite = command.find_first_not_of(" \t");
+  // Empty command
+  if (iFirstNonWhite == std::string::npos) return;
+  // Command is a comment. Ignore it.
+  if (command[iFirstNonWhite] == '#') return;
+
+  PyEval_RestoreThread(_pyState);
+
+  std::cout << command.c_str() << std::endl;
+  PyObject* result =
+      PyRun_String(command.c_str(), Py_eval_input, globals_, globals_);
+  // Check if the result is null.
+  if (result == NULL) {
+    // Test if this is a syntax error (due to the evaluation of an expression)
+    // else just output the problem.
+    if (!HandleErr(err, globals_, Py_eval_input)) {
+      // If this is a statement, re-parse the command.
+      result =
+          PyRun_String(command.c_str(), Py_single_input, globals_, globals_);
+
+      // If there is still an error build the appropriate err string.
+      if (result == NULL) HandleErr(err, globals_, Py_single_input);
+      // If there is no error, make sure that the previous error message is
+      // erased.
+      else
+        err = "";
+    } else
+      dgDEBUG(15) << "Do not try a second time." << std::endl;
+  }
+
+  PyObject* stdout_obj = 0;
+  stdout_obj =
+      PyRun_String("stdout_catcher.fetch()", Py_eval_input, globals_, globals_);
+  out = obj_to_str(stdout_obj);
+  Py_DECREF(stdout_obj);
+  // Local display for the robot (in debug mode or for the logs)
+  if (out.size() != 0) std::cout << "Output:" << out << std::endl;
+  if (err.size() != 0) std::cout << "Error:" << err << std::endl;
+  // If python cannot build a string representation of result
+  // then results is equal to NULL. This will trigger a SEGV
+  dgDEBUG(15) << "For command: " << command << std::endl;
+  if (result != NULL) {
+    res = obj_to_str(result);
+    dgDEBUG(15) << "Result is: " << res << std::endl;
+    Py_DECREF(result);
+  } else {
+    dgDEBUG(15) << "Result is: empty" << std::endl;
+  }
+  dgDEBUG(15) << "Out is: " << out << std::endl;
+  dgDEBUG(15) << "Err is :" << err << std::endl;
+
+  _pyState = PyEval_SaveThread();
+
+  return;
+}
+
+PyObject* Interpreter::globals() { return globals_; }
+
+void Interpreter::runPythonFile(std::string filename) {
+  std::string err = "";
+  runPythonFile(filename, err);
+}
+
+void Interpreter::runPythonFile(std::string filename, std::string& err) {
+  FILE* pFile = fopen(filename.c_str(), "r");
+  if (pFile == 0x0) {
+    err = filename + " cannot be open";
+    return;
+  }
+
+  PyEval_RestoreThread(_pyState);
+
+  err = "";
+  PyObject* run =
+      PyRun_File(pFile, filename.c_str(), Py_file_input, globals_, globals_);
+  if (run == NULL) {
+    HandleErr(err, globals_, Py_file_input);
+    std::cerr << err << std::endl;
+  }
+  Py_DecRef(run);
+
+  _pyState = PyEval_SaveThread();
+  fclose(pFile);
+}
+
+void Interpreter::runMain(void) {
+  PyEval_RestoreThread(_pyState);
+#if PY_MAJOR_VERSION >= 3
+  const Py_UNICODE* argv[] = {L"dg-embedded-pysh"};
+  Py_Main(1, const_cast<Py_UNICODE**>(argv));
+#else
+  const char* argv[] = {"dg-embedded-pysh"};
+  Py_Main(1, const_cast<char**>(argv));
+#endif
+  _pyState = PyEval_SaveThread();
+}
+
+std::string Interpreter::processStream(std::istream& stream, std::ostream& os) {
+  char line[10000];
+  sprintf(line, "%s", "\n");
+  std::string command;
+  std::streamsize maxSize = 10000;
+#if 0
+  while (line != std::string("")) {
+    stream.getline(line, maxSize, '\n');
+    command += std::string(line) + std::string("\n");
+  };
+#else
+  os << "dg> ";
+  stream.getline(line, maxSize, ';');
+  command += std::string(line);
+#endif
+  return command;
+}
+
+}  // namespace python
+}  // namespace dynamicgraph

tests/CMakeLists.txt

+# Copyright 2010-2020, Florent Lamiraux, Thomas Moulard, Olivier Stasse, Guilhem
+# Saurel, JRL, CNRS/AIST, LAAS-CNRS
+
+# Test the interpreter
+add_unit_test(interpreter-test interpreter-test.cc)
+target_link_libraries(interpreter-test PRIVATE ${PROJECT_NAME})
+
+# Test runfile
+add_unit_test(interpreter-test-runfile interpreter-test-runfile.cc)
+target_link_libraries(interpreter-test-runfile PRIVATE ${PROJECT_NAME})
+target_include_directories(interpreter-test-runfile
+                           PRIVATE Boost::unit_test_framework)
+target_compile_definitions(interpreter-test-runfile
+                           PRIVATE PATH="${CMAKE_CURRENT_LIST_DIR}/")
+
+# Test the module generation Create an entity
+
+set(LIBRARY_NAME "custom_entity")
+add_library(${LIBRARY_NAME} SHARED "${LIBRARY_NAME}.cpp")
+if(SUFFIX_SO_VERSION)
+  set_target_properties(${LIBRARY_NAME} PROPERTIES SOVERSION ${PROJECT_VERSION})
+endif(SUFFIX_SO_VERSION)
+
+target_link_libraries(${LIBRARY_NAME} PRIVATE dynamic-graph::dynamic-graph)
+
+# Create its bindings This mimics DYNAMIC_GRAPH_PYTHON_MODULE(${LIBRARY_NAME}
+# ${LIBRARY_NAME} "${LIBRARY_NAME}-wrap")
+
+configure_file(
+  ${PROJECT_SOURCE_DIR}/cmake/dynamic_graph/submodule/__init__.py.cmake
+  ${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME}/__init__.py)
+set(PYTHON_MODULE "${LIBRARY_NAME}-wrap")
+set(DYNAMICGRAPH_MODULE_HEADER
+    "${CMAKE_SOURCE_DIR}/tests/custom_entity_module.h")
+configure_file(${PROJECT_SOURCE_DIR}/cmake/dynamic_graph/python-module-py.cc.in
+               ${CMAKE_CURRENT_BINARY_DIR}/python-module-py.cc @ONLY)
+add_library(${PYTHON_MODULE} MODULE
+            ${CMAKE_CURRENT_BINARY_DIR}/python-module-py.cc)
+set_target_properties(${PYTHON_MODULE}
+                      PROPERTIES PREFIX "" OUTPUT_NAME ${LIBRARY_NAME}/wrap)
+
+if(UNIX AND NOT APPLE)
+  target_link_libraries(${PYTHON_MODULE} PRIVATE "-Wl,--no-as-needed")
+endif(UNIX AND NOT APPLE)
+
+target_link_libraries(${PYTHON_MODULE} PRIVATE ${LIBRARY_NAME} ${PROJECT_NAME})
+
+# Test it
+add_python_unit_test("test-custom-entity" "tests/test_custom_entity.py" src
+                     tests)
+
+# also test other bindings, using this custom entity
+add_python_unit_test("test-bindings" "tests/test_bindings.py" src tests)

tests/custom_entity.cpp

+/* Copyright 2010-2019 LAAS, CNRS
+ * Thomas Moulard.
+ *
+ */
+
+#define ENABLE_RT_LOG
+
+#include "custom_entity.h"
+
+#include <dynamic-graph/command-bind.h>
+#include <dynamic-graph/entity.h>
+#include <dynamic-graph/exception-factory.h>
+#include <dynamic-graph/factory.h>
+#include <dynamic-graph/pool.h>
+#include <dynamic-graph/real-time-logger.h>
+#include <dynamic-graph/signal-ptr.h>
+#include <dynamic-graph/signal-time-dependent.h>
+
+#include <boost/bind.hpp>
+
+namespace dynamicgraph {
+
+CustomEntity::CustomEntity(const std::string n)
+    : Entity(n),
+      m_sigdSIN(NULL, "CustomEntity(" + name + ")::input(double)::in_double"),
+      m_sigdTimeDepSOUT(boost::bind(&CustomEntity::update, this, _1, _2),
+                        m_sigdSIN,
+                        "CustomEntity(" + name + ")::input(double)::out_double")
+
+{
+  addSignal();
+
+  using namespace dynamicgraph::command;
+
+  this->addCommand("act",
+                   makeCommandVoid0(*this, &CustomEntity::act,
+                                    docCommandVoid0("act on input signal")));
+}
+
+void CustomEntity::addSignal() {
+  signalRegistration(m_sigdSIN << m_sigdTimeDepSOUT);
+}
+
+void CustomEntity::rmValidSignal() {
+  signalDeregistration("in_double");
+  signalDeregistration("out_double");
+}
+
+double &CustomEntity::update(double &res, const int &inTime) {
+  const double &aDouble = m_sigdSIN(inTime);
+  res = aDouble;
+  logger().stream(MSG_TYPE_ERROR) << "start update " << res << '\n';
+  DYNAMIC_GRAPH_ENTITY_DEBUG(*this)
+      << "This is a message of level MSG_TYPE_DEBUG\n";
+  DYNAMIC_GRAPH_ENTITY_INFO(*this)
+      << "This is a message of level MSG_TYPE_INFO\n";
+  DYNAMIC_GRAPH_ENTITY_WARNING(*this)
+      << "This is a message of level MSG_TYPE_WARNING\n";
+  DYNAMIC_GRAPH_ENTITY_ERROR(*this)
+      << "This is a message of level MSG_TYPE_ERROR\n";
+  DYNAMIC_GRAPH_ENTITY_DEBUG_STREAM(*this)
+      << "This is a message of level MSG_TYPE_DEBUG_STREAM\n";
+  DYNAMIC_GRAPH_ENTITY_INFO_STREAM(*this)
+      << "This is a message of level MSG_TYPE_INFO_STREAM\n";
+  DYNAMIC_GRAPH_ENTITY_WARNING_STREAM(*this)
+      << "This is a message of level MSG_TYPE_WARNING_STREAM\n";
+  DYNAMIC_GRAPH_ENTITY_ERROR_STREAM(*this)
+      << "This is a message of level MSG_TYPE_ERROR_STREAM\n";
+  logger().stream(MSG_TYPE_ERROR) << "end update\n";
+  return res;
+}
+
+void CustomEntity::act() { m_sigdSIN.accessCopy(); }
+
+DYNAMICGRAPH_FACTORY_ENTITY_PLUGIN(CustomEntity, "CustomEntity");
+}  // namespace dynamicgraph

tests/custom_entity.h

+/* Copyright 2020 LAAS, CNRS
+ * Joseph Mirabel
+ *
+ */
+
+#define ENABLE_RT_LOG
+
+#include <dynamic-graph/entity.h>
+#include <dynamic-graph/signal-ptr.h>
+#include <dynamic-graph/signal-time-dependent.h>
+
+#include <sstream>
+
+namespace dynamicgraph {
+class CustomEntity : public Entity {
+ public:
+  dynamicgraph::SignalPtr<double, int> m_sigdSIN;
+  dynamicgraph::SignalTimeDependent<double, int> m_sigdTimeDepSOUT;
+
+  DYNAMIC_GRAPH_ENTITY_DECL();
+  CustomEntity(const std::string n);
+
+  void addSignal();
+
+  void rmValidSignal();
+
+  double &update(double &res, const int &inTime);
+
+  void act();
+};
+}  // namespace dynamicgraph

tests/custom_entity_module.h

+#include "custom_entity.h"
+
+typedef boost::mpl::vector<dynamicgraph::CustomEntity> entities_t;