bound static method with 'def_static' instead of 'def' in operators python binding

python_binding/operator/pybind_ReduceMean.cpp

@@ -28,9 +28,9 @@ void declare_ReduceMeanOp(py::module &m) {
   const std::string pyClassName("ReduceMeanOp");
   py::class_<ReduceMean_Op, std::shared_ptr<ReduceMean_Op>, Attributes, OperatorTensor>(
     m, pyClassName.c_str(), py::multiple_inheritance())
-    .def("get_inputs_name", &ReduceMean_Op::getInputsName)
-    .def("get_outputs_name", &ReduceMean_Op::getOutputsName)
-    .def("attributes_name", &ReduceMean_Op::staticGetAttrsName)
+    .def_static("get_inputs_name", &ReduceMean_Op::getInputsName)
+    .def_static("get_outputs_name", &ReduceMean_Op::getOutputsName)
+    .def_static("attributes_name", &ReduceMean_Op::staticGetAttrsName)
     ;
   declare_registrable<ReduceMean_Op>(m, pyClassName);
 

python_binding/operator/pybind_Reshape.cpp

@@ -20,8 +20,8 @@ namespace Aidge {
 
 void init_Reshape(py::module& m) {
     py::class_<Reshape_Op, std::shared_ptr<Reshape_Op>, Attributes, OperatorTensor>(m, "ReshapeOp", py::multiple_inheritance())
-    .def("get_inputs_name", &Reshape_Op::getInputsName)
-    .def("get_outputs_name", &Reshape_Op::getOutputsName);
+    .def_static("get_inputs_name", &Reshape_Op::getInputsName)
+    .def_static("get_outputs_name", &Reshape_Op::getOutputsName);
     declare_registrable<Reshape_Op>(m, "ReshapeOp");
     m.def("Reshape", &Reshape, py::arg("shape") = std::vector<std::int64_t>(), py::arg("name") = "");
 }

python_binding/operator/pybind_Scaling.cpp

@@ -19,12 +19,12 @@ namespace py = pybind11;
 
 namespace Aidge {
 
-void init_Scaling(py::module& m) 
+void init_Scaling(py::module& m)
 {
     py::class_<Scaling_Op, std::shared_ptr<Scaling_Op>, Attributes, OperatorTensor>(m, "ScalingOp", py::multiple_inheritance())
-    .def("get_inputs_name", &Scaling_Op::getInputsName)
-    .def("get_outputs_name", &Scaling_Op::getOutputsName)
-    .def("attributes_name", &Scaling_Op::staticGetAttrsName);
+    .def_static("get_inputs_name", &Scaling_Op::getInputsName)
+    .def_static("get_outputs_name", &Scaling_Op::getOutputsName)
+    .def_static("attributes_name", &Scaling_Op::staticGetAttrsName);
     declare_registrable<Scaling_Op>(m, "ScalingOp");
     m.def("Scaling", &Scaling, py::arg("scaling_factor") = 1.0f, py::arg("nb_bits") = 8, py::arg("is_output_unsigned") = true, py::arg("name") = "");
 }

python_binding/operator/pybind_Sigmoid.cpp

@@ -20,8 +20,8 @@ namespace Aidge {
 
 void init_Sigmoid(py::module& m) {
     py::class_<Sigmoid_Op, std::shared_ptr<Sigmoid_Op>, OperatorTensor>(m, "SigmoidOp", py::multiple_inheritance())
-    .def("get_inputs_name", &Sigmoid_Op::getInputsName)
-    .def("get_outputs_name", &Sigmoid_Op::getOutputsName);
+    .def_static("get_inputs_name", &Sigmoid_Op::getInputsName)
+    .def_static("get_outputs_name", &Sigmoid_Op::getOutputsName);
 
     m.def("Sigmoid", &Sigmoid, py::arg("name") = "");
 }

python_binding/operator/pybind_Slice.cpp

@@ -21,8 +21,8 @@ namespace Aidge {
 
 void init_Slice(py::module& m) {
     py::class_<Slice_Op, std::shared_ptr<Slice_Op>, OperatorTensor>(m, "SliceOp", py::multiple_inheritance())
-    .def("get_inputs_name", &Slice_Op::getInputsName)
-    .def("get_outputs_name", &Slice_Op::getOutputsName);
+    .def_static("get_inputs_name", &Slice_Op::getInputsName)
+    .def_static("get_outputs_name", &Slice_Op::getOutputsName);
     declare_registrable<Slice_Op>(m, "SliceOp");
 
     m.def("Slice",

python_binding/operator/pybind_Softmax.cpp

@@ -21,9 +21,9 @@ namespace Aidge {
 
 void init_Softmax(py::module& m) {
     py::class_<Softmax_Op, std::shared_ptr<Softmax_Op>, Attributes, OperatorTensor>(m, "SoftmaxOp", py::multiple_inheritance())
-    .def("get_inputs_name", &Softmax_Op::getInputsName)
-    .def("get_outputs_name", &Softmax_Op::getOutputsName)
-    .def("attributes_name", &Softmax_Op::staticGetAttrsName);
+    .def_static("get_inputs_name", &Softmax_Op::getInputsName)
+    .def_static("get_outputs_name", &Softmax_Op::getOutputsName)
+    .def_static("attributes_name", &Softmax_Op::staticGetAttrsName);
     declare_registrable<Softmax_Op>(m, "SoftmaxOp");
     m.def("Softmax", &Softmax, py::arg("axis"), py::arg("name") = "");
 }

python_binding/operator/pybind_Sqrt.cpp

@@ -20,8 +20,8 @@ namespace Aidge {
 
 void init_Sqrt(py::module& m) {
     py::class_<Sqrt_Op, std::shared_ptr<Sqrt_Op>, OperatorTensor>(m, "SqrtOp", py::multiple_inheritance())
-    .def("get_inputs_name", &Sqrt_Op::getInputsName)
-    .def("get_outputs_name", &Sqrt_Op::getOutputsName);
+    .def_static("get_inputs_name", &Sqrt_Op::getInputsName)
+    .def_static("get_outputs_name", &Sqrt_Op::getOutputsName);
     declare_registrable<Sqrt_Op>(m, "SqrtOp");
     m.def("Sqrt", &Sqrt, py::arg("name") = "");
 }

python_binding/operator/pybind_Sub.cpp

@@ -20,8 +20,8 @@ namespace Aidge {
 
 void init_Sub(py::module& m) {
     py::class_<Sub_Op, std::shared_ptr<Sub_Op>, OperatorTensor>(m, "SubOp", py::multiple_inheritance())
-    .def("get_inputs_name", &Sub_Op::getInputsName)
-    .def("get_outputs_name", &Sub_Op::getOutputsName);
+    .def_static("get_inputs_name", &Sub_Op::getInputsName)
+    .def_static("get_outputs_name", &Sub_Op::getOutputsName);
     declare_registrable<Sub_Op>(m, "SubOp");
     m.def("Sub", &Sub, py::arg("name") = "");
 }

python_binding/operator/pybind_Tanh.cpp

@@ -20,8 +20,8 @@ namespace Aidge {
 
 void init_Tanh(py::module& m) {
     py::class_<Tanh_Op, std::shared_ptr<Tanh_Op>, OperatorTensor>(m, "TanhOp", py::multiple_inheritance())
-    .def("get_inputs_name", &Tanh_Op::getInputsName)
-    .def("get_outputs_name", &Tanh_Op::getOutputsName);
+    .def_static("get_inputs_name", &Tanh_Op::getInputsName)
+    .def_static("get_outputs_name", &Tanh_Op::getOutputsName);
 
     m.def("Tanh", &Tanh, py::arg("name") = "");
 }

python_binding/operator/pybind_Transpose.cpp

@@ -29,9 +29,9 @@ void declare_Transpose(py::module &m) {
   const std::string pyClassName("TransposeOp");
   py::class_<Transpose_Op, std::shared_ptr<Transpose_Op>, Attributes, OperatorTensor>(
     m, "TransposeOp", py::multiple_inheritance())
-  .def("get_inputs_name", &Transpose_Op::getInputsName)
-  .def("get_outputs_name", &Transpose_Op::getOutputsName)
-  .def("attributes_name", &Transpose_Op::staticGetAttrsName);
+  .def_static("get_inputs_name", &Transpose_Op::getInputsName)
+  .def_static("get_outputs_name", &Transpose_Op::getOutputsName)
+  .def_static("attributes_name", &Transpose_Op::staticGetAttrsName);
   declare_registrable<Transpose_Op>(m, pyClassName);
   m.def("Transpose", &Transpose, py::arg("output_dims_order"), py::arg("name") = "");
 }