Correct logic for Node's parents/children association with inputs/outputs in aidge_core/show_graphview.py.

Context

This MR corrects an identified problem within the algorithm allowing to link a Node's parents (or children) nodes to its respective inputs (or outputs) in file aidge_core/show_graphview.py.

In short, only the dimensions of tensors were verified to do the matching, which caused a problem when, for example, multiple Node's inputs (or outputs) had the same dimensions.

Also, it corrects a few errors with the automatic creation of the generated files' paths.

Modified files

• python_binding/graph/pybind_Node.cpp , added the python binding for the method "get_ordered_children()";
• aidge_core/show_graphview.py, corrected logic used to link parents/children to inputs/outputs of a Node and management of paths.

Detailed major modifications

Inside the _create_dict method, employ the aidge_core.Node.outputs() method to retrieve the children of the Node's parents and the associated input index connected to each child. Similarly, use aidge_core.Node.inputs() to retrieve the Node's list of children and outputs.

include/aidge/operator/Transpose.hpp

@@ -25,6 +25,11 @@
 #include "aidge/utils/Types.h"
 
 namespace Aidge {
+/**
+ * @brief implementation of the operator Transpose.
+ * @note Since this operator implementation is agnostic to the backend it is
+ * located here instead of in aidge_backend.
+ */
 class TransposeImpl : public OperatorImpl {
 public:
     TransposeImpl(const Operator& op, const std::string& backend = "")
@@ -33,8 +38,22 @@ public:
     void forward() override;
 };
 
-enum class TransposeAttr { OutputDimsOrder };
+enum class TransposeAttr {
+  /**
+   * @brief order of the ouput dims from the input dims. If left empty,
+   * the dimensions of input will be reversed.
+   */
+    OutputDimsOrder
+};
 
+/**
+ * @brief This operator has as purpose to transpose the axes of a given tensor.
+ * input#0 : Tensor to transpose
+ * @example Calling transpose() on a tensor of dimensions [1, 2, 3] with OutputDimsOrder=(1,0,2) result
+ * in a tensor of dim [2, 1, 3].
+ * @example Calling transpose() on a tensor of dimensions [1,2,3,4] with an empty OutputDimsOrder vector
+ * will result in a tensor of dim [4,3,2,1].
+ */
 class Transpose_Op : public OperatorTensor,
                 public Registrable<Transpose_Op, std::string, std::function<std::shared_ptr<OperatorImpl>(const Transpose_Op&)>> {
 
@@ -50,6 +69,10 @@ private:
 public:
     Transpose_Op() = delete;
 
+  /**
+   * @brief constructor for Transpose op
+   * @param[in] outputDimsOrder axes permutation order. By default axes are reversed.
+   */
     Transpose_Op(const std::vector<DimSize_t> &outputDimsOrder);
 
     /**
@@ -70,6 +93,9 @@ public:
     std::set<std::string> getAvailableBackends() const override;
 
     inline std::shared_ptr<Attributes> attributes() const override { return mAttributes; }
+    /**
+     * @brief axes new order, if left empty, axes will be reversed.
+     */
     inline std::vector<DimSize_t>& outputDimsOrder() const noexcept { return mAttributes -> getAttr<TransposeAttr::OutputDimsOrder>(); }
 
     static const std::vector<std::string> getInputsName(){
@@ -80,8 +106,8 @@ public:
     }
 };
 
-std::shared_ptr<Node> Transpose(const std::vector<DimSize_t> &outputDimsOrder,
-                                           const std::string& name = "");
+std::shared_ptr<Node> Transpose(const std::vector<DimSize_t> &outputDimsOrder = {},
+                                const std::string& name = "");
 }  // namespace Aidge
 
 namespace {