Added Type binding

python_binding/operator/pybind_Add.cpp

@@ -24,7 +24,8 @@ void declare_Add(py::module &m) {
   py::class_<Add_Op, std::shared_ptr<Add_Op>, OperatorTensor>(m, "AddOp", py::multiple_inheritance())
     .def(py::init<const IOIndex_t>(), py::arg("nb_inputs"))
     .def_static("get_inputs_name", &Add_Op::getInputsName)
-    .def_static("get_outputs_name", &Add_Op::getOutputsName);
+    .def_static("get_outputs_name", &Add_Op::getOutputsName)
+    .def_readonly_static("Type", &Add_Op::Type);
 
   declare_registrable<Add_Op>(m, "AddOp");
 

python_binding/operator/pybind_AvgPooling.cpp

@@ -45,7 +45,8 @@ template <DimIdx_t DIM> void declare_AvgPoolingOp(py::module &m) {
             py::arg("kernel_dims"),
             py::arg("stride_dims") = create_array<DimSize_t,DIM>(1))
     .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_readonly_static("Type", &AvgPooling_Op<DIM>::Type);
 
   declare_registrable<AvgPooling_Op<DIM>>(m, pyClassName);
 

python_binding/operator/pybind_BatchNorm.cpp

@@ -30,7 +30,8 @@ void declare_BatchNormOp(py::module& m) {
             py::arg("epsilon"),
             py::arg("momentum"))
         .def_static("get_inputs_name", &BatchNorm_Op<DIM>::getInputsName)
-        .def_static("get_outputs_name", &BatchNorm_Op<DIM>::getOutputsName);
+        .def_static("get_outputs_name", &BatchNorm_Op<DIM>::getOutputsName)
+        .def_readonly_static("Type", &BatchNorm_Op<DIM>::Type);
 
     declare_registrable<BatchNorm_Op<DIM>>(m, pyClassName);
 

python_binding/operator/pybind_Concat.cpp

@@ -25,7 +25,8 @@ void init_Concat(py::module& m) {
                 py::arg("nb_inputs"),
                 py::arg("axis"))
         .def_static("get_inputs_name", &Concat_Op::getInputsName)
-        .def_static("get_outputs_name", &Concat_Op::getOutputsName);
+        .def_static("get_outputs_name", &Concat_Op::getOutputsName)
+        .def_readonly_static("Type", &Concat_Op::Type);
 
     declare_registrable<Concat_Op>(m, "ConcatOp");
 

python_binding/operator/pybind_Conv.cpp

@@ -45,6 +45,7 @@ template <DimIdx_t DIM> void declare_ConvOp(py::module &m) {
         .def_static("get_outputs_name", &Conv_Op<DIM>::getOutputsName)
         .def("in_channels", &Conv_Op<DIM>::inChannels)
         .def("out_channels", &Conv_Op<DIM>::outChannels)
+        .def_readonly_static("Type", &Conv_Op<DIM>::Type)
         ;
 
   declare_registrable<Conv_Op<DIM>>(m, pyClassName);

python_binding/operator/pybind_ConvDepthWise.cpp

@@ -39,7 +39,8 @@ template <DimIdx_t DIM> void declare_ConvDepthWiseOp(py::module &m) {
         py::arg("dilation_dims"))
   .def_static("get_inputs_name", &ConvDepthWise_Op<DIM>::getInputsName)
   .def_static("get_outputs_name", &ConvDepthWise_Op<DIM>::getOutputsName)
-  .def("nb_channels", &ConvDepthWise_Op<DIM>::nbChannels);
+  .def("nb_channels", &ConvDepthWise_Op<DIM>::nbChannels)
+  .def_readonly_static("Type", &ConvDepthWise_Op<DIM>::Type);
 
   declare_registrable<ConvDepthWise_Op<DIM>>(m, pyClassName);
   m.def(("ConvDepthWise" + std::to_string(DIM) + "D").c_str(), [](const DimSize_t nb_channels,

python_binding/operator/pybind_Div.cpp

@@ -22,7 +22,8 @@ void init_Div(py::module& m) {
     py::class_<Div_Op, std::shared_ptr<Div_Op>, OperatorTensor>(m, "DivOp", py::multiple_inheritance())
         .def(py::init<>())
         .def_static("get_inputs_name", &Div_Op::getInputsName)
-        .def_static("get_outputs_name", &Div_Op::getOutputsName);
+        .def_static("get_outputs_name", &Div_Op::getOutputsName)
+        .def_readonly_static("Type", &Div_Op::Type);
     declare_registrable<Div_Op>(m, "DivOp");
     m.def("Div", &Div, py::arg("name") = "");
 }

python_binding/operator/pybind_Erf.cpp

@@ -22,7 +22,8 @@ void init_Erf(py::module& m) {
     py::class_<Erf_Op, std::shared_ptr<Erf_Op>, OperatorTensor>(m, "ErfOp", py::multiple_inheritance())
         .def(py::init<>())
         .def_static("get_inputs_name", &Erf_Op::getInputsName)
-        .def_static("get_outputs_name", &Erf_Op::getOutputsName);
+        .def_static("get_outputs_name", &Erf_Op::getOutputsName)
+        .def_readonly_static("Type", &Erf_Op::Type);
 
     declare_registrable<Erf_Op>(m, "ErfOp");
 

python_binding/operator/pybind_FC.cpp

@@ -28,6 +28,7 @@ void declare_FC(py::module &m) {
     .def(py::init<>())
     .def_static("get_inputs_name", &FC_Op::getInputsName)
     .def_static("get_outputs_name", &FC_Op::getOutputsName)
+    .def_readonly_static("Type", &FC_Op::Type)
     .def("out_channels", &FC_Op::outChannels)
     // .def_property_readonly("a", &FC_Op::get_a)
     // .def_property_readonly("a", [](const FC_Op& self) {

python_binding/operator/pybind_Gather.cpp

@@ -29,7 +29,8 @@ void init_Gather(py::module& m) {
                 py::arg("indices"),
                 py::arg("gathered_shape"))
         .def_static("get_inputs_name", &Gather_Op::getInputsName)
-        .def_static("get_outputs_name", &Gather_Op::getOutputsName);
+        .def_static("get_outputs_name", &Gather_Op::getOutputsName)
+        .def_readonly_static("Type", &Gather_Op::Type);
 
     declare_registrable<Gather_Op>(m, "GatherOp");
 

python_binding/operator/pybind_GlobalAveragePooling.cpp

@@ -25,7 +25,8 @@ void init_GlobalAveragePooling(py::module &m) {
                              py::multiple_inheritance())
       .def(py::init<>())
       .def_static("get_inputs_name", &GlobalAveragePooling_Op::getInputsName)
-      .def_static("get_outputs_name", &GlobalAveragePooling_Op::getOutputsName);
+      .def_static("get_outputs_name", &GlobalAveragePooling_Op::getOutputsName)
+      .def_readonly_static("Type", &GlobalAveragePooling_Op::Type);
 
   declare_registrable<GlobalAveragePooling_Op>(m, pyClassName);
 

python_binding/operator/pybind_GridSample.cpp

@@ -58,6 +58,7 @@ void declare_GridSampleOp(py::module &m) {
             py::arg("alogn_corners") = false)
         .def_static("get_inputs_name", &GridSample_Op::getInputsName)
         .def_static("get_outputs_name", &GridSample_Op::getOutputsName)
+        .def_readonly_static("Type", &GridSample_Op::Type)
         ;
 
   declare_registrable<GridSample_Op>(m, pyClassName);

python_binding/operator/pybind_Identity.cpp

@@ -22,7 +22,8 @@ void init_Identity(py::module& m) {
     py::class_<Identity_Op, std::shared_ptr<Identity_Op>, OperatorTensor>(m, "IdentityOp", py::multiple_inheritance())
         .def(py::init<>())
         .def_static("get_inputs_name", &Identity_Op::getInputsName)
-        .def_static("get_outputs_name", &Identity_Op::getOutputsName);
+        .def_static("get_outputs_name", &Identity_Op::getOutputsName)
+        .def_readonly_static("Type", &Identity_Op::Type);
 
     m.def("Identity", &Identity, py::arg("name") = "");
 }

python_binding/operator/pybind_LeakyReLU.cpp

@@ -22,7 +22,8 @@ void init_LeakyReLU(py::module& m) {
     py::class_<LeakyReLU_Op, std::shared_ptr<LeakyReLU_Op>, OperatorTensor>(m, "LeakyReLUOp", py::multiple_inheritance())
         .def(py::init<float>(), py::arg("negative_slope"))
         .def_static("get_inputs_name", &LeakyReLU_Op::getInputsName)
-        .def_static("get_outputs_name", &LeakyReLU_Op::getOutputsName);
+        .def_static("get_outputs_name", &LeakyReLU_Op::getOutputsName)
+        .def_readonly_static("Type", &LeakyReLU_Op::Type);
     declare_registrable<LeakyReLU_Op>(m, "LeakyReLUOp");
     m.def("LeakyReLU", &LeakyReLU, py::arg("negative_slope") = 0.0f, py::arg("name") = "");
 }

python_binding/operator/pybind_Ln.cpp

@@ -22,7 +22,8 @@ void init_Ln(py::module& m) {
     py::class_<Ln_Op, std::shared_ptr<Ln_Op>, OperatorTensor>(m, "LnOp", py::multiple_inheritance())
     .def(py::init<>())
     .def_static("get_inputs_name", &Ln_Op::getInputsName)
-    .def_static("get_outputs_name", &Ln_Op::getOutputsName);
+    .def_static("get_outputs_name", &Ln_Op::getOutputsName)
+    .def_readonly_static("Type", &Ln_Op::Type);
 
     m.def("Ln", &Ln, py::arg("name") = "");
 }

python_binding/operator/pybind_Matmul.cpp

@@ -24,7 +24,8 @@ void init_MatMul(py::module &m) {
   py::class_<MatMul_Op, std::shared_ptr<MatMul_Op>, OperatorTensor>(m, "MatMulOp", py::multiple_inheritance())
     .def(py::init<>())
     .def_static("get_inputs_name", &MatMul_Op::getInputsName)
-    .def_static("get_outputs_name", &MatMul_Op::getOutputsName);
+    .def_static("get_outputs_name", &MatMul_Op::getOutputsName)
+    .def_readonly_static("Type", &MatMul_Op::Type);
   declare_registrable<MatMul_Op>(m, "MatMulOp");
   m.def("MatMul", &MatMul, py::arg("name") = "");
 }

python_binding/operator/pybind_MaxPooling.cpp

@@ -37,7 +37,8 @@ template <DimIdx_t DIM> void declare_MaxPoolingOp(py::module &m) {
         py::arg("stride_dims"),
         py::arg("ceil_mode"))
   .def_static("get_inputs_name", &MaxPooling_Op<DIM>::getInputsName)
-  .def_static("get_outputs_name", &MaxPooling_Op<DIM>::getOutputsName);
+  .def_static("get_outputs_name", &MaxPooling_Op<DIM>::getOutputsName)
+  .def_readonly_static("Type", &MaxPooling_Op<DIM>::Type);
   declare_registrable<MaxPooling_Op<DIM>>(m, pyClassName);
   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_Mul.cpp

@@ -22,7 +22,8 @@ void init_Mul(py::module& m) {
     py::class_<Mul_Op, std::shared_ptr<Mul_Op>, OperatorTensor>(m, "MulOp", py::multiple_inheritance())
     .def(py::init<>())
     .def_static("get_inputs_name", &Mul_Op::getInputsName)
-    .def_static("get_outputs_name", &Mul_Op::getOutputsName);
+    .def_static("get_outputs_name", &Mul_Op::getOutputsName)
+    .def_readonly_static("Type", &Mul_Op::Type);
     declare_registrable<Mul_Op>(m, "MulOp");
     m.def("Mul", &Mul, py::arg("name") = "");
 }

python_binding/operator/pybind_Pad.cpp

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

python_binding/operator/pybind_Pop.cpp

@@ -22,7 +22,8 @@ void init_Pop(py::module& m) {
     py::class_<Pop_Op, std::shared_ptr<Pop_Op>, OperatorTensor>(m, "PopOp", py::multiple_inheritance())
     .def(py::init<>())
     .def_static("get_inputs_name", &Pop_Op::getInputsName)
-    .def_static("get_outputs_name", &Pop_Op::getOutputsName);
+    .def_static("get_outputs_name", &Pop_Op::getOutputsName)
+    .def_readonly_static("Type", &Pop_Op::Type);
 
     m.def("Pop", &Pop, py::arg("name") = "");
 }