diff --git a/CHANGELOG b/CHANGELOG
index 82e90519cc6546e5fa2c2dfa76bc32893d7cad64..68018f081f0bd0133e6bd51067043c63f6c6720a 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,3 +1,5 @@
+# Version 0.4.1 (January 31, 2025)
+
 # Version 0.1.0 (January 23, 2024)
 
 Initial release
diff --git a/aidge_onnx/__init__.py b/aidge_onnx/__init__.py
index 1665ea468fa2e141d63705da4ace5140371ec291..b67537e883364ff7082998697e06fb6bb0461c54 100644
--- a/aidge_onnx/__init__.py
+++ b/aidge_onnx/__init__.py
@@ -7,11 +7,10 @@ http://www.eclipse.org/legal/epl-2.0.
 
 SPDX-License-Identifier: EPL-2.0
 """
+from . import utils
+from . import dtype_converter
 from . import node_import
-from . import node_export
 from .onnx_import import *
+from . import node_export
 from .onnx_export import *
 from .onnx_test import *
-from .utils import _AIDGE_DOMAIN
-
-from ._version import *
diff --git a/aidge_onnx/node_export/aidge_converters/add.py b/aidge_onnx/node_export/aidge_converters/add.py
index 70087445e433ef8039ac44be72478ab914c3154d..1cb3c37083d7856ba304f13c8a67cb4b00be4aa3 100644
--- a/aidge_onnx/node_export/aidge_converters/add.py
+++ b/aidge_onnx/node_export/aidge_converters/add.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
@@ -22,9 +21,6 @@ def export_add(
     opset:int = None,
     verbose: bool = False,
     **kwargs) -> List[helper.NodeProto]:
-
-    aidge_operator = aidge_node.get_operator()
-
     onnx_node = helper.make_node(
         name=aidge_node.name(),
         op_type="Add",
diff --git a/aidge_onnx/node_export/aidge_converters/and.py b/aidge_onnx/node_export/aidge_converters/and.py
index b849ee19b67d27cbe8625d820e49d0e8f749a9ae..4d08d85889b60fa3282b38675cb392d2d0d4bda8 100644
--- a/aidge_onnx/node_export/aidge_converters/and.py
+++ b/aidge_onnx/node_export/aidge_converters/and.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
@@ -22,9 +21,6 @@ def export_and(
     opset:int = None,
     verbose: bool = False,
     **kwargs) -> List[helper.NodeProto]:
-
-    aidge_operator = aidge_node.get_operator()
-
     onnx_node = helper.make_node(
         name=aidge_node.name(),
         op_type="And",
diff --git a/aidge_onnx/node_export/aidge_converters/argmax.py b/aidge_onnx/node_export/aidge_converters/argmax.py
index d05f3e4fa086f94a14f13ab162200f77d63c516a..135a0fe49d6ef0814085fad5cb7ad8e2616e819f 100644
--- a/aidge_onnx/node_export/aidge_converters/argmax.py
+++ b/aidge_onnx/node_export/aidge_converters/argmax.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/average_pool.py b/aidge_onnx/node_export/aidge_converters/average_pool.py
index bfca1dd3d2c90adfeb6376e3f95734d3b8d78026..34de16841f851562d8ed79b17facc2ca54c53d0b 100644
--- a/aidge_onnx/node_export/aidge_converters/average_pool.py
+++ b/aidge_onnx/node_export/aidge_converters/average_pool.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/batchnorm.py b/aidge_onnx/node_export/aidge_converters/batchnorm.py
index 30421002e74955e0250612a7a17460f742369e04..c9af2d18bed71c215d6ab3da0d850fb368b43734 100644
--- a/aidge_onnx/node_export/aidge_converters/batchnorm.py
+++ b/aidge_onnx/node_export/aidge_converters/batchnorm.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/bitshift.py b/aidge_onnx/node_export/aidge_converters/bitshift.py
index 9ee7c3d89944676aca3bb7eb4c3e13a0af1ed5cb..d6961bb5fe54b008c1433da1881489d41479efed 100644
--- a/aidge_onnx/node_export/aidge_converters/bitshift.py
+++ b/aidge_onnx/node_export/aidge_converters/bitshift.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 
diff --git a/aidge_onnx/node_export/aidge_converters/clip.py b/aidge_onnx/node_export/aidge_converters/clip.py
index f0f73d6db4094c6fad4599ead0f036c9032c8385..c6c3e0499a43d3fac159b03f0794f980eaedb1f1 100644
--- a/aidge_onnx/node_export/aidge_converters/clip.py
+++ b/aidge_onnx/node_export/aidge_converters/clip.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 
@@ -17,11 +16,10 @@ from aidge_onnx.node_export import auto_register_export
 def export_clip(
     aidge_node: aidge_core.Node,
     node_inputs_name,
-    node_outputs_name, 
+    node_outputs_name,
     opset:int = None,
     verbose: bool = False,
     **kwargs) -> None:
-    aidge_operator = aidge_node.get_operator()
     onnx_node = helper.make_node(
         name=aidge_node.name(),
         op_type="Clip",
diff --git a/aidge_onnx/node_export/aidge_converters/concat.py b/aidge_onnx/node_export/aidge_converters/concat.py
index 64871c781fc65588fc70ab4a76497cce43e7ae71..d9860b13d29590dfae74c4a9b37ccf13b5fdf125 100644
--- a/aidge_onnx/node_export/aidge_converters/concat.py
+++ b/aidge_onnx/node_export/aidge_converters/concat.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/constantofshape.py b/aidge_onnx/node_export/aidge_converters/constantofshape.py
index dc65c80f08dc30141ea253b04adc274da2fae875..b763ba76aa4a576b34c7b189073e4a096c675636 100644
--- a/aidge_onnx/node_export/aidge_converters/constantofshape.py
+++ b/aidge_onnx/node_export/aidge_converters/constantofshape.py
@@ -11,7 +11,6 @@ SPDX-License-Identifier: EPL-2.0
 from typing import List
 
 import onnx
-import numpy as np
 from onnx import helper
 
 import aidge_core
diff --git a/aidge_onnx/node_export/aidge_converters/conv.py b/aidge_onnx/node_export/aidge_converters/conv.py
index 3ac533c338c5d0569fa66159035bebb1d2d1a843..e7e966a2e39226fd75290ee206d0d9eb2da3afb3 100644
--- a/aidge_onnx/node_export/aidge_converters/conv.py
+++ b/aidge_onnx/node_export/aidge_converters/conv.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/erf.py b/aidge_onnx/node_export/aidge_converters/erf.py
index 63f90f8ef1ecbf86c249d33027963c09336cc582..7ce443b7b1a266167e05d323228d625b92ccc764 100644
--- a/aidge_onnx/node_export/aidge_converters/erf.py
+++ b/aidge_onnx/node_export/aidge_converters/erf.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/fc.py b/aidge_onnx/node_export/aidge_converters/fc.py
index 24fc5b6bfbba53555ec126edcdc03cb92a176c3c..768bf99e0ddb54dc3427de268820ef1327208f28 100644
--- a/aidge_onnx/node_export/aidge_converters/fc.py
+++ b/aidge_onnx/node_export/aidge_converters/fc.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/flatten.py b/aidge_onnx/node_export/aidge_converters/flatten.py
index 6d4a4f444cbe0bc0590d351369410883b243a58f..0edfb4d8d6b7e2a394649ae41abb87818d3ee51e 100644
--- a/aidge_onnx/node_export/aidge_converters/flatten.py
+++ b/aidge_onnx/node_export/aidge_converters/flatten.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/gather.py b/aidge_onnx/node_export/aidge_converters/gather.py
index 26ee3190c0b902c7d21c87406aa213c4a1d7d243..30bd3a603fd408c30934b37505b524b4bc5859d9 100644
--- a/aidge_onnx/node_export/aidge_converters/gather.py
+++ b/aidge_onnx/node_export/aidge_converters/gather.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/globalaveragepooling.py b/aidge_onnx/node_export/aidge_converters/globalaveragepooling.py
index 3e7bec0f811075285bfaa697ede1062fc376f83f..2ea96a47fcd3986ddf0b41851d02c71e9a2ccd40 100644
--- a/aidge_onnx/node_export/aidge_converters/globalaveragepooling.py
+++ b/aidge_onnx/node_export/aidge_converters/globalaveragepooling.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 
diff --git a/aidge_onnx/node_export/aidge_converters/identity.py b/aidge_onnx/node_export/aidge_converters/identity.py
index 5dce4c8092d01af5c83c59c6211cd490a7b0f367..c4fa633924956595f88ee9e3656c42e72b358e9d 100644
--- a/aidge_onnx/node_export/aidge_converters/identity.py
+++ b/aidge_onnx/node_export/aidge_converters/identity.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/maxpooling.py b/aidge_onnx/node_export/aidge_converters/maxpooling.py
index 77cd1045b976908d9aa17c27872d3e93f5e1d3b7..ddf0dd0d0b5041612521a3625c7085278cf1195c 100644
--- a/aidge_onnx/node_export/aidge_converters/maxpooling.py
+++ b/aidge_onnx/node_export/aidge_converters/maxpooling.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/mul.py b/aidge_onnx/node_export/aidge_converters/mul.py
index db97d97538311acfdf09c2c946a0893d6f772997..fddbd5f11780b43fff1cf9bb5116b21875cb9f91 100644
--- a/aidge_onnx/node_export/aidge_converters/mul.py
+++ b/aidge_onnx/node_export/aidge_converters/mul.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
@@ -23,8 +22,6 @@ def export_mul(
     verbose: bool = False,
     **kwargs) -> List[helper.NodeProto]:
 
-    aidge_operator = aidge_node.get_operator()
-
     onnx_node = helper.make_node(
         name=aidge_node.name(),
         op_type="Mul",
diff --git a/aidge_onnx/node_export/aidge_converters/pad.py b/aidge_onnx/node_export/aidge_converters/pad.py
index 686e1f0ae22494c7f8be8cd840b1b075f2b34523..9b97086a98b8797da00d888baae0a8272f7ef462 100644
--- a/aidge_onnx/node_export/aidge_converters/pad.py
+++ b/aidge_onnx/node_export/aidge_converters/pad.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper, TensorProto
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/padded_avgpooling.py b/aidge_onnx/node_export/aidge_converters/padded_avgpooling.py
index 7b4df4bdd2411772a413636ec0d1c8c69f36981c..0c619f614c74106a6094bf06fddd11ebd0ad1a48 100644
--- a/aidge_onnx/node_export/aidge_converters/padded_avgpooling.py
+++ b/aidge_onnx/node_export/aidge_converters/padded_avgpooling.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/padded_conv.py b/aidge_onnx/node_export/aidge_converters/padded_conv.py
index 102532f9333b37d14c13aee19a84e78c21242b91..378298879286cc3b3a3a7d28722a21e642061892 100644
--- a/aidge_onnx/node_export/aidge_converters/padded_conv.py
+++ b/aidge_onnx/node_export/aidge_converters/padded_conv.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/padded_convdw.py b/aidge_onnx/node_export/aidge_converters/padded_convdw.py
index f3fee28af9526f70542d67b6b52032070a7a6292..e9b589a89a449488df32b12817c5d60bc95371b9 100644
--- a/aidge_onnx/node_export/aidge_converters/padded_convdw.py
+++ b/aidge_onnx/node_export/aidge_converters/padded_convdw.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
@@ -26,11 +25,9 @@ def export_padded_conv(
     aidge_operator = aidge_node.get_operator()
     micro_graph = aidge_operator.get_micro_graph()
     conv_op, pad_op = None, None
-    conv_node = None
     for node in micro_graph.get_nodes():
         if node.type() == "ConvDepthWise1D" or node.type() == "ConvDepthWise2D" or node.type() == "ConvDepthWise3D":
             conv_op = node.get_operator()
-            conv_node = node
         elif node.type() == "Pad1D" or node.type() == "Pad2D" or node.type() == "Pad3D":
             pad_op = node.get_operator()
         else:
diff --git a/aidge_onnx/node_export/aidge_converters/padded_maxpooling.py b/aidge_onnx/node_export/aidge_converters/padded_maxpooling.py
index 616de3bf57a6eb681ed12352f15630fb5bd40b28..f875d7d0053b4c6d3676bd8d8d6e5297e3400553 100644
--- a/aidge_onnx/node_export/aidge_converters/padded_maxpooling.py
+++ b/aidge_onnx/node_export/aidge_converters/padded_maxpooling.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/producer.py b/aidge_onnx/node_export/aidge_converters/producer.py
index 11965143da0b16fd16914c80ac1b3d034459af2e..edd605d254d6c3157fff537660fae27730919595 100644
--- a/aidge_onnx/node_export/aidge_converters/producer.py
+++ b/aidge_onnx/node_export/aidge_converters/producer.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 import numpy as np
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/reducemean.py b/aidge_onnx/node_export/aidge_converters/reducemean.py
index d3ce441da03105487c3d90a0ac7e257ed1bd7564..f3bc9f6d3e1978a272bf58ebe190178704b25733 100644
--- a/aidge_onnx/node_export/aidge_converters/reducemean.py
+++ b/aidge_onnx/node_export/aidge_converters/reducemean.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/reducesum.py b/aidge_onnx/node_export/aidge_converters/reducesum.py
index 6e2307b31e72c062dfc9b6a690611d95160f040d..24b61e2c74ad3678daba3b4455fbc4f06b9e5482 100644
--- a/aidge_onnx/node_export/aidge_converters/reducesum.py
+++ b/aidge_onnx/node_export/aidge_converters/reducesum.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/relu.py b/aidge_onnx/node_export/aidge_converters/relu.py
index c80c522c69b2a3341986e83a9360b75909ffb42b..987031b5ebc336b8de4f573f35f3d4e684086070 100644
--- a/aidge_onnx/node_export/aidge_converters/relu.py
+++ b/aidge_onnx/node_export/aidge_converters/relu.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/reshape.py b/aidge_onnx/node_export/aidge_converters/reshape.py
index 178652c852ae67cc3788586075c4e1e793cace6e..1aba708140b76fd3a373eb5b9418ef56b371a9a8 100644
--- a/aidge_onnx/node_export/aidge_converters/reshape.py
+++ b/aidge_onnx/node_export/aidge_converters/reshape.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/round.py b/aidge_onnx/node_export/aidge_converters/round.py
index d0a9a4ec055e84f8774a1bef9aac2972ed86dcc0..c9392903105110da08331aceafeaa815b5850675 100644
--- a/aidge_onnx/node_export/aidge_converters/round.py
+++ b/aidge_onnx/node_export/aidge_converters/round.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
@@ -23,8 +22,6 @@ def export_Round(
     verbose: bool = False,
     **kwargs) -> List[helper.NodeProto]:
 
-    aidge_operator = aidge_node.get_operator()
-
     onnx_node = helper.make_node(
         name=aidge_node.name(),
         op_type="Round",
diff --git a/aidge_onnx/node_export/aidge_converters/shape.py b/aidge_onnx/node_export/aidge_converters/shape.py
index 50c2cb3cdd62214dd02cc860154a03a37240cd7b..f45e56765f8610c276d20307d204c785c4b2294e 100644
--- a/aidge_onnx/node_export/aidge_converters/shape.py
+++ b/aidge_onnx/node_export/aidge_converters/shape.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/slice.py b/aidge_onnx/node_export/aidge_converters/slice.py
index 3c37c953f20ef2ec15b915e1707cfe8d1e204872..1b1faac90b70320cd5a611ce231bb7899793d8c2 100644
--- a/aidge_onnx/node_export/aidge_converters/slice.py
+++ b/aidge_onnx/node_export/aidge_converters/slice.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/softmax.py b/aidge_onnx/node_export/aidge_converters/softmax.py
index 9340acdac6c4f8351e141b3cc5d1b4c2eda61f1b..33ecc7c317ff5700acd150933563b7696ab19529 100644
--- a/aidge_onnx/node_export/aidge_converters/softmax.py
+++ b/aidge_onnx/node_export/aidge_converters/softmax.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/split.py b/aidge_onnx/node_export/aidge_converters/split.py
index 8865a51871dc545f30ddd86e82c5a16f296eff7e..2199be1eb73f2ecb98300ef20309ade3750987df 100644
--- a/aidge_onnx/node_export/aidge_converters/split.py
+++ b/aidge_onnx/node_export/aidge_converters/split.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/squeeze.py b/aidge_onnx/node_export/aidge_converters/squeeze.py
index 80588204a9063c4437b5a766d16ba544754c6856..8c788179adfaba66291869f711793a620f519d90 100644
--- a/aidge_onnx/node_export/aidge_converters/squeeze.py
+++ b/aidge_onnx/node_export/aidge_converters/squeeze.py
@@ -8,7 +8,6 @@ http://www.eclipse.org/legal/epl-2.0.
 SPDX-License-Identifier: EPL-2.0
 """
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/sub.py b/aidge_onnx/node_export/aidge_converters/sub.py
index 5bfaf12efea89435010b8bd562a6bae3df7aec86..78d287a26fdef140e87e07b9bf6b0e36e5911bf6 100644
--- a/aidge_onnx/node_export/aidge_converters/sub.py
+++ b/aidge_onnx/node_export/aidge_converters/sub.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
@@ -23,8 +22,6 @@ def export_sub(
     verbose: bool = False,
     **kwargs) -> List[helper.NodeProto]:
 
