feat: Update the log of the filter to get the number of warnings at the end of the calculation

geos-processing/src/geos/processing/generic_processing_tools/AttributeMapping.py

@@ -9,7 +9,7 @@
 from vtkmodules.vtkCommonDataModel import vtkDataSet, vtkMultiBlockDataSet
 from geos.mesh.utils.arrayModifiers import transferAttributeWithElementMap
 from geos.mesh.utils.arrayHelpers import ( computeElementMapping, getAttributeSet, isAttributeGlobal )
-from geos.utils.Logger import ( Logger, getLogger )
+from geos.utils.Logger import ( getLogger, Logger, CountWarningHandler, isHandlerInLogger, getLoggerHandlerType )
 from geos.utils.pieceEnum import Piece
 
 __doc__ = """
@@ -111,6 +111,18 @@ def __init__(
             self.logger.setLevel( logging.INFO )
             self.logger.propagate = False
 
+        counter: CountWarningHandler = CountWarningHandler()
+        self.counter: CountWarningHandler
+        self.nbWarnings: int = 0
+        try:
+            self.counter = getLoggerHandlerType( type( counter ), self.logger )
+            self.counter.resetWarningCount()
+        except ValueError:
+            self.counter = counter
+            self.counter.setLevel( logging.INFO )
+
+        self.logger.addHandler( self.counter )
+
     def setLoggerHandler( self: Self, handler: logging.Handler ) -> None:
         """Set a specific handler for the filter logger.
 
@@ -120,11 +132,10 @@ def setLoggerHandler( self: Self, handler: logging.Handler ) -> None:
         Args:
             handler (logging.Handler): The handler to add.
         """
-        if len( self.logger.handlers ) == 0:
+        if not isHandlerInLogger( handler, self.logger ):
             self.logger.addHandler( handler )
         else:
-            self.logger.warning( "The logger already has an handler, to use yours set the argument 'speHandler'"
-                                 " to True during the filter initialization." )
+            self.logger.warning( "The logger already has this handler, it has not be added." )
 
     def getElementMap( self: Self ) -> dict[ int, npt.NDArray[ np.int64 ] ]:
         """Getter of the element mapping dictionary.
@@ -184,14 +195,19 @@ def applyFilter( self: Self ) -> None:
             transferAttributeWithElementMap( self.meshFrom, self.meshTo, self.ElementMap, attributeName, self.piece,
                                              self.logger )
 
-        # Log the output message.
-        self._logOutputMessage()
-
-        return
+        self.logger.warning( "test" )
 
-    def _logOutputMessage( self: Self ) -> None:
-        """Create and log result messages of the filter."""
-        self.logger.info( f"The filter { self.logger.name } succeeded." )
+        # Log the output message.
         self.logger.info(
-            f"The attributes { self.attributeNames } have been transferred from the source mesh to the final mesh with the { self.piece.value } mapping."
+            f"The attributes { self.attributeNames } have been transferred from the source mesh to the final mesh with a { self.piece.value } mapping.\n"
         )
+        result: str = f"The filter { self.logger.name } succeeded"
+        if self.counter.warningCount > 0:
+            self.logger.warning( f"{ result } but { self.counter.warningCount } warnings have been logged." )
+        else:
+            self.logger.info( f"{ result }." )
+
+        self.nbWarnings = self.counter.warningCount
+        self.counter.resetWarningCount()
+
+        return

geos-processing/src/geos/processing/generic_processing_tools/ClipToMainFrame.py

@@ -16,7 +16,7 @@
 from vtkmodules.vtkCommonTransforms import vtkLandmarkTransform
 from vtkmodules.vtkFiltersGeneral import vtkTransformFilter
 
-from geos.utils.Logger import ( Logger, getLogger )
+from geos.utils.Logger import ( getLogger, Logger, CountWarningHandler, isHandlerInLogger, getLoggerHandlerType )
 from geos.mesh.utils.genericHelpers import getMultiBlockBounds
 
 __doc__ = """
@@ -212,7 +212,7 @@ def __getFramePoints( self, vpts: vtkPoints ) -> tuple[ vtkPoints, vtkPoints ]:
         return ( sourcePts, targetPts )
 
 
-loggerTitle: str = "Clip mesh to main frame."
+loggerTitle: str = "Clip mesh to main frame"
 
 
 class ClipToMainFrame( vtkTransformFilter ):
@@ -227,7 +227,8 @@ def __init__( self, speHandler: bool = False, **properties: str ) -> None:
             properties (kwargs): kwargs forwarded to vtkTransformFilter.
         """
         super().__init__( **properties )
