Embedding and extending within a C++ class ?

[nyue]

I have a class in which I have a method ::compute() which I am embedding Python

Within that embedding I would like the Python session to have access to call the C++ class methods to set/get information.

I am able to do the embedding, however, I am unable to setup a module to access the class' methods as extending via PYBIND11_EMBEDDED_MODULE creates static functions.

Is this possible with pybind11 or am I looking at the problem wrongly and hence not being able to find a solution ?

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

PYBIND11_EMBEDDED_MODULE(fast_calc, m)
{
  // `m` is a `py::module_` which is used to bind functions and classes
  m.def("add", [](int i, int j) { return i + j; });
}

class MyClass
{
public:
  MyClass()
    : _quantity(0){

    };
  virtual ~MyClass(){};
  int numComponents() { return _quantity; };
  void compute()
  {
    pybind11::scoped_interpreter guard{};

    auto fast_calc = pybind11::module_::import("fast_calc");

    std::string script =R"(
print(dir(fast_calc))
print('MyClass::compute()')
kwargs = dict(name = 'World', number = 42)
message = 'Hello, {name}! The answer is {number}'.format(**kwargs)
print(message)
    )";
    std::cout << "script = " << script << std::endl;
    pybind11::exec(script);
  }

private:
  int _quantity;
};

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

[nkr0]

Yes. You can do something like

PYBIND11_EMBEDDED_MODULE(fast_calc, m)
{
  py::class_<MyClass>(m, "PythonSideMyClassName")
    .def(py::init<>())
    .def("numComponents", &MyClass::numComponents)
}

https://pybind11.readthedocs.io/en/stable/advanced/classes.html

[nyue]

I have implemented your idea, here is the new code. However, I am unsure how I can access this new module method within the Python script block though i.e. how should I call the module method inside the script string in MyClass::compute() ?

I can list the module fast_calc but can't import it (maybe because it is already imported)

I am also unable to access the numComponents() method in the module

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

class MyClass
{
public:
  MyClass();
  virtual ~MyClass();
  int numComponents();
  void compute();

private:
  int _quantity;
};

PYBIND11_EMBEDDED_MODULE(fast_calc, m){ pybind11::class_<MyClass>(m, "PythonSideMyClassName")
                                           .def(pybind11::init<>())
                                           .def("numComponents", &MyClass::numComponents); }

MyClass::MyClass()
  : _quantity(0)
{
}

MyClass::~MyClass()
{

}

int MyClass::numComponents()
{
  return _quantity;
}

void MyClass::compute()
{
  pybind11::scoped_interpreter guard{};

  auto fast_calc = pybind11::module_::import("fast_calc");

    std::string script =R"(
#print(dir(fast_calc))

import sys
from pprint import pprint

# Get the list of all loaded module names
loaded_modules = list(sys.modules.keys())

# Print the list of loaded modules in a pretty format
pprint(loaded_modules)

a = fast_calc.numComponents()
print('numComponents = {}'.format(a))
print('MyClass::compute()')
kwargs = dict(name = 'World', number = 42)
message = 'Hello, {name}! The answer is {number}'.format(**kwargs)
print(message)
    )";
    std::cout << "script = " << script << std::endl;
    pybind11::exec(script);
}

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

[nkr0]

1. Before, I wrote PythonSideMyClassName. What I meant with that is how you want to address this class in your Python script. The name you write in double-quotes is how you would see it from python. If you just want the same name, that is also fine.

PYBIND11_EMBEDDED_MODULE(fast_calc, m){ pybind11::class_<MyClass>(m, "MyClass")
                                           .def(pybind11::init<>())
                                           .def("numComponents", &MyClass::numComponents); }

2. If you want to call MyClass::compute() from python, you should add that to the list of methods exposed in the PYBIND11_EMBEDDED_MODULE. But, that doesn't make sense in this case, because MyClass::compute() is the method that is calling python. You would end up in a loop between c++ <-> python. I think.
3. auto fast_calc = pybind11::module_::import("fast_calc"); imports python module into c++ for usage. Which is not what you want. You want a c++ api to be available in python. So you should import that in your python script. Like this,

    std::string script =R"(
import fast_calc
    )";

4. Now to use a class that you exposed you've to create an object from it in your python script. And then call the method on that object.

c = fast_calc.MyClass()
a = c.numComponents()
print('numComponents = {}'.format(a))