-    aidge_operator = aidge_node.get_operator()
-
     onnx_node = helper.make_node(
         name=aidge_node.name(),
         op_type="Sub",
diff --git a/aidge_onnx/node_export/aidge_converters/transpose.py b/aidge_onnx/node_export/aidge_converters/transpose.py
index 14c2285eb7e47e09af8999f44ca98a53fdcc36bc..bb0c8fa2443e1a179cb3644abd781d175410ffd6 100644
--- a/aidge_onnx/node_export/aidge_converters/transpose.py
+++ b/aidge_onnx/node_export/aidge_converters/transpose.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
diff --git a/aidge_onnx/node_export/aidge_converters/unsqueeze.py b/aidge_onnx/node_export/aidge_converters/unsqueeze.py
index 7e07455d7a8311f84f0676345b1526f46077337f..8117727ee4bd69e1a3c3f2d085389e78c30b74fb 100644
--- a/aidge_onnx/node_export/aidge_converters/unsqueeze.py
+++ b/aidge_onnx/node_export/aidge_converters/unsqueeze.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 import aidge_core
-import onnx
 from onnx import helper
 from aidge_onnx.node_export import auto_register_export
 from typing import List
@@ -36,7 +35,7 @@ def export_unsqueeze(
                 "axes",
                 aidge_node.get_operator().axes()
         ))
-    
+
 
     return [onnx_node]
 
diff --git a/aidge_onnx/node_import/generic.py b/aidge_onnx/node_import/generic.py
index 37b335a00f8464d09d3ac5d4ddac5101cd7015c8..b013c10fc491181216430ecc1cc7f726eb2493fa 100644
--- a/aidge_onnx/node_import/generic.py
+++ b/aidge_onnx/node_import/generic.py
@@ -11,6 +11,7 @@ from typing import List, Tuple
 
 import onnx
 import aidge_core
+from aidge_core import Log
 
 def import_generic(onnx_node: onnx.NodeProto, input_nodes: List[Tuple[aidge_core.Node, int]], opset = None) -> aidge_core.Node:
     """
@@ -30,7 +31,8 @@ def import_generic(onnx_node: onnx.NodeProto, input_nodes: List[Tuple[aidge_core
 
     # TODO : Add verbose parameter somewhere to avoid those logs ...
     # TODO : Add a toString method to genericOperator
-    print(f"- {node_name} ({onnx_node.op_type} | GenericOperator)")
+    message = f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m] as a GenericOperator.\n"
     for param_name in operator.attr.dict().keys():
-        print(f"\t- {param_name} : {operator.attr.get_attr(param_name)}")
+        message += f"\t* {param_name} : {operator.attr.get_attr(param_name)}\n"
+    Log.notice(message)
     return generic_node
diff --git a/aidge_onnx/node_import/onnx_converters/add.py b/aidge_onnx/node_import/onnx_converters/add.py
index 680e08c114ecb2bfb5286b67935a8d72be9431f5..e04664908af71745c6e6fe09716949bd5eeaa909 100644
--- a/aidge_onnx/node_import/onnx_converters/add.py
+++ b/aidge_onnx/node_import/onnx_converters/add.py
@@ -53,5 +53,5 @@ def import_add(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node,
         return None
 
     my_node = aidge_core.Node(aidge_core.AddOp(), name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/and.py b/aidge_onnx/node_import/onnx_converters/and.py
index 0b291e7918745958b188862fa2f8ffd026cb42b3..004a5e1b8751529367c188bfe1365b44af90eb52 100644
--- a/aidge_onnx/node_import/onnx_converters/and.py
+++ b/aidge_onnx/node_import/onnx_converters/and.py
@@ -8,12 +8,9 @@ http://www.eclipse.org/legal/epl-2.0.
 SPDX-License-Identifier: EPL-2.0
 """
 from typing import List, Tuple
-import numpy as np
-
 import aidge_core
 import onnx
 from aidge_onnx.node_import import auto_register_import
-from aidge_onnx.utils import get_node_attributes
 from aidge_onnx.utils import warn_unsupported_attr
 from aidge_core import Log
 
@@ -49,5 +46,5 @@ def import_and(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node,
         return None
 
     my_node = aidge_core.And(name=node_name)
-    print(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/argmax.py b/aidge_onnx/node_import/onnx_converters/argmax.py
index 3d5f46e0cbee3e75bc66f60ac1b07d8dcaf88a04..df4b7afc41ba2250e6739bb60f032d0cdf149d92 100644
--- a/aidge_onnx/node_import/onnx_converters/argmax.py
+++ b/aidge_onnx/node_import/onnx_converters/argmax.py
@@ -8,10 +8,7 @@ http://www.eclipse.org/legal/epl-2.0.
 SPDX-License-Identifier: EPL-2.0
 """
 from typing import List, Tuple
-import numpy as np
-
 import aidge_core
-import numpy as np
 import onnx
 
 from aidge_onnx.node_import import auto_register_import
@@ -57,5 +54,5 @@ def import_argmax(onnx_node: onnx.NodeProto,
         return None
 
     my_op = aidge_core.ArgMaxOp(**argmax_attrs)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_core.Node(my_op, name = node_name)
diff --git a/aidge_onnx/node_import/onnx_converters/atan.py b/aidge_onnx/node_import/onnx_converters/atan.py
index 33798d90ee0d3333c34bb8bcd3ca307929e0db2f..11bc74211291f855f0cdf331c948283bbac5002c 100644
--- a/aidge_onnx/node_import/onnx_converters/atan.py
+++ b/aidge_onnx/node_import/onnx_converters/atan.py
@@ -34,5 +34,5 @@ def import_sigmoid(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.N
         return None
 
     my_node = aidge_core.Atan(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/averagepool.py b/aidge_onnx/node_import/onnx_converters/averagepool.py
index 95394fb0f49a56d457a797038e28f999d8e41392..62fe3c165b4d8018e996cbca1e618fc988edd776 100644
--- a/aidge_onnx/node_import/onnx_converters/averagepool.py
+++ b/aidge_onnx/node_import/onnx_converters/averagepool.py
@@ -121,5 +121,5 @@ def import_avg_pooling(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_co
         Log.warn(f"Warning: operator {op_aidge_class_name} is not supported in Aidge. This node will be filled by a GenericOperator.")
         return None
 
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_core.Node(avg_pooling_op, name = node_name)
diff --git a/aidge_onnx/node_import/onnx_converters/batchnorm.py b/aidge_onnx/node_import/onnx_converters/batchnorm.py
index 3e2f6b4864f527fb4268ebb665e92cb246123084..5f6c5577dea341e5728849ca83482bdd528eed9d 100644
--- a/aidge_onnx/node_import/onnx_converters/batchnorm.py
+++ b/aidge_onnx/node_import/onnx_converters/batchnorm.py
@@ -30,7 +30,7 @@ def import_batch_norm(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_cor
     """
     node_name = onnx_node.name if onnx_node.name else onnx_node.output[0]
     onnx_attrs = get_node_attributes(onnx_node, opset)
-    batchnorm_attrs: dict = {"epsilon": 1e-05, "momentum":0.9, "training_mode":False}
+    batchnorm_attrs: dict = {"epsilon": 1e-05,"momentum":0.9, "training_mode": False}
     #epsilon and momentum are present in all opsets
 
     if 'epsilon' in onnx_attrs:
@@ -41,9 +41,10 @@ def import_batch_norm(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_cor
         batchnorm_attrs['momentum'] = onnx_attrs['momentum']
         del onnx_attrs['momentum']
 
-    if 'training_mode' in onnx_attrs:
-        batchnorm_attrs['training_mode'] = onnx_attrs['training_mode']
-        del onnx_attrs['training_mode']
+    if opset >= 14:
+        if 'training_mode' in onnx_attrs:
+            batchnorm_attrs['training_mode'] = onnx_attrs['training_mode']
+            del onnx_attrs['training_mode']
 
     if opset < 9:
         if 'spatial' in onnx_attrs:
@@ -70,5 +71,5 @@ def import_batch_norm(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_cor
     # This may be the case if the input is not an ONNX initializer, but another
     # node (like Identity).
     batch_norm_node = aidge_core.Node(aidge_core.BatchNorm2DOp(**batchnorm_attrs), name=node_name)
-    print(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return batch_norm_node
diff --git a/aidge_onnx/node_import/onnx_converters/bitshift.py b/aidge_onnx/node_import/onnx_converters/bitshift.py
index 7e1162518cd97bfe04c53edbced9cf7bfa25b944..4ed141a1340abc2a1ac35236f407cbc285e88c3b 100644
--- a/aidge_onnx/node_import/onnx_converters/bitshift.py
+++ b/aidge_onnx/node_import/onnx_converters/bitshift.py
@@ -11,7 +11,7 @@ from typing import List, Tuple
 
 import aidge_core
 import onnx
-
+from aidge_core import Log
 from aidge_onnx.node_import import auto_register_import
 
 @auto_register_import("bitshift")
@@ -28,23 +28,23 @@ def import_bitshift(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.
     attrs = {attr.name : attr for attr in onnx_node.attribute}
     onnx_attr_default: dict = {}
     direction = None
-    
+
     if 'direction' in attrs:
         onnx_attr_default['direction'] = attrs['direction']
         del attrs['direction']
-   
+
     if(len(attrs) > 0):
-        print(f"Warning: Attribute {attrs.keys()} is not supported for operator bitshift.")
+        Log.warn(f"Warning: Attribute {attrs.keys()} is not supported for operator bitshift.")
         return None
-   
+
     string_direction_onnx = onnx_attr_default['direction'].s.decode('utf-8')
     if(string_direction_onnx == "RIGHT"):
         direction  = aidge_core.BitShiftOp.BitShiftDirection.Right
     elif(string_direction_onnx == "LEFT"):
         direction  = aidge_core.BitShiftOp.BitShiftDirection.Left
     else:
-        print(f"Warning: Unable to parse shift direction <{string_direction_onnx}> for operator bitshift")
+        Log.warn(f"Warning: Unable to parse shift direction <{string_direction_onnx}> for operator bitshift")
         return None
     My_op = aidge_core.BitShiftOp(direction)
-    print(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_core.Node(My_op,name=node_name)
diff --git a/aidge_onnx/node_import/onnx_converters/clip.py b/aidge_onnx/node_import/onnx_converters/clip.py
index 2a7a07f8ceaae795145a8dc830292f75335d9832..583f71344c199016cf54ab3c83c285888b0e6c39 100644
--- a/aidge_onnx/node_import/onnx_converters/clip.py
+++ b/aidge_onnx/node_import/onnx_converters/clip.py
@@ -11,9 +11,9 @@ from typing import List, Tuple
 
 import aidge_core
 import onnx
-import numpy as np
 
 from aidge_onnx.node_import import auto_register_import
+from aidge_core import Log
 
 @auto_register_import("clip")
 def import_clip(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node, int]], opset=None) -> aidge_core.Node:
@@ -41,13 +41,13 @@ def import_clip(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node
         valmin = onnx_attr_default['min'].f
         valmax = onnx_attr_default['max'].f
         clip = aidge_core.Clip(min=valmin,max=valmax)
-        print(f"- {node_name} ({onnx_node.op_type})")
+        Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
         return clip
-            
-        if(len(attrs) > 0):
-            print(f"Warning: Attribute {attrs.keys()} is not supported for operator Clip.")
-            return None
-        
+
+    if(len(attrs) > 0):
+        Log.warn(f"Warning: Attribute {attrs.keys()} is not supported for operator Clip.")
+        return None
+
     clip = aidge_core.Clip()
-    print(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return clip
diff --git a/aidge_onnx/node_import/onnx_converters/concat.py b/aidge_onnx/node_import/onnx_converters/concat.py
index 0da25b4d654ced7373948925c63bd7ce9c665459..b2d4dd89f87746ec414958a0661f95fe350afdee 100644
--- a/aidge_onnx/node_import/onnx_converters/concat.py
+++ b/aidge_onnx/node_import/onnx_converters/concat.py
@@ -8,7 +8,6 @@ http://www.eclipse.org/legal/epl-2.0.
 SPDX-License-Identifier: EPL-2.0
 """
 from typing import List, Tuple
-import numpy as np
 
 import aidge_core
 import onnx
@@ -51,7 +50,7 @@ def import_concat(onnx_node: onnx.NodeProto, input_nodes: List[Tuple[aidge_core.
     if 'axis' in onnx_attrs:
         concat_attrs["axis"] = onnx_attrs['axis']
         del onnx_attrs['axis']
-        
+
     if concat_attrs["axis"] is None:
         Log.warn("Warning: Operator 'Concat' must have 'axis' attribute. This node will be filled by a GenericOperator.")
         return None
@@ -62,5 +61,5 @@ def import_concat(onnx_node: onnx.NodeProto, input_nodes: List[Tuple[aidge_core.
 
     my_op = aidge_core.ConcatOp(**concat_attrs)
 
-    print(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_core.Node(my_op, name = node_name)
diff --git a/aidge_onnx/node_import/onnx_converters/constant.py b/aidge_onnx/node_import/onnx_converters/constant.py
index 06a698cf92eec0e5617c194ab62660d9d341cd46..c76c60dccc28e9bc27dad9771b6163427da0d5b4 100644
--- a/aidge_onnx/node_import/onnx_converters/constant.py
+++ b/aidge_onnx/node_import/onnx_converters/constant.py
@@ -32,7 +32,7 @@ def import_constant(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.
     if len(onnx_node.attribute) == 1:
         #Only value accepted in aidge for the moment
         if onnx_node.attribute[0].name == "value":
-            Log.notice(f"- {node_name} ({onnx_node.op_type})")
+            Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
             values = numpy_helper.to_array(onnx_node.attribute[0].t)
             Log.notice(f"val type: {values.dtype}")
             return aidge_core.Producer(aidge_core.Tensor(values) if values.shape != () else aidge_core.Tensor(np.array(values.item(), dtype=values.dtype)), node_name, True)
diff --git a/aidge_onnx/node_import/onnx_converters/constantofshape.py b/aidge_onnx/node_import/onnx_converters/constantofshape.py
index 8912ef319b6a2370bc9cb9abba117b223d38d85c..3547c9f39f6065d43765da922ae47409ab5dd325 100644
--- a/aidge_onnx/node_import/onnx_converters/constantofshape.py
+++ b/aidge_onnx/node_import/onnx_converters/constantofshape.py
@@ -51,6 +51,6 @@ def import_constant(
 
     constant_of_shape_node = aidge_core.ConstantOfShape(attrs["value"], node_name)
 
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return constant_of_shape_node
 
diff --git a/aidge_onnx/node_import/onnx_converters/conv.py b/aidge_onnx/node_import/onnx_converters/conv.py
index 43c70fd44923b9b454c284f92d28b01c52f5ffff..348e7e831ce73ede49df89607581372f3bf67945 100644
--- a/aidge_onnx/node_import/onnx_converters/conv.py
+++ b/aidge_onnx/node_import/onnx_converters/conv.py
@@ -148,5 +148,5 @@ def import_conv(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node
         Log.warn(f"Warning: {op_aidge_class_name} is not supported in Aidge. This node will be filled by a GenericOperator.")
         return None
 
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_core.Node(aidge_op, name = node_name)
diff --git a/aidge_onnx/node_import/onnx_converters/depthtospace.py b/aidge_onnx/node_import/onnx_converters/depthtospace.py
index 3b07f55348888711a36a01a496560684568c69d1..b7dd3d1c521a1366d6723056018fe14e55520e93 100644
--- a/aidge_onnx/node_import/onnx_converters/depthtospace.py
+++ b/aidge_onnx/node_import/onnx_converters/depthtospace.py
@@ -57,5 +57,5 @@ def import_dtp(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node,
         return None
 
     aidge_node = aidge_core.DepthToSpace(**aidge_attrs)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_node
diff --git a/aidge_onnx/node_import/onnx_converters/dequantizelinear.py b/aidge_onnx/node_import/onnx_converters/dequantizelinear.py
index a42e3ec6b8e585640c6c331a2743968228117101..5248a95f21ccc4c883ee17484d47e447f6dadf6a 100644
--- a/aidge_onnx/node_import/onnx_converters/dequantizelinear.py
+++ b/aidge_onnx/node_import/onnx_converters/dequantizelinear.py
@@ -8,8 +8,6 @@ http://www.eclipse.org/legal/epl-2.0.
 SPDX-License-Identifier: EPL-2.0
 """
 from typing import List, Tuple
-import numpy as np
-
 import aidge_core
 import onnx
 from aidge_onnx.node_import import auto_register_import
@@ -37,7 +35,6 @@ def import_dequantizelinear(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aid
 
     node_name = onnx_node.name if onnx_node.name else onnx_node.output[0]
     onnx_attrs = get_node_attributes(onnx_node, opset)
-    quantize_linear_attrs: dict = {}
 
     if opset >= 13:
         if 'axis' in onnx_attrs:
@@ -99,5 +96,5 @@ def import_dequantizelinear(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aid
                                             dequantize_graph,
                                             name = node_name)
 
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return dequant_metaop
diff --git a/aidge_onnx/node_import/onnx_converters/div.py b/aidge_onnx/node_import/onnx_converters/div.py
index 7f2fcd13a4fa85ccf81f3c8df59fc166fd9a2139..9c813b717c36e05e36a1fc1a9f151644dea2f9f5 100644
--- a/aidge_onnx/node_import/onnx_converters/div.py
+++ b/aidge_onnx/node_import/onnx_converters/div.py
@@ -53,5 +53,5 @@ def import_div(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node,
         return None
 
     my_node = aidge_core.Div(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/dropout.py b/aidge_onnx/node_import/onnx_converters/dropout.py
index d44b7c54097d70eee94080411d029a2d5dd1fb7b..f5b52674dabf15baf46ced01a07e96a4c4b2cb65 100644
--- a/aidge_onnx/node_import/onnx_converters/dropout.py
+++ b/aidge_onnx/node_import/onnx_converters/dropout.py
@@ -28,5 +28,5 @@ def import_dropout(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.N
 
     # @todo: replace Identity with Dropout operator when it is added
     my_node = aidge_core.Identity(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/erf.py b/aidge_onnx/node_import/onnx_converters/erf.py
index 8ee39b1ffe5d4357dd383ed26f1ac17cc5f1e900..2356722732fc7e01238980ac504e6900189a71e4 100644
--- a/aidge_onnx/node_import/onnx_converters/erf.py
+++ b/aidge_onnx/node_import/onnx_converters/erf.py
@@ -32,5 +32,5 @@ def import_erf(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node,
         return None
 
     my_node = aidge_core.Erf(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/flatten.py b/aidge_onnx/node_import/onnx_converters/flatten.py
index f7bd2e59d6785b9353193ff16d21b7677329c72f..ee7cbaeee5d18a8e204583901dbd577654a5427b 100644
--- a/aidge_onnx/node_import/onnx_converters/flatten.py
+++ b/aidge_onnx/node_import/onnx_converters/flatten.py
@@ -40,5 +40,5 @@ def import_reshape(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.N
         return None
 
     my_node = aidge_core.Flatten(**flatten_attrs)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/gather.py b/aidge_onnx/node_import/onnx_converters/gather.py
index 5b7d43c5af6fc8d74a59e54f5023184514545a7f..26af8146ee70029dbf014715e3e20d08f390b774 100644
--- a/aidge_onnx/node_import/onnx_converters/gather.py
+++ b/aidge_onnx/node_import/onnx_converters/gather.py
@@ -8,7 +8,6 @@ http://www.eclipse.org/legal/epl-2.0.
 SPDX-License-Identifier: EPL-2.0
 """
 from typing import List, Tuple
-import numpy as np
 
 import aidge_core
 import onnx
@@ -41,5 +40,5 @@ def import_gather(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.No
         return None
     #gathered shape missing
     gather_node = aidge_core.Gather(**gather_attrs, name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return gather_node
diff --git a/aidge_onnx/node_import/onnx_converters/gemm.py b/aidge_onnx/node_import/onnx_converters/gemm.py
index 0e1a4d20b6aa8d9729dd6bfd42b0b19fe0dabc25..56aa4f9171a4fb8a3edbe0dc23b6fc0088bc5e2c 100644
--- a/aidge_onnx/node_import/onnx_converters/gemm.py
+++ b/aidge_onnx/node_import/onnx_converters/gemm.py
@@ -80,5 +80,5 @@ def import_gemm(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node
             return None
 
     fc_node = aidge_core.Node(aidge_core.FCOp(), name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return fc_node
diff --git a/aidge_onnx/node_import/onnx_converters/globalaveragepooling.py b/aidge_onnx/node_import/onnx_converters/globalaveragepooling.py
index 8a4d5bdbae9c3c440edc88be0184adea808ac102..66b2de37e09344c592079668f6e88295fc353fdd 100644
--- a/aidge_onnx/node_import/onnx_converters/globalaveragepooling.py
+++ b/aidge_onnx/node_import/onnx_converters/globalaveragepooling.py
@@ -37,5 +37,5 @@ def import_globalaveragepooling(
         return None
 
     global_average_pooling_node = aidge_core.globalaveragepooling(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return global_average_pooling_node
diff --git a/aidge_onnx/node_import/onnx_converters/gridsample.py b/aidge_onnx/node_import/onnx_converters/gridsample.py
index 222d2378cf10b57b498b0df6b3ec288c197bd555..a2293a336043ef8057efc6cd59910650396715ef 100644
--- a/aidge_onnx/node_import/onnx_converters/gridsample.py
+++ b/aidge_onnx/node_import/onnx_converters/gridsample.py
@@ -78,5 +78,5 @@ def import_gridsample(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_cor
         return None
 
     aidge_node = aidge_core.GridSample(**aidge_attrs)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_node
diff --git a/aidge_onnx/node_import/onnx_converters/identity.py b/aidge_onnx/node_import/onnx_converters/identity.py
index c6e89658bb694600bc811bc696c845ee0303349d..6afbf3da081810593f4fb34a268b53324258ee19 100644
--- a/aidge_onnx/node_import/onnx_converters/identity.py
+++ b/aidge_onnx/node_import/onnx_converters/identity.py
@@ -32,5 +32,5 @@ def import_identity(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.
         return None
 
     my_node = aidge_core.Identity(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/leakyrelu.py b/aidge_onnx/node_import/onnx_converters/leakyrelu.py
index c2e2a5c9eb4c3d1fa33d0d726cc4c0094254ca97..7487f4214935dd1f8eca51a98b89ad4a6b71d5b4 100644
--- a/aidge_onnx/node_import/onnx_converters/leakyrelu.py
+++ b/aidge_onnx/node_import/onnx_converters/leakyrelu.py
@@ -44,5 +44,5 @@ def import_leaky_relu(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_cor
         return None
 
     my_node = aidge_core.LeakyReLU(**leaky_relu_attrs)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/lrn.py b/aidge_onnx/node_import/onnx_converters/lrn.py
index 9668beb57a40b209bbd0bd97cf318225fcd6d643..05ea464cd502dd136c42dd500fbc223db52ce5c9 100644
--- a/aidge_onnx/node_import/onnx_converters/lrn.py
+++ b/aidge_onnx/node_import/onnx_converters/lrn.py
@@ -60,5 +60,5 @@ def import_lrn(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node,
     my_op.attr.alpha = lrn_alpha
     my_op.attr.beta = lrn_beta
     my_op.attr.bias = lrn_bias
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_core.Node(my_op, name = node_name)
diff --git a/aidge_onnx/node_import/onnx_converters/lstm.py b/aidge_onnx/node_import/onnx_converters/lstm.py
index 988edabf62c67b2c997fd6cd6d89bccba06c52a1..d923e19b6b003860d5d838538e1617bc01327cd2 100644
--- a/aidge_onnx/node_import/onnx_converters/lstm.py
+++ b/aidge_onnx/node_import/onnx_converters/lstm.py
@@ -156,5 +156,5 @@ def import_lstm(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node
                        aidge_core.InputCategory.Param]
 
     my_node = aidge_core.meta_operator("LSTM_ONNX", graph, inputs_category, name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/matmul.py b/aidge_onnx/node_import/onnx_converters/matmul.py
index 5465fa060a138c712db946e8c9ea9fcfaad29bcf..93cce03ff69fe1b3464384475f4f1aad7010f81f 100644
--- a/aidge_onnx/node_import/onnx_converters/matmul.py
+++ b/aidge_onnx/node_import/onnx_converters/matmul.py
@@ -8,7 +8,6 @@ http://www.eclipse.org/legal/epl-2.0.
 SPDX-License-Identifier: EPL-2.0
 """
 from typing import List, Tuple
-import numpy as np
 
 import aidge_core
 import onnx
@@ -33,5 +32,5 @@ def import_matmul(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.No
         return None
 
     matmul_node = aidge_core.MatMul(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return matmul_node
diff --git a/aidge_onnx/node_import/onnx_converters/maxpool.py b/aidge_onnx/node_import/onnx_converters/maxpool.py
index c651b4197a498abd73d4539ebad5ce2e7fad03df..4a26b797d61a6925785fc65fbe2b691c48b218d9 100644
--- a/aidge_onnx/node_import/onnx_converters/maxpool.py
+++ b/aidge_onnx/node_import/onnx_converters/maxpool.py
@@ -124,5 +124,5 @@ def import_max_pooling(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_co
         name=node_name,
         **maxpool_attrs)
 
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return max_pooling_node
diff --git a/aidge_onnx/node_import/onnx_converters/mul.py b/aidge_onnx/node_import/onnx_converters/mul.py
index 56028784acd3c9993523e8509df3a1f51329c18a..4efce8a36240540c218cfcd53ad8f5e3c3dafcad 100644
--- a/aidge_onnx/node_import/onnx_converters/mul.py
+++ b/aidge_onnx/node_import/onnx_converters/mul.py
@@ -52,5 +52,5 @@ def import_mul(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node,
         return None
 
     my_node = aidge_core.Mul(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/pad.py b/aidge_onnx/node_import/onnx_converters/pad.py
index d02e7e19f0db96b66a3e1c70fe639a2d59040fff..30d33d81e9e8a81c56d2a9302deb1ea640313a78 100644
--- a/aidge_onnx/node_import/onnx_converters/pad.py
+++ b/aidge_onnx/node_import/onnx_converters/pad.py
@@ -89,6 +89,6 @@ def import_slice(
         return None
 
     pad_node = getattr(aidge_core, cls_name)(onnx_pads, name=node_name)
-    print(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
 
     return pad_node
diff --git a/aidge_onnx/node_import/onnx_converters/pow.py b/aidge_onnx/node_import/onnx_converters/pow.py
index 3a74589fc78456311e68f318b5e93f6d6d299e12..8ddb31eae92d52c67525e020bdb9324b2f80713d 100644
--- a/aidge_onnx/node_import/onnx_converters/pow.py
+++ b/aidge_onnx/node_import/onnx_converters/pow.py
@@ -48,5 +48,5 @@ def import_pow(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node,
         return None
 
     my_node = aidge_core.Pow(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/qlinearconv.py b/aidge_onnx/node_import/onnx_converters/qlinearconv.py
index ec4d1792e4aae523bd2925a4fdc885476ff199ac..a35f610ed73e2c5b5e3902543f82aa334cbee6fb 100644
--- a/aidge_onnx/node_import/onnx_converters/qlinearconv.py
+++ b/aidge_onnx/node_import/onnx_converters/qlinearconv.py
@@ -282,5 +282,5 @@ def import_qlinearconv(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_co
                              qlinear_conv_graph,
                              name = "qlinear_"+node_name)
 
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return qlinear_conv_metaop
diff --git a/aidge_onnx/node_import/onnx_converters/quantizelinear.py b/aidge_onnx/node_import/onnx_converters/quantizelinear.py
index b2f2f23a5507f7f6d34eeb814d36d48b90b9f646..e7fde5a9ddc5abc0dbfb85c6806c190088c2d3ec 100644
--- a/aidge_onnx/node_import/onnx_converters/quantizelinear.py
+++ b/aidge_onnx/node_import/onnx_converters/quantizelinear.py
@@ -8,7 +8,6 @@ http://www.eclipse.org/legal/epl-2.0.
 SPDX-License-Identifier: EPL-2.0
 """
 from typing import List, Tuple
-import numpy as np
 
 import aidge_core
 import onnx
@@ -118,5 +117,5 @@ def import_quantizelinear(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge
                              quantize_linear_graph,
                              name = node_name)
 
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return metaop_quantize_linear
diff --git a/aidge_onnx/node_import/onnx_converters/reducemean.py b/aidge_onnx/node_import/onnx_converters/reducemean.py
index 795ca74b4afd6c0387bbe0d4802ec0a1eb09e0ea..736b63599d9b8b10f211279ae0ac25b53040c52d 100644
--- a/aidge_onnx/node_import/onnx_converters/reducemean.py
+++ b/aidge_onnx/node_import/onnx_converters/reducemean.py
@@ -59,5 +59,5 @@ def import_reducemean(onnx_node: onnx.NodeProto,
         return None
 
     my_op = aidge_core.ReduceMeanOp(**reducemean_attrs)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_core.Node(my_op, name = node_name)
diff --git a/aidge_onnx/node_import/onnx_converters/reducesum.py b/aidge_onnx/node_import/onnx_converters/reducesum.py
index bbb2936881202dac6a711dae7966984dbc0891f7..1948ecf556e27d003e1045bfa3a4f29a6655bab5 100644
--- a/aidge_onnx/node_import/onnx_converters/reducesum.py
+++ b/aidge_onnx/node_import/onnx_converters/reducesum.py
@@ -8,10 +8,7 @@ http://www.eclipse.org/legal/epl-2.0.
 SPDX-License-Identifier: EPL-2.0
 """
 from typing import List, Tuple
-import numpy as np
-
 import aidge_core
-import numpy as np
 import onnx
 
 from aidge_onnx.node_import import auto_register_import
@@ -59,5 +56,5 @@ def import_reducesum(onnx_node: onnx.NodeProto,
         return None
 
     my_op = aidge_core.ReduceSumOp(**reducesum_attrs)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_core.Node(my_op, name = node_name)
diff --git a/aidge_onnx/node_import/onnx_converters/relu.py b/aidge_onnx/node_import/onnx_converters/relu.py
index a32d9c4d1294f3d6fc447e2d1b995b90b8c11887..2838af8a1f3053d3a8dbd27961a579e9ca4441fb 100644
--- a/aidge_onnx/node_import/onnx_converters/relu.py
+++ b/aidge_onnx/node_import/onnx_converters/relu.py
@@ -49,5 +49,5 @@ def import_relu(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node
         return None
 
     my_node = aidge_core.Node(aidge_core.ReLUOp(), name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/reshape.py b/aidge_onnx/node_import/onnx_converters/reshape.py
index acf8395f5e14ec28f349d21e2f88c1730e27a9a8..6ed2340344eb09027f1e984fccded451bb7edae5 100644
--- a/aidge_onnx/node_import/onnx_converters/reshape.py
+++ b/aidge_onnx/node_import/onnx_converters/reshape.py
@@ -52,5 +52,5 @@ def import_reshape(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.N
         return None
 
     my_node = aidge_core.Reshape(**reshape_attrs)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/resize.py b/aidge_onnx/node_import/onnx_converters/resize.py
index ff3d9f07559ab5871994abd27afee44481b849c4..be5c8c57a08b8d8c31ebf6a28d3778847e0a297f 100644
--- a/aidge_onnx/node_import/onnx_converters/resize.py
+++ b/aidge_onnx/node_import/onnx_converters/resize.py
@@ -8,8 +8,6 @@ http://www.eclipse.org/legal/epl-2.0.
 SPDX-License-Identifier: EPL-2.0
 """
 from typing import List, Tuple
-import numpy as np
-
 import aidge_core
 import onnx
 
@@ -65,7 +63,6 @@ def import_resize(onnx_node: onnx.NodeProto, input_nodes: List[Tuple[aidge_core.
     if 'coordinate_transformation_mode' in onnx_attrs:
         resize_attrs['coordinate_transformation_mode'] = onnx_attrs['coordinate_transformation_mode'].decode()
         del onnx_attrs['coordinate_transformation_mode']
-    print(onnx_attrs)
     if 'mode' in onnx_attrs:
         if onnx_attrs['mode'] == b'nearest':
             if 'nearest_mode' in onnx_attrs:
@@ -85,5 +82,5 @@ def import_resize(onnx_node: onnx.NodeProto, input_nodes: List[Tuple[aidge_core.
 
     aidge_op = aidge_core.ResizeOp(coord_trans_dict[resize_attrs['coordinate_transformation_mode']],
                                     mode_dict[resize_attrs['mode']])
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_core.Node(aidge_op, name = node_name)
diff --git a/aidge_onnx/node_import/onnx_converters/round.py b/aidge_onnx/node_import/onnx_converters/round.py
index f6d7bc61cbb151872c224c376c440177cc3698f7..72cd98278e40325488fbd1c407982e6ffe396112 100644
--- a/aidge_onnx/node_import/onnx_converters/round.py
+++ b/aidge_onnx/node_import/onnx_converters/round.py
@@ -15,7 +15,6 @@ import onnx
 from aidge_onnx.node_import import auto_register_import
 
 from aidge_core import Log
-from aidge_onnx.utils import warn_unsupported_attr
 
 @auto_register_import("round")
 def import_round(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node, int]], opset=None) -> aidge_core.Node:
@@ -30,5 +29,5 @@ def import_round(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Nod
     node_name = onnx_node.name if onnx_node.name else onnx_node.output[0]
 
     my_node = aidge_core.Round(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/shape.py b/aidge_onnx/node_import/onnx_converters/shape.py
index 5530e9c694ffa9428eb5bb3c2e6f2ad86ec3b61a..972881e73b2386687707b013915ae7c806bcdfb8 100644
--- a/aidge_onnx/node_import/onnx_converters/shape.py
+++ b/aidge_onnx/node_import/onnx_converters/shape.py
@@ -67,5 +67,5 @@ def import_shape(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Nod
         return None
 
     my_node = aidge_core.Shape(**shape_attrs, name = onnx_node.output[0])
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/sigmoid.py b/aidge_onnx/node_import/onnx_converters/sigmoid.py
index 1a385234c6714c5cc4012b8d152753aa15a8d860..244f94f19ba5dcee6f1ec93b210777f16b2e5a5d 100644
--- a/aidge_onnx/node_import/onnx_converters/sigmoid.py
+++ b/aidge_onnx/node_import/onnx_converters/sigmoid.py
@@ -38,5 +38,5 @@ def import_sigmoid(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.N
         return None
 
     my_node = aidge_core.Sigmoid(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/slice.py b/aidge_onnx/node_import/onnx_converters/slice.py
index 8a3fb4556a9e129d4c323a5b8a45a42cb9d7f271..16c7382dbada9c81db95fc80e691c0fd9ab13d29 100644
--- a/aidge_onnx/node_import/onnx_converters/slice.py
+++ b/aidge_onnx/node_import/onnx_converters/slice.py
@@ -46,5 +46,5 @@ def import_slice(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Nod
         return None
 
     slice_node = aidge_core.Slice(**slice_attrs)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return slice_node
diff --git a/aidge_onnx/node_import/onnx_converters/softmax.py b/aidge_onnx/node_import/onnx_converters/softmax.py
index c47ad192d9b813efdfc04af1e3379d3fe3b8f035..da129ca80b126810387b30a5718bc337ba4b1eac 100644
--- a/aidge_onnx/node_import/onnx_converters/softmax.py
+++ b/aidge_onnx/node_import/onnx_converters/softmax.py
@@ -41,5 +41,5 @@ def import_softmax(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.N
         return None
 
     my_op = aidge_core.SoftmaxOp(softmax_axis)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return aidge_core.Node(my_op, name = node_name)
diff --git a/aidge_onnx/node_import/onnx_converters/split.py b/aidge_onnx/node_import/onnx_converters/split.py
index b5b67012ae554e5361d45f68fc58f8708324ee75..70d05d6bd78a954e1007b07a5d7482a403f578a3 100644
--- a/aidge_onnx/node_import/onnx_converters/split.py
+++ b/aidge_onnx/node_import/onnx_converters/split.py
@@ -58,5 +58,5 @@ def import_split(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Nod
         return None
 
     my_node = aidge_core.Split(**split_attrs, name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/sqrt.py b/aidge_onnx/node_import/onnx_converters/sqrt.py
index a480cb6be27e01a1b832604ba5264fb2c950757b..febf960b78d1df69a89da6caad034fc3aab10e97 100644
--- a/aidge_onnx/node_import/onnx_converters/sqrt.py
+++ b/aidge_onnx/node_import/onnx_converters/sqrt.py
@@ -38,5 +38,5 @@ def import_sqrt(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node
         return None
 
     my_node = aidge_core.Sqrt(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/squeeze.py b/aidge_onnx/node_import/onnx_converters/squeeze.py
index 9d9f97319070718d88a20395784644f737384379..0c027c754b2dbfe8304665a5729e6e72750b7ed8 100644
--- a/aidge_onnx/node_import/onnx_converters/squeeze.py
+++ b/aidge_onnx/node_import/onnx_converters/squeeze.py
@@ -9,7 +9,6 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 from typing import List
-import numpy as np
 
 import aidge_core
 from aidge_core import Log
@@ -68,6 +67,6 @@ def import_squeeze(
         return None
 
     squeeze_node = aidge_core.Squeeze(axes=axes, name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return squeeze_node
 
diff --git a/aidge_onnx/node_import/onnx_converters/sub.py b/aidge_onnx/node_import/onnx_converters/sub.py
index c3996859976e5abcc08f7a2bca2f13119cb07d20..f956f3aeaccb7212edb5915135e05f564a09586e 100644
--- a/aidge_onnx/node_import/onnx_converters/sub.py
+++ b/aidge_onnx/node_import/onnx_converters/sub.py
@@ -52,5 +52,5 @@ def import_sub(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node,
         return None
 
     my_node = aidge_core.Sub(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/sum.py b/aidge_onnx/node_import/onnx_converters/sum.py
index ba1c03a15f4eb336ab16c3e80c026ea2b4554df8..2affe405ff74e295c9c0cac492a4df001f3e8139 100644
--- a/aidge_onnx/node_import/onnx_converters/sum.py
+++ b/aidge_onnx/node_import/onnx_converters/sum.py
@@ -53,5 +53,5 @@ def import_sum(
         return None
 
     my_node = aidge_core.Add(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/tanh.py b/aidge_onnx/node_import/onnx_converters/tanh.py
index 65431d5a3b60721cec08c6d4672ad63d1f207acf..284e5cb35849b1c8050c15370428ed06035dd349 100644
--- a/aidge_onnx/node_import/onnx_converters/tanh.py
+++ b/aidge_onnx/node_import/onnx_converters/tanh.py
@@ -38,5 +38,5 @@ def import_tanh(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core.Node
         return None
 
     my_node = aidge_core.Tanh(name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return my_node
diff --git a/aidge_onnx/node_import/onnx_converters/transpose.py b/aidge_onnx/node_import/onnx_converters/transpose.py
index cf571cd4909ff2b68e08867ac53184610aa8ccb5..aad62318e04432a9bd7c7ef4f6353ee2c87e51c0 100644
--- a/aidge_onnx/node_import/onnx_converters/transpose.py
+++ b/aidge_onnx/node_import/onnx_converters/transpose.py
@@ -37,5 +37,5 @@ def import_transpose(onnx_node:onnx.NodeProto, input_nodes:List[Tuple[aidge_core
         return None
 
     transpose_node = aidge_core.Transpose(**transpose_attrs)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return transpose_node
diff --git a/aidge_onnx/node_import/onnx_converters/unsqueeze.py b/aidge_onnx/node_import/onnx_converters/unsqueeze.py
index f785534af9520389c7ac62b02cbf1d649a6115f7..dcb4ed656e7f52099eff658eea6a71969135dae5 100644
--- a/aidge_onnx/node_import/onnx_converters/unsqueeze.py
+++ b/aidge_onnx/node_import/onnx_converters/unsqueeze.py
@@ -9,15 +9,12 @@ SPDX-License-Identifier: EPL-2.0
 """
 
 from typing import List
-import numpy as np
 
 import aidge_core
 from aidge_core import Log
 import onnx
-
 from aidge_onnx.node_import import auto_register_import
 
-
 @auto_register_import("unsqueeze")
 def import_unsqueeze(
     onnx_node: onnx.NodeProto, input_nodes: List[aidge_core.Node], opset=None
@@ -69,6 +66,6 @@ def import_unsqueeze(
     # expanded (heterogeneous) - T:
     #     Reshaped tensor with same data as input.
     unsqueeze_node = aidge_core.Unsqueeze(axes=axes, name=node_name)
-    Log.notice(f"- {node_name} ({onnx_node.op_type})")
+    Log.info(f"Loaded node [\033[1m\033[3m{node_name}\033[0m] of type [\033[1m\033[3m{onnx_node.op_type}\033[0m]")
     return unsqueeze_node
 
diff --git a/aidge_onnx/onnx_export.py b/aidge_onnx/onnx_export.py
index 366893a0142cb053687af18825f5f9ad932b2b30..30b8ce691134fb04fafc5546ea4348869a5d54e1 100644
--- a/aidge_onnx/onnx_export.py
+++ b/aidge_onnx/onnx_export.py
@@ -80,7 +80,7 @@ def export_onnx(graph_view: aidge_core.GraphView,
     """
     major, minor = onnx.__version__.split(".")[:2]
     if enable_custom_op and (int(major)*100 + int(minor) < 114):
-        print("Warning: Cannot enable custom operator with onnx < 1.14, update onnx library with:"
+        ("Warning: Cannot enable custom operator with onnx < 1.14, update onnx library with:"
               "\n\t> pip install --upgrade onnx\nDefaulting to enable_custom_op = False")
         enable_custom_op = False
     if opset is None:
@@ -131,8 +131,7 @@ def export_onnx(graph_view: aidge_core.GraphView,
         if isinstance(aidge_operator, aidge_core.ProducerOp):
             if aidge_operator.get_output(0).has_impl():
                 if not aidge_operator.attr.constant:
-                    if verbose:
-                        print(f"Creating initializer: {aidge_node.name()}")
+                    aidge_core.Log.info(f"Creating initializer: {aidge_node.name()}")
                     onnx_initializers.append(
                         numpy_helper.from_array(
                             np.array(aidge_operator.get_output(0)),
diff --git a/aidge_onnx/onnx_import.py b/aidge_onnx/onnx_import.py
index 6c4d8341e87dc5df2475059c05fd66c0a89d103d..74d93a1c22496bfd200020adf25aeba57ae88368 100644
--- a/aidge_onnx/onnx_import.py
+++ b/aidge_onnx/onnx_import.py
@@ -20,7 +20,7 @@ from onnx import numpy_helper
 import onnx
 from .node_import import ONNX_NODE_CONVERTER_, generic
 from .utils import onnx_to_aidge_model_names
-
+from aidge_core import Log
 
 def load_onnx(filename: str, verbose: bool = False):
     """Load an ONNX file and convert it into a :py:class:`aidge_core.GraphView`.
@@ -32,8 +32,7 @@ def load_onnx(filename: str, verbose: bool = False):
     :returns: Aidge :py:class:`aidge_core.GraphView` corresponding to the ONNX model described by the onnx file  ``filename``
     :rtype: :py:class:`aidge_core.GraphView`
     """
-    if verbose:
-        print(f"Loading ONNX {filename}")
+    aidge_core.Log.info(f"Loading ONNX {filename}")
 
     # Load the ONNX model
     model = onnx.load(filename)
@@ -62,7 +61,7 @@ def native_coverage_report(graph: aidge_core.GraphView):
     :type graph: aidge_core.GraphView
     """
     if len(graph.get_nodes()) == 0:
-        print("GraphView is empty!")
+        Log.warn("GraphView is empty, could not get a native coverage report!")
         return
 
     native_node_types = defaultdict(int)
@@ -260,8 +259,7 @@ def _load_onnx2graphview(model: onnx.ModelProto,
         domains = {domain.domain: domain.version for domain in model.opset_import}
     else:
         raise RuntimeError("Cannot retieve opset version from ONNX model.")
-    if verbose:
-        print(
+    aidge_core.Log.info(
             f"ONNX metadata:"
             f"\n\t- Producer name: {model.producer_name}"
             f"\n\t- Producer version: {model.producer_version}"
@@ -274,16 +272,14 @@ def _load_onnx2graphview(model: onnx.ModelProto,
     # might affect Aidge in the next steps
     model = onnx_to_aidge_model_names(model)
 
-    if verbose:
-        print("\nConstructing DFG\n====================")
+    aidge_core.Log.info("Constructing DFG...")
     dfg = _get_dataflow_graph(model)
 
     # Clean dataflow graph
     if remove_unused_init:
         _remove_unused_initializers(dfg)
 
-    if verbose:
-        print("\nProcessing Initializers\n====================")
+    aidge_core.Log.info("Processing Initializers...")
     for node_id, onnx_init in dfg.initializers.items():
         values = numpy_helper.to_array(onnx_init)
         aidge_node = aidge_core.Producer(
@@ -296,8 +292,7 @@ def _load_onnx2graphview(model: onnx.ModelProto,
         if verbose:
             print(f"- Initializer: '{onnx_init.name}': {list(values.shape)}")
 
-    if verbose:
-        print("\nProcessing Nodes\n================")
+    aidge_core.Log.info("Processing Nodes...")
     # Get the nodes
     # Associate the ONNX nodes with Aidge Node if possible
     for node_id, onnx_node in dfg.ops.items():
@@ -319,17 +314,15 @@ def _load_onnx2graphview(model: onnx.ModelProto,
                 onnx_node, node_inputs, node_opset
             )
         except Exception as e:
-            print(
-                colorama.Fore.YELLOW
-                + f"Warning: an error occured when trying to load node '{onnx_node.name}' of type {onnx_node.op_type.lower()}."
-            )
-            print("Loading node using a generic operator.")
-            print(
-                "Please report this issue at https://gitlab.eclipse.org/eclipse/aidge/aidge_onnx"
+            Log.warn(
+                f"Trying to load node named [\033[1m\033[3m{onnx_node.name}\033[0m] of type "
+                f"[\033[1m\033[3m{onnx_node.op_type}\033[0m].\n"
+                "Loading node using a [\033[1m\033[3mGenericOperator\033[0m].\n"
+                "Please report this issue at "
+                "https://gitlab.eclipse.org/eclipse/aidge/aidge_onnx by "
+                "providing your ONNX model and the following error:\n"
+                f"\"ONNX_NODE_CONVERTER_ returned: {e}\""
             )
-            print("by providing your ONNX model and the following error:")
-            print(f"ONNX_NODE_CONVERTER_ returned: {e}")
-            print(colorama.Style.RESET_ALL)
             aidge_node = None
 
         # If None, the node type exists but could not be converted (for instance because unsupported attribute) => fall back to generic
@@ -348,8 +341,7 @@ def _load_onnx2graphview(model: onnx.ModelProto,
             input_node_id, output_idx = inputs.pop()
             dfg.node_outputs[input_node_id][output_idx].remove((node_id, len(inputs)))
 
-    if verbose:
-        print("\nConnecting Nodes\n================")
+    aidge_core.Log.info("Connecting Nodes...")
     # Generate ordered input and add identity nodes only when necessary
     aidge_inputs = []
     for node_id, onnx_input in dfg.inputs.items():
@@ -366,9 +358,9 @@ def _load_onnx2graphview(model: onnx.ModelProto,
         aidge_inputs.append((input_node, input_idx))
         if verbose:
             if input_node is not None:
-                print(f"- Input: '{onnx_input.name}': {input_node.name()}#{input_idx}")
+                aidge_core.Log.debug(f"Input: '{onnx_input.name}': {input_node.name()}#{input_idx}")
             else:
-                print(f"- Input: '{onnx_input.name}': ignored")
+                aidge_core.Log.debug(f"Input: '{onnx_input.name}': ignored")
 
     # Generate ordered outputs
     aidge_outputs = []
@@ -381,11 +373,9 @@ def _load_onnx2graphview(model: onnx.ModelProto,
         aidge_outputs.append((output_node, output_idx))
         if verbose:
             if output_node is not None:
-                print(
-                    f"- Output: '{onnx_output.name}': {output_node.name()}#{output_idx}"
-                )
+                aidge_core.Log.debug(f"Output: '{onnx_output.name}': {output_node.name()}#{output_idx}")
             else:
-                print(f"- Output: '{onnx_output.name}': ignored")
+                aidge_core.Log.debug(f"Output: '{onnx_output.name}': ignored")
 
     # Link every inputs
     for node_id, inputs in dfg.node_inputs.items():
@@ -395,8 +385,7 @@ def _load_onnx2graphview(model: onnx.ModelProto,
             if input_node is not None:
                 if node is not None:
                     input_node.add_child(node, output_idx, input_idx)
-                    if verbose:
-                        print(
+                    aidge_core.Log.debug(
                             f"edge {input_node.name()}#{output_idx} -> {node.name()}#{input_idx} added"
                         )
                 # Add node to the graph after updating connections
@@ -405,8 +394,7 @@ def _load_onnx2graphview(model: onnx.ModelProto,
                 pass  # No node associated, it's a graph input
         if node is not None:
             graph.add(node)
-            if verbose:
-                print(f"node {node.name()} added")
+            aidge_core.Log.debug(f"node {node.name()} added")
 
     # The final output list may differ from the onnx output list as undefined/ignored outputs are filtered
     graph.set_ordered_outputs(
diff --git a/aidge_onnx/onnx_test.py b/aidge_onnx/onnx_test.py
index 97bcec33e349af5567db9592e77bca40c5af5cde..a544238816f2e333ede18c1bcb7688f93ef16aa2 100644
--- a/aidge_onnx/onnx_test.py
+++ b/aidge_onnx/onnx_test.py
@@ -1,5 +1,5 @@
 import onnx
-
+from aidge_core import Log
 def check_onnx_validity(onnx_file_path):
     """Check if an onnx file is valid with the ONNX standard.
     """
@@ -65,7 +65,7 @@ def check_isomorphism(file_path1, file_path2):
 
     # Easy check on number of nodes.
     if len(nodes1) != len(nodes2):
-        print(f"Graph are not isomorphic, number of nodes differs ({len(nodes1)} != {len(nodes2)})")
+        Log.notice(f"Graph are not isomorphic, number of nodes differs ({len(nodes1)} != {len(nodes2)})")
         return False
 
     # Set of index of nodes from graph2 which has been matched in graph1
@@ -80,6 +80,6 @@ def check_isomorphism(file_path1, file_path2):
                 matched_nodes.add(i)
                 node_not_found = False
         if node_not_found:
-            print(f"Cannot find equivalent of node: {node1.name} in {file_path2}")
+            Log.notice(f"Cannot find equivalent of node: {node1.name} in {file_path2}")
             return False
     return True
diff --git a/aidge_onnx/utils.py b/aidge_onnx/utils.py
index d833cd24bab480dca393d02a65856aea9ffd36e2..664237fe124a9c2460cf0f8f03a1902aaef4e976 100644
--- a/aidge_onnx/utils.py
+++ b/aidge_onnx/utils.py
@@ -2,9 +2,21 @@ import onnx
 
 from aidge_core import Log
 from typing import Dict, Any
+from importlib.metadata import version
 
 _AIDGE_DOMAIN = "ai.onnx.converters.aidge"
 
+def show_version():
+    version_aidge_onnx = version("aidge_onnx")
+    version_onnx = version("onnx")
+    version_protobuf = version("protobuf")
+    print(f"Aidge ONNX: {version_aidge_onnx}")
+    print(f"ONNX version: {version_onnx}")
+    print(f"Protobuf: {version_protobuf}")
+
+def get_project_version()->str:
+    return version("aidge_onnx")
+
 
 def onnx_to_aidge_model_names(model: onnx.ModelProto) -> onnx.ModelProto:
     """
diff --git a/pyproject.toml b/pyproject.toml
index 6efdbe75829c3985fe8c93fe2599da71b66e1cf0..f36a0b1d4e529f8c46174eb8342437e3cf068013 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,17 +5,25 @@ dependencies = [
     "numpy>=1.20",
     "onnx>=1.16.0",
     "colorama",
-    "typing_extensions"
+    "typing_extensions",
 ]
 
-requires-python = ">= 3.7"
+requires-python = ">= 3.8"
 readme = "README.md"
 license = { file = "LICENSE" }
-classifiers = [ 
+classifiers = [
     "Development Status :: 2 - Pre-Alpha",
     "Programming Language :: Python :: 3"
     ]
-dynamic = ["version"] # defined in tool.setuptools_scm
+dynamic = ["version"] # defined in pbr
+
+
+[project.urls]
+Homepage = "https://www.deepgreen.ai/en/platform"
+Documentation = "https://eclipse-aidge.readthedocs.io/en/latest/"
+Repository = "https://gitlab.eclipse.org/eclipse/aidge/aidge_onnx"
+Issues = "https://gitlab.eclipse.org/eclipse/aidge/aidge_onnx/-/issues/"
+Changelog = "https://gitlab.eclipse.org/eclipse/aidge/aidge_onnx/-/releases"
 
 [project.optional-dependencies]
 test = [
@@ -28,7 +36,7 @@ test = [
 [build-system]
 requires = [
     "setuptools>=64",
-    "setuptools_scm[toml]==7.1.0"
+    "pbr"
 ]
 build-backend = "setuptools.build_meta"
 #####################################################
@@ -40,18 +48,15 @@ build-backend = "setuptools.build_meta"
 #####################################################
 # SETUPTOOLS
 [tool.setuptools]
-include-package-data = true
+include-package-data = false # No package data
 [tool.setuptools.packages.find]
 where = ["."]  # list of folders that contain the packages (["."] by default)
-include = ["aidge_onnx"]  # package names should match these glob patterns (["*"] by default)
-namespaces = false  # to disable scanning PEP 420 namespaces (true by default)
+include = ["aidge_onnx*"]  # package names should match these glob patterns (["*"] by default)
+namespaces = false  # to disable scanning PEP 420 namespaces (true by default), note: this disable the packaging of module without a __init__.py
 [tool.setuptools.exclude-package-data]
 aidge_onnx = ["unit_tests*"]
-# SETUPTOOLS_SCM
-[tool.setuptools_scm]
-write_to = "aidge_onnx/_version.py"
 
-#####################################################
+# #####################################################
 # PYLINT
 [tool.pylint.main]
 # A comma-separated list of package or module names from where C extensions may
@@ -80,7 +85,7 @@ limit-inference-results = 100
 persistent = true
 # Minimum Python version to use for version dependent checks. Will default to the
 # version used to run pylint.
-py-version = "3.7"
+py-version = "3.8"
 # When enabled, pylint would attempt to guess common misconfiguration and emit
 # user-friendly hints instead of false-positive error messages.
 suggestion-mode = true
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..aa0f227f6688468a5ab93384f7b1670086000035
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,3 @@
+# pbr file
+[metadata]
+version = file: version.txt
diff --git a/version.txt b/version.txt
new file mode 100644
index 0000000000000000000000000000000000000000..267577d47e497a0630bc454b3f74c4fd9a10ced4
--- /dev/null
+++ b/version.txt
@@ -0,0 +1 @@
+0.4.1