decorator and precommit recipe

Author: jafranc

.hooks/pre-commit.example

@@ -0,0 +1,20 @@
+#!/bin/bash -e
+
+function run_precommit_checks
+{
+	python -m mypy --config-file ./.mypy.ini --check-untyped-defs $1
+	python -m ruff check --unsafe-fixes --config .ruff.toml $1
+	python -m yapf -r -i --style .style.yapf $1
+	
+	return 0
+}
+
+		
+source ${ENV_PYTHON_PATH}/bin/activate
+
+sphinx-build -b html docs/ docs/_build -W
+for file in $(git diff --name-only --cached | grep py)
+do
+	run_precommit_checks $file
+done
+	

geos-utils/src/geos/utils/details.py

@@ -1,55 +1,66 @@
 import logging
 from geos.utils.Logger import Logger, getLogger
 from functools import wraps
-from typing import Type, TypeVar
-
+from typing import Type, TypeVar, Callable, Protocol, Any
 
 __doc__ = """
-  Decorators
+  Group of decorators and Protocols that will be used in filters to wrap behaviors without code replication
 
 """
 
-def addLogSupport(loggerTitle : str):
-    T = TypeVar('T')
-    def decorator(cls:Type[T]) -> Type[T]:
-        original_init = cls.__init__
 
-        @wraps(cls)
-        def new_init(self : T, *args, **kwargs):
+class HasLogger( Protocol ):
+    """Protocol for classes that have logging support."""
+
+    logger: Logger
+
+    def setLoggerHandler( self, handler: logging.Handler ) -> None:
+        """Set a specific handler for the filter logger.
+
+        In this filter 4 log levels are use, .info, .error, .warning and .critical, be sure to have at least the same 4 levels.
+
+        Args:
+            handler (logging.Handler): The handler to add.
+        """
+        pass
+
 
-            self.logger : Logger
+T = TypeVar( 'T', bound='HasLogger' )
 
-            if kwargs.get('speHandler'):
-                kwargs.pop('speHandler')
+
+def addLogSupport( loggerTitle: str ) -> Callable[ [ Type[ T ] ], Type[ T ] ]:
+    """Decorator to add logger support in the class following existing architecture.
+
+    Args:
+        loggerTitle (str): Title to display in the logger
+    """
+
+    def decorator( cls: Type[ T ] ) -> Type[ T ]:
+        original_init = cls.__init__
+
+        @wraps( original_init )
+        def new_init( self: T, *args: Any, **kwargs: Any ) -> None:
+            spe_handler = kwargs.pop( 'speHandler', False )
+            if spe_handler:
                 self.logger = logging.getLogger( loggerTitle )
                 self.logger.setLevel( logging.INFO )
             else:
-                self.logger = getLogger( loggerTitle, True)
-
-            original_init(self,*args,*kwargs)
-
-        @property
-        def logger(self : T)->Logger:
-            return self.logger
-        
-        def setLoggerHandler(self, handler : logging.Handler):
-            """Set a specific handler for the filter logger.
+                self.logger = getLogger( loggerTitle, True )
 
-            In this filter 4 log levels are use, .info, .error, .warning and .critical, be sure to have at least the same 4 levels.
+            original_init( self, *args, **kwargs )
 
-            Args:
-                handler (logging.Handler): The handler to add.
-            """
-            if not self.logger.hasHandlers():
+        def setLoggerHandler( self: T, handler: logging.Handler ) -> None:
+            # No docstring needed - Protocol defines the contract
+            if not self.logger.handlers:
                 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."
                 )
 
-        cls.__init__ = new_init
-        cls.setLoggerHandler = setLoggerHandler     
+        cls.__init__ = new_init  # type: ignore[assignment]
+        cls.setLoggerHandler = setLoggerHandler  # type: ignore[assignment]
 
         return cls
 
-    return decorator
+    return decorator