[Operator] Add getInputsName & getOutputsName methods.

python_binding/operator/pybind_FC.cpp

@@ -20,7 +20,9 @@ namespace py = pybind11;
 namespace Aidge {
 
 void declare_FC(py::module &m) {
-  py::class_<FC_Op, std::shared_ptr<FC_Op>, Operator, Attributes>(m, "FC_Op", py::multiple_inheritance());
+  py::class_<FC_Op, std::shared_ptr<FC_Op>, Operator, Attributes>(m, "FCOp", py::multiple_inheritance())
+  .def("get_inputs_name", &FC_Op::getInputsName)
+  .def("get_outputs_name", &FC_Op::getOutputsName);
 
   m.def("FC", &FC, py::arg("out_channels"), py::arg("nobias") = false, py::arg("name") = "");
 }

python_binding/operator/pybind_LeakyReLU.cpp

@@ -18,7 +18,9 @@ namespace py = pybind11;
 namespace Aidge {
 
 void init_LeakyReLU(py::module& m) {
-    py::class_<LeakyReLU_Op, std::shared_ptr<LeakyReLU_Op>, Operator, Attributes>(m, "LeakyReLU_Op", py::multiple_inheritance());
+    py::class_<LeakyReLU_Op, std::shared_ptr<LeakyReLU_Op>, Operator, Attributes>(m, "LeakyReLUOp", py::multiple_inheritance())
+    .def("get_inputs_name", &LeakyReLU_Op::getInputsName)
+    .def("get_outputs_name", &LeakyReLU_Op::getOutputsName);
 
     m.def("LeakyReLU", &LeakyReLU, py::arg("negative_slope") = 0.0f, py::arg("name") = "");
 }

python_binding/operator/pybind_Matmul.cpp

@@ -20,7 +20,9 @@ namespace py = pybind11;
 namespace Aidge {
 
 void declare_MatMul(py::module &m) {
-  py::class_<MatMul_Op, std::shared_ptr<MatMul_Op>, Operator, Attributes>(m, "MatMul_Op", py::multiple_inheritance());
+  py::class_<MatMul_Op, std::shared_ptr<MatMul_Op>, Operator, Attributes>(m, "MatMulOp", py::multiple_inheritance())
+  .def("get_inputs_name", &MatMul_Op::getInputsName)
+  .def("get_outputs_name", &MatMul_Op::getOutputsName);
 
   m.def("MatMul", &MatMul, py::arg("out_channels"), py::arg("name") = "");
 }

python_binding/operator/pybind_MaxPooling.cpp

@@ -32,13 +32,15 @@ template <DimIdx_t DIM> void declare_MaxPoolingOp(py::module &m) {
   .def(py::init<const std::array<DimSize_t, DIM> &,
                 const std::array<DimSize_t, DIM> &>(),
         py::arg("kernel_dims"),
-        py::arg("stride_dims"));
-  
-  m.def(("MaxPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims, 
+        py::arg("stride_dims"))
+  .def("get_inputs_name", &MaxPooling_Op<DIM>::getInputsName)
+  .def("get_outputs_name", &MaxPooling_Op<DIM>::getOutputsName);
+
+  m.def(("MaxPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
                                                                   const std::string& name,
                                                                   const std::vector<DimSize_t> &stride_dims) {
         // Lambda function wrapper because PyBind fails to convert const array.
-        // So we use a vector that we convert in this function to a const DimeSize_t [DIM] array. 
+        // So we use a vector that we convert in this function to a const DimeSize_t [DIM] array.
         if (kernel_dims.size() != DIM) {
             throw std::runtime_error("kernel_dims size [" + std::to_string(kernel_dims.size()) + "] does not match DIM [" + std::to_string(DIM) +"]");
         }
@@ -59,7 +61,7 @@ template <DimIdx_t DIM> void declare_MaxPoolingOp(py::module &m) {
     }, py::arg("kernel_dims"),
        py::arg("name") = "",
        py::arg("stride_dims") = std::vector<DimSize_t>(DIM,1));
-  
+
 }
 
 
@@ -67,10 +69,10 @@ void init_MaxPooling(py::module &m) {
   declare_MaxPoolingOp<1>(m);
   declare_MaxPoolingOp<2>(m);
   declare_MaxPoolingOp<3>(m);
- 
+
   // FIXME:
   // m.def("MaxPooling1D", static_cast<NodeAPI(*)(const char*, int, int, int const
   // (&)[1])>(&MaxPooling));
 }
 } // namespace Aidge
-#endif
\ No newline at end of file
+#endif

python_binding/operator/pybind_Producer.cpp

@@ -35,7 +35,9 @@ void init_Producer(py::module &m) {
         "ProducerOp",
         py::multiple_inheritance())
     .def("dims", &Producer_Op::dims)
-    .def("set_output_tensor", &Producer_Op::setOutputTensor);
+    .def("set_output_tensor", &Producer_Op::setOutputTensor)
+    .def("get_inputs_name", &Producer_Op::getInputsName)
+    .def("get_outputs_name", &Producer_Op::getOutputsName);
     m.def("Producer", static_cast<std::shared_ptr<Node>(*)(const std::shared_ptr<Tensor>, const std::string&)>(&Producer), py::arg("tensor"), py::arg("name") = "");
 
     declare_Producer<1>(m);

python_binding/operator/pybind_ReLU.cpp

@@ -18,7 +18,9 @@ namespace py = pybind11;
 namespace Aidge {
 
 void init_ReLU(py::module& m) {
-    py::class_<ReLU_Op, std::shared_ptr<ReLU_Op>, Operator>(m, "ReLU_Op", py::multiple_inheritance());
+    py::class_<ReLU_Op, std::shared_ptr<ReLU_Op>, Operator>(m, "ReLUOp", py::multiple_inheritance())
+    .def("get_inputs_name", &ReLU_Op::getInputsName)
+    .def("get_outputs_name", &ReLU_Op::getOutputsName);
 
     m.def("ReLU", &ReLU, py::arg("name") = "");
 }

python_binding/operator/pybind_Softmax.cpp

@@ -19,7 +19,9 @@ namespace py = pybind11;
 namespace Aidge {
 
 void init_Softmax(py::module& m) {
-    py::class_<Softmax_Op, std::shared_ptr<Softmax_Op>, Operator>(m, "Softmax_Op", py::multiple_inheritance());
+    py::class_<Softmax_Op, std::shared_ptr<Softmax_Op>, Operator>(m, "SoftmaxOp", py::multiple_inheritance())
+    .def("get_inputs_name", &Softmax_Op::getInputsName)
+    .def("get_outputs_name", &Softmax_Op::getOutputsName);
 
     m.def("Softmax", &Softmax, py::arg("name") = "");
 }