Add attributes_name method to get statically attributes name.

include/aidge/utils/StaticAttributes.hpp

@@ -202,6 +202,22 @@ public:
     }
 
     #ifdef PYBIND
+    /**
+     * @brief Return a set of attributes defined.
+     * This method is used to automatically retrieve attributes in the documentation.
+     * This method is a duplicate of ``getAttrsName`` but static.
+     *
+     * @return std::set<std::string>
+     */
+    static std::set<std::string> staticGetAttrsName() {
+        std::set<std::string> attrsName;
+        for (std::size_t i = 0; i < size(EnumStrings<ATTRS_ENUM>::data); ++i) {
+            attrsName.insert(EnumStrings<ATTRS_ENUM>::data[i]);
+        }
+        return attrsName;
+    }
+
+
     py::object getAttrPy(const std::string& name) const override {
         for (std::size_t i = 0; i < size(EnumStrings<ATTRS_ENUM>::data); ++i) {
             if (name == EnumStrings<ATTRS_ENUM>::data[i]) {

python_binding/operator/pybind_AvgPooling.cpp

@@ -34,7 +34,8 @@ template <DimIdx_t DIM> void declare_AvgPoolingOp(py::module &m) {
         py::arg("kernel_dims"),
         py::arg("stride_dims"))
   .def("get_inputs_name", &AvgPooling_Op<DIM>::getInputsName)
-  .def("get_outputs_name", &AvgPooling_Op<DIM>::getOutputsName);
+  .def("get_outputs_name", &AvgPooling_Op<DIM>::getOutputsName)
+  .def("attributes_name", &AvgPooling_Op<DIM>::staticGetAttrsName);
 
   m.def(("AvgPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
                                                                   const std::string& name,

python_binding/operator/pybind_BatchNorm.cpp

@@ -23,7 +23,8 @@ template <DimSize_t DIM>
 void declare_BatchNormOp(py::module& m) {
     py::class_<BatchNorm_Op<DIM>, std::shared_ptr<BatchNorm_Op<DIM>>, Attributes, OperatorTensor>(m, ("BatchNormOp" + std::to_string(DIM) + "D").c_str(), py::multiple_inheritance())
     .def("get_inputs_name", &BatchNorm_Op<DIM>::getInputsName)
-    .def("get_outputs_name", &BatchNorm_Op<DIM>::getOutputsName);
+    .def("get_outputs_name", &BatchNorm_Op<DIM>::getOutputsName)
+    .def("attributes_name", &BatchNorm_Op<DIM>::staticGetAttrsName);
 
     m.def(("BatchNorm" + std::to_string(DIM) + "D").c_str(), &BatchNorm<DIM>, py::arg("nbFeatures"), py::arg("epsilon") = 1.0e-5F, py::arg("momentum") = 0.1F, py::arg("name") = "");
 }

python_binding/operator/pybind_Concat.cpp

@@ -21,7 +21,8 @@ namespace Aidge {
 void init_Concat(py::module& m) {
     py::class_<Concat_Op, std::shared_ptr<Concat_Op>, Attributes, OperatorTensor>(m, "ConcatOp", py::multiple_inheritance())
     .def("get_inputs_name", &Concat_Op::getInputsName)
-    .def("get_outputs_name", &Concat_Op::getOutputsName);
+    .def("get_outputs_name", &Concat_Op::getOutputsName)
+    .def("attributes_name", &Concat_Op::staticGetAttrsName);
 
     m.def("Concat", &Concat, py::arg("nbIn"), py::arg("axis"), py::arg("name") = "");
 }

python_binding/operator/pybind_Conv.cpp

@@ -39,6 +39,7 @@ template <DimIdx_t DIM> void declare_ConvOp(py::module &m) {
         py::arg("dilation_dims"))
     .def("get_inputs_name", &Conv_Op<DIM>::getInputsName)
     .def("get_outputs_name", &Conv_Op<DIM>::getOutputsName)
+    .def("attributes_name", &Conv_Op<DIM>::staticGetAttrsName)
     ;
 
   m.def(("Conv" + std::to_string(DIM) + "D").c_str(), [](DimSize_t in_channels,

python_binding/operator/pybind_ConvDepthWise.cpp

@@ -38,7 +38,8 @@ template <DimIdx_t DIM> void declare_ConvDepthWiseOp(py::module &m) {
         py::arg("stride_dims"),
         py::arg("dilation_dims"))
   .def("get_inputs_name", &ConvDepthWise_Op<DIM>::getInputsName)
-  .def("get_outputs_name", &ConvDepthWise_Op<DIM>::getOutputsName);
+  .def("get_outputs_name", &ConvDepthWise_Op<DIM>::getOutputsName)
+  .def("attributes_name", &ConvDepthWise_Op<DIM>::staticGetAttrsName);
 
   m.def(("ConvDepthWise" + std::to_string(DIM) + "D").c_str(), [](const DimSize_t nb_channels,
                                                                   const std::vector<DimSize_t>& kernel_dims,

python_binding/operator/pybind_FC.cpp

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

python_binding/operator/pybind_Gather.cpp

@@ -21,7 +21,8 @@ namespace Aidge {
 void init_Gather(py::module& m) {
     py::class_<Gather_Op, std::shared_ptr<Gather_Op>, Attributes, OperatorTensor>(m, "GatherOp", py::multiple_inheritance())
     .def("get_inputs_name", &Gather_Op::getInputsName)
-    .def("get_outputs_name", &Gather_Op::getOutputsName);
+    .def("get_outputs_name", &Gather_Op::getOutputsName)
+    .def("attributes_name", &Gather_Op::staticGetAttrsName);
 
     m.def("Gather", &Gather, py::arg("axis"), py::arg("name") = "");
 }

python_binding/operator/pybind_LeakyReLU.cpp

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

python_binding/operator/pybind_Matmul.cpp

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

python_binding/operator/pybind_MaxPooling.cpp

@@ -36,7 +36,8 @@ template <DimIdx_t DIM> void declare_MaxPoolingOp(py::module &m) {
         py::arg("stride_dims"),
         py::arg("ceil_mode"))
   .def("get_inputs_name", &MaxPooling_Op<DIM>::getInputsName)
-  .def("get_outputs_name", &MaxPooling_Op<DIM>::getOutputsName);
+  .def("get_outputs_name", &MaxPooling_Op<DIM>::getOutputsName)
+  .def("attributes_name", &MaxPooling_Op<DIM>::staticGetAttrsName);
 
   m.def(("MaxPooling" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& kernel_dims,
                                                                   const std::string& name,

python_binding/operator/pybind_Pad.cpp

@@ -36,6 +36,7 @@ template <DimIdx_t DIM> void declare_PadOp(py::module &m) {
         py::arg("borderValue") = 0.0)
     .def("get_inputs_name", &Pad_Op<DIM>::getInputsName)
     .def("get_outputs_name", &Pad_Op<DIM>::getOutputsName)
+    .def("attributes_name", &Pad_Op<DIM>::staticGetAttrsName)
     ;
 
   m.def(("Pad" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& beginEndTuples,

python_binding/operator/pybind_Producer.cpp

@@ -36,7 +36,8 @@ void init_Producer(py::module &m) {
         py::multiple_inheritance())
     .def("dims", &Producer_Op::dims)
     .def("get_inputs_name", &Producer_Op::getInputsName)
-    .def("get_outputs_name", &Producer_Op::getOutputsName);
+    .def("get_outputs_name", &Producer_Op::getOutputsName)
+    .def("attributes_name", &Producer_Op<DIM>::staticGetAttrsName);
     m.def("Producer", static_cast<std::shared_ptr<Node>(*)(const std::shared_ptr<Tensor>, const std::string&, bool)>(&Producer), py::arg("tensor"), py::arg("name") = "", py::arg("constant") = false);
 
     declare_Producer<1>(m);

python_binding/operator/pybind_ReduceMean.cpp

@@ -28,6 +28,7 @@ template <DimIdx_t DIM> void declare_ReduceMeanOp(py::module &m) {
     m, ("ReduceMeanOp" + std::to_string(DIM) + "D").c_str(), py::multiple_inheritance())
     .def("get_inputs_name", &ReduceMean_Op<DIM>::getInputsName)
     .def("get_outputs_name", &ReduceMean_Op<DIM>::getOutputsName)
+    .def("attributes_name", &ReduceMean_Op<DIM>::staticGetAttrsName)
     ;
 
   m.def(("ReduceMean" + std::to_string(DIM) + "D").c_str(), [](const std::vector<int>& axes,

python_binding/operator/pybind_Softmax.cpp

@@ -21,7 +21,8 @@ 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("get_outputs_name", &Softmax_Op::getOutputsName)
+    .def("attributes_name", &Softmax_Op::staticGetAttrsName);
 
     m.def("Softmax", &Softmax, py::arg("axis"), py::arg("name") = "");
 }

python_binding/operator/pybind_Transpose.cpp

@@ -30,7 +30,8 @@ void declare_Transpose(py::module &m) {
   py::class_<Transpose_Op<DIM>, std::shared_ptr<Transpose_Op<DIM>>, Attributes, OperatorTensor>(
     m, ("TransposeOp" + std::to_string(DIM) + "D").c_str(), py::multiple_inheritance())
   .def("get_inputs_name", &Transpose_Op<DIM>::getInputsName)
-  .def("get_outputs_name", &Transpose_Op<DIM>::getOutputsName);
+  .def("get_outputs_name", &Transpose_Op<DIM>::getOutputsName)
+  .def("attributes_name", &Transpose_Op<DIM>::staticGetAttrsName);
 
   m.def(("Transpose" + std::to_string(DIM) + "D").c_str(), [](const std::vector<DimSize_t>& output_dims_order,
                                                                   const std::string& name) {

python_binding/utils/pybind_Attributes.cpp

 #include <pybind11/pybind11.h>
 #include "aidge/utils/Attributes.hpp"
 #include "aidge/utils/DynamicAttributes.hpp"
+#include "aidge/utils/StaticAttributes.hpp"
 
 namespace py = pybind11;
 namespace Aidge {