-        # Logger.
+
+        # Logger
         self.logger: Logger
         if not speHandler:
             self.logger = getLogger( loggerTitle, True )
@@ -236,8 +237,35 @@ def __init__( self, speHandler: bool = False, **properties: str ) -> None:
             self.logger.setLevel( logging.INFO )
             self.logger.propagate = False
 
+        counter: CountWarningHandler = CountWarningHandler()
+        self.counter: CountWarningHandler
+        self.nbWarnings: int = 0
+        try:
+            self.counter = getLoggerHandlerType( type( counter ), self.logger )
+            self.counter.resetWarningCount()
+        except ValueError:
+            self.counter = counter
+            self.counter.setLevel( logging.INFO )
+
+        self.logger.addHandler( self.counter )
+
+    def Update( self ) -> None:  # type: ignore[override]
+        """Update the filter."""
+        super().Update()
+
+        result: str = f"The filter { self.logger.name } succeeded"
+        if self.counter.warningCount > 0:
+            self.logger.warning( f"{ result } but { self.counter.warningCount } warnings have been logged." )
+        else:
+            self.logger.info( f"{ result }." )
+
+        self.nbWarnings = self.counter.warningCount
+        self.counter.resetWarningCount()
+
     def ComputeTransform( self ) -> None:
         """Update the transformation."""
+        self.logger.info( f"Apply filter { self.logger.name }." )
+
         # dispatch to ClipToMainFrame depending on input type
         if isinstance( self.GetInput(), vtkMultiBlockDataSet ):
             # locate reference point
@@ -265,11 +293,10 @@ def SetLoggerHandler( self, handler: logging.Handler ) -> None:
         Args:
             handler (logging.Handler): The handler to add.
         """
-        if len( self.logger.handlers ) == 0:
+        if not isHandlerInLogger( handler, self.logger ):
             self.logger.addHandler( handler )
         else:
-            self.logger.warning( "The logger already has an handler, to use yours set the argument 'speHandler' to True"
-                                 " during the filter initialization." )
+            self.logger.warning( "The logger already has this handler, it has not be added." )
 
     def __locate_reference_point( self, multiBlockDataSet: vtkMultiBlockDataSet ) -> int:
         """Locate the block to use as reference for the transformation.

geos-processing/src/geos/processing/generic_processing_tools/CreateConstantAttributePerRegion.py

@@ -12,7 +12,7 @@
 from vtkmodules.vtkCommonDataModel import vtkMultiBlockDataSet, vtkDataSet
 
 from geos.utils.pieceEnum import Piece
-from geos.utils.Logger import ( getLogger, Logger, CountWarningHandler )
+from geos.utils.Logger import ( getLogger, Logger, CountWarningHandler, isHandlerInLogger, getLoggerHandlerType )
 from geos.mesh.utils.arrayHelpers import ( getArrayInObject, getComponentNames, getNumberOfComponents,
                                            getVtkDataTypeInObject, isAttributeGlobal, getAttributePieceInfo,
                                            checkValidValuesInDataSet, checkValidValuesInMultiBlock )
@@ -122,11 +122,7 @@ def __init__(
         # Check if the new component have default values (information for the output message).
         self.useDefaultValue: bool = False
 
-        # Warnings counter.
-        self.counter: CountWarningHandler = CountWarningHandler()
-        self.counter.setLevel( logging.INFO )
-
-        # Logger.
+        # Logger
         self.logger: Logger
         if not speHandler:
             self.logger = getLogger( loggerTitle, True )
@@ -135,6 +131,18 @@ def __init__(
             self.logger.setLevel( logging.INFO )
             self.logger.propagate = False
 
+        counter: CountWarningHandler = CountWarningHandler()
+        self.counter: CountWarningHandler
+        self.nbWarnings: int = 0
+        try:
+            self.counter = getLoggerHandlerType( type( counter ), self.logger )
+            self.counter.resetWarningCount()
+        except ValueError:
+            self.counter = counter
+            self.counter.setLevel( logging.INFO )
+
+        self.logger.addHandler( self.counter )
+
     def setLoggerHandler( self: Self, handler: logging.Handler ) -> None:
         """Set a specific handler for the filter logger.
 
@@ -144,12 +152,10 @@ def setLoggerHandler( self: Self, handler: logging.Handler ) -> None:
         Args:
             handler (logging.Handler): The handler to add.
         """
-        if len( self.logger.handlers ) == 0:
+        if not isHandlerInLogger( handler, self.logger ):
             self.logger.addHandler( handler )
         else:
-            # This warning does not count for the number of warning created during the application of the filter.
-            self.logger.warning( "The logger already has an handler, to use yours set the argument 'speHandler' to True"
-                                 " during the filter initialization." )
+            self.logger.warning( "The logger already has this handler, it has not be added." )
 
     def applyFilter( self: Self ) -> None:
         """Create a constant attribute per region in the mesh.
@@ -160,9 +166,6 @@ def applyFilter( self: Self ) -> None:
         """
         self.logger.info( f"Apply filter { self.logger.name }." )
 
-        # Add the handler to count warnings messages.
-        self.logger.addHandler( self.counter )
-
         # Check the validity of the attribute region.
         if self.piece == Piece.NONE:
             raise AttributeError( f"The attribute { self.regionName } is not in the mesh." )
@@ -342,9 +345,6 @@ def _logOutputMessage( self: Self, trueIndexes: list[ Any ] ) -> None:
         Args:
             trueIndexes (list[Any]): The list of the true region indexes use to create the attribute.
         """
-        # The Filter succeed.
-        self.logger.info( f"The filter { self.logger.name } succeeded." )
-
         # Info about the created attribute.
         # The piece where the attribute is created.
         self.logger.info( f"The new attribute { self.newAttributeName } is created on { self.piece.value }." )
@@ -409,3 +409,14 @@ def _logOutputMessage( self: Self, trueIndexes: list[ Any ] ) -> None:
                     self.logger.warning( messValue )
                 else:
                     self.logger.info( messValue )
+
+        result: str = f"The filter { self.logger.name } succeeded"
+        if self.counter.warningCount > 0:
+            self.logger.warning( f"{ result } but { self.counter.warningCount } warnings have been logged." )
+        else:
+            self.logger.info( f"{ result }." )
+
+        self.nbWarnings = self.counter.warningCount
+        self.counter.resetWarningCount()
+
+        return

geos-processing/src/geos/processing/generic_processing_tools/FillPartialArrays.py

@@ -6,7 +6,7 @@
 from typing import Union, Any
 
 from geos.utils.pieceEnum import Piece
-from geos.utils.Logger import ( Logger, getLogger )
+from geos.utils.Logger import ( getLogger, Logger, CountWarningHandler, isHandlerInLogger, getLoggerHandlerType )
 from geos.mesh.utils.arrayModifiers import fillPartialAttributes
 from geos.mesh.utils.arrayHelpers import getAttributePieceInfo
 
@@ -89,7 +89,7 @@ def __init__(
         self.multiBlockDataSet: vtkMultiBlockDataSet = multiBlockDataSet
         self.dictAttributesValues: dict[ str, Union[ list[ Any ], None ] ] = dictAttributesValues
 
-        # Logger.
+        # Logger
         self.logger: Logger
         if not speHandler:
             self.logger = getLogger( loggerTitle, True )
@@ -98,6 +98,18 @@ def __init__(
             self.logger.setLevel( logging.INFO )
             self.logger.propagate = False
 
+        counter: CountWarningHandler = CountWarningHandler()
+        self.counter: CountWarningHandler
+        self.nbWarnings: int = 0
+        try:
+            self.counter = getLoggerHandlerType( type( counter ), self.logger )
+            self.counter.resetWarningCount()
+        except ValueError:
+            self.counter = counter
+            self.counter.setLevel( logging.INFO )
+
+        self.logger.addHandler( self.counter )
+
     def setLoggerHandler( self: Self, handler: logging.Handler ) -> None:
         """Set a specific handler for the filter logger.
 
@@ -107,11 +119,10 @@ def setLoggerHandler( self: Self, handler: logging.Handler ) -> None:
         Args:
             handler (logging.Handler): The handler to add.
         """
-        if len( self.logger.handlers ) == 0:
+        if not isHandlerInLogger( handler, self.logger ):
             self.logger.addHandler( handler )
         else:
-            self.logger.warning( "The logger already has an handler, to use yours set the argument 'speHandler' to True"
-                                 " during the filter initialization." )
+            self.logger.warning( "The logger already has this handler, it has not be added." )
 
     def applyFilter( self: Self ) -> None:
         """Create a constant attribute per region in the mesh.
@@ -121,8 +132,10 @@ def applyFilter( self: Self ) -> None:
             ValueError: Error during the filling of the attribute.
         """
         self.logger.info( f"Apply filter { self.logger.name }." )
+
         piece: Piece
-        for attributeName in self.dictAttributesValues:
+        mess: str = ""
+        for attributeName, values in self.dictAttributesValues.items():
             piece = getAttributePieceInfo( self.multiBlockDataSet, attributeName )
             if piece == Piece.NONE:
                 raise AttributeError( f"The attribute { attributeName } is not in the mesh." )
@@ -134,9 +147,22 @@ def applyFilter( self: Self ) -> None:
             fillPartialAttributes( self.multiBlockDataSet,
                                    attributeName,
                                    piece=piece,
-                                   listValues=self.dictAttributesValues[ attributeName ],
+                                   listValues=values,
                                    logger=self.logger )
+            if values is None:
+                values = [ "the default value" ]
+            mess = f"{ mess }The attribute { attributeName } has been filled with { values }.\n"
+
+        # Log the output message.
+        self.logger.info( mess )
+
+        result: str = f"The filter { self.logger.name } succeeded"
+        if self.counter.warningCount > 0:
+            self.logger.warning( f"{ result } but { self.counter.warningCount } warnings have been logged." )
+        else:
+            self.logger.info( f"{ result }." )
 
-        self.logger.info( f"The filter { self.logger.name } succeed." )
+        self.nbWarnings = self.counter.warningCount
+        self.counter.resetWarningCount()
 
         return

geos-processing/src/geos/processing/generic_processing_tools/MergeBlockEnhanced.py

@@ -6,7 +6,7 @@
 
 from typing_extensions import Self
 
-from geos.utils.Logger import ( Logger, getLogger )
+from geos.utils.Logger import ( getLogger, Logger, CountWarningHandler, isHandlerInLogger, getLoggerHandlerType )
 from geos.mesh.utils.multiblockModifiers import mergeBlocks
 
 from vtkmodules.vtkCommonDataModel import vtkMultiBlockDataSet, vtkUnstructuredGrid
@@ -91,6 +91,18 @@ def __init__(
             self.logger.setLevel( logging.INFO )
             self.logger.propagate = False
 
+        counter: CountWarningHandler = CountWarningHandler()
+        self.counter: CountWarningHandler
+        self.nbWarnings: int = 0
+        try:
+            self.counter = getLoggerHandlerType( type( counter ), self.logger )
+            self.counter.resetWarningCount()
+        except ValueError:
+            self.counter = counter
+            self.counter.setLevel( logging.INFO )
+
+        self.logger.addHandler( self.counter )
+
     def setLoggerHandler( self: Self, handler: logging.Handler ) -> None:
         """Set a specific handler for the filter logger.
 
@@ -99,11 +111,10 @@ def setLoggerHandler( self: Self, handler: logging.Handler ) -> None:
         Args:
             handler (logging.Handler): The handler to add.
         """
-        if len( self.logger.handlers ) == 0:
+        if not isHandlerInLogger( handler, self.logger ):
             self.logger.addHandler( handler )
         else:
-            self.logger.warning( "The logger already has an handler, to use yours set the argument 'speHandler' to True"
-                                 " during the filter initialization." )
+            self.logger.warning( "The logger already has this handler, it has not be added." )
 
     def applyFilter( self: Self ) -> None:
         """Merge the blocks of a multiblock dataset mesh.
@@ -117,7 +128,14 @@ def applyFilter( self: Self ) -> None:
         outputMesh = mergeBlocks( self.inputMesh, keepPartialAttributes=True, logger=self.logger )
         self.outputMesh = outputMesh
 
-        self.logger.info( f"The filter { self.logger.name } succeeded." )
+        result: str = f"The filter { self.logger.name } succeeded"
+        if self.counter.warningCount > 0:
+            self.logger.warning( f"{ result } but { self.counter.warningCount } warnings have been logged." )
+        else:
+            self.logger.info( f"{ result }." )
+
+        self.nbWarnings = self.counter.warningCount
+        self.counter.resetWarningCount()
 
         return