Remove various print.

aidge_core/export_utils/export_registry.py

@@ -61,7 +61,6 @@ class ExportLib(aidge_core.OperatorImpl):
 
     def get_export_node(self, spec: aidge_core.aidge_core.ImplSpec):
         for registered_spec, export_node in self._export_node_registry[self.get_operator().type()]:
-            print(f"{registered_spec} vs {spec}")
             if registered_spec == spec:
 
                 return export_node
@@ -85,7 +84,6 @@ class ExportLib(aidge_core.OperatorImpl):
             else:
                 # Equivalent to aidge_core.register_ConvOp("ExportLibX", ExportLibX)
                 aidge_core.__getattribute__(register_func)(cls._name, cls)
-                aidge_core.Log.info(f"Registring operator {type} to {cls._name}")
             return Wrapper
         return decorator
 
@@ -100,7 +98,6 @@ class ExportLib(aidge_core.OperatorImpl):
                 cls._export_node_registry[type] = []
 
             cls._export_node_registry[type].append((spec, operator))
-            aidge_core.Log.info(f"Registring metaop {type} to {cls._name}")
             aidge_core.register_MetaOperatorOp([cls._name, type], cls)
             spec.attrs.add_attr("type", type) # MetaOperator specs need to verify the type
             return Wrapper

aidge_core/export_utils/scheduler_export.py

@@ -43,15 +43,17 @@ def scheduler_export(scheduler, export_folder_path: str, export_lib: ExportLib =
             if export_lib is not None:
                 aidge_core.Log.debug(f"Setting backend {export_lib._name} to {node.name()}[{node.type()}].")
                 node.get_operator().set_backend(export_lib._name)
-            elif not isinstance(op_impl, ExportLib):
+
+            op_impl = node.get_operator().get_impl()
+            if op_impl is None:
+                raise RuntimeError(f"Operator {node.name()}[{node.type()}] doesn't have an implementation.")
+            if not isinstance(op_impl, ExportLib):
                 raise RuntimeError(f"Operator {node.name()}[{node.type()}] doesn't have an exportable backend ({op_impl}).")
 
             is_input = node in graphview.get_input_nodes()
             is_output = node in graphview.get_output_nodes()
 
-            op_impl = node.get_operator().get_impl()
-            if op_impl is None:
-                raise RuntimeError(f"Operator {node.name()}[{node.type()}] doesn't have an implementation.")
+
             required_specs = op_impl.get_required_spec()
             specs = op_impl.get_best_match(required_specs)
             export_node = op_impl.get_export_node(specs)

src/backend/OperatorImpl.cpp

@@ -124,7 +124,6 @@ Aidge::ImplSpec Aidge::OperatorImpl::getBestMatch(const ImplSpec& requiredSpecs)
                 name = attrName.substr(0, (qualifierPos - attrName.begin()));
                 qualifier = attrName.substr((qualifierPos - attrName.begin())+1);
             }
-            fmt::println("{} : {}", name, qualifier);
             const bool mandatory = (qualifier == "!");
             if (mandatory) {
                 // Required attribute:

src/operator/MetaOperator.cpp

@@ -77,7 +77,6 @@ std::string Aidge::MetaOperator_Op::backend() const noexcept {
 }
 
 void Aidge::MetaOperator_Op::setBackend(const std::string &name, Aidge::DeviceIdx_t device) {
-    fmt::println("Setting backend {} for {}", name, type());
     if (Registrar<MetaOperator_Op>::exists({name, type()})) {
         // A custom implementation exists for this meta operator
         mImpl = Registrar<MetaOperator_Op>::create({name, type()})(*this);