Access to C++ methods within embedded python script ?

[nyue]

This is related to another question I asked but I feel that I have did not phrased the other question clearly hence I am submitting a new question

I am developing a small library to allow user to run their own python script inside my library

My C++ node classes have functions to set/get attributes of the class

These attributes are not POD (plain old datatypes), they are objects which tracks modified time and connection to other attributes elsewhere within the framework amongst other information.

I do have methods for set/get.

What would be the pybind11 recommended way to wrap such instance method ?

What would be a call to those wrapped/extension looks like within the py_script that I will be executing within the embeded python ?

class PythonNode {
public:
  PythonNode(const std::string py_script);
  bool compute() {
    pybind11::scoped_interpreter guard{};
    pybind11::exec(_py_script);
  }
protected:
  bool setAttribute(const std::string& attributeName, const std::any& value);
  bool getAttribute(const std::string& attributeName, std::any& value) const;
private:
  std::string _py_script;
  AttributeDataDictionaryType _attributes;
};

Or would I be better off doing the C++ attribute query outside of the py_script (before executing it) via the py::dict() data and retrieving the output via an the create dictionary to retrieve the results as per this

#include <pybind11/embed.h>
#include <iostream>

namespace py = pybind11;
using namespace py::literals;

int main() {
    py::scoped_interpreter guard{};

    auto locals = py::dict("name"_a="World", "number"_a=42);
    py::exec(R"(
        message = "Hello, {name}! The answer is {number}".format(**locals())
    )", py::globals(), locals);

    auto message = locals["message"].cast<std::string>();
    std::cout << message;
}

I am looking for the best practice when using pybind11.

[obragaa]

Hii @nyue!

To expose C++ methods for access from an embedded Python script in your library, you should use pybind11 to create bindings. Here's a step-by-step guide to set this up with a practical example based on your PythonNode class:

1. Include pybind11 in your C++ project and define a module that exposes the PythonNode class.

2. Write bindings for your class that include the methods you want to access from Python. For example:

   #include <pybind11/pybind11.h>
   namespace py = pybind11;
   
   class PythonNode {
   public:
       PythonNode(const std::string& script) : _py_script(script) {}
   
       bool setAttribute(const std::string& attributeName, const std::any& value);
       bool getAttribute(const std::string& attributeName, std::any& value) const;
   
       void runScript() {
           py::scoped_interpreter guard{};
           py::exec(_py_script);
       }
   private:
       std::string _py_script;
   };
   
   PYBIND11_MODULE(my_module, m) {
       py::class_<PythonNode>(m, "PythonNode")
           .def(py::init<const std::string&>())
           .def("setAttribute", &PythonNode::setAttribute)
           .def("getAttribute", &PythonNode::getAttribute)
           .def("runScript", &PythonNode::runScript);
   }

3. Compile your C++ code with the pybind11 bindings and ensure that the module is accessible to Python.

4. In Python, you can now create instances of your C++ class and call its methods:

   import my_module
   
   node = my_module.PythonNode("some_script.py")
   node.setAttribute("some_attribute", value)
   attr_value = node.getAttribute("some_attribute")
   node.runScript()  # This will execute the specified Python script.

This is the straightforward way to set up and use access to the methods of your C++ class from an embedded Python script, using pybind11. If you need additional details or encounter specific issues, I'm here to help!

[nyue]

@obragaa Thank you for the suggestions.

My use case is not to create a new instance PythonNode, it must be the same instance (same this pointer). I need to be able to call the methods getAttribute() and setAttribute() from within the same instance that is running the _py_script. I am looking for an ability for the python command that is inside of _py_script to call those public methods.

[nyue]

I also attempted to pass the this point as a python object but no success

#include <pybind11/embed.h>

namespace py = pybind11;
using namespace py::literals;

class MyClass {
public:
    MyClass() {};

    double pureCMethod(double d);

    void methodWithPy();

private:
    double m_some_member;
};

// https://stackoverflow.com/questions/71716181/embedded-python-using-pybind11-in-c-class-how-to-call-member-function-of-c
PYBIND11_EMBEDDED_MODULE(myModule, m) {
    py::class_<MyClass>(m, "MyClass")
            .def("pureCMethod", &MyClass::pureCMethod);
}

// method of the c++ class that has acess to members and does some computation
double MyClass::pureCMethod(double d) {
    // here we have some costly computation
    return m_some_member * d;
}

// 2nd method of the c++ class that uses embedded python
void MyClass::methodWithPy() {
    namespace py = pybind11;
    using namespace py::literals;

    py::scoped_interpreter guard{};

    auto myModule = py::module_::import("myModule");
    auto locals = py::dict("mc"_a = this); // this pointer of class

    py::exec(R"(
print("Hello From Python")
result = 23.0 + 1337
result = MyClass::pureCMethod(result) // pseudocode here. how can I do this?
print(result)
    )", py::globals(), locals);
}


int main() {
    MyClass mc;
    mc.methodWithPy();
    return 0;
}