V6.0.2

Author: ddc

.github/workflows/workflow.yml

@@ -17,13 +17,11 @@ jobs:
       - uses: astral-sh/ruff-action@v3
         with:
           args: "check"
-      - uses: astral-sh/ruff-action@v3
-        with:
-          args: "format --check"
 
   test:
     name: Test Python ${{ matrix.python-version }} on ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
+    needs: lint
     strategy:
       fail-fast: false
       matrix:
@@ -66,7 +64,7 @@ jobs:
   build:
     name: Build Package
     runs-on: ubuntu-latest
-    needs: [lint, test]
+    needs: test
     if: startsWith(github.ref, 'refs/tags/v')
     steps:
       - uses: actions/checkout@v6

pythonLogs/basic_log.py

@@ -5,7 +5,7 @@
 from pythonLogs.core.thread_safety import auto_thread_safe
 
 
-@auto_thread_safe(['init'])
+@auto_thread_safe(["init"])
 class BasicLog:
     """Basic logger with context manager support for automatic resource cleanup."""
 
@@ -48,13 +48,13 @@ def init(self):
 
     def __enter__(self):
         """Context manager entry."""
-        if not hasattr(self, 'logger') or self.logger is None:
+        if not hasattr(self, "logger") or self.logger is None:
             self.init()
         return self.logger
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Context manager exit with automatic cleanup."""
-        if hasattr(self, 'logger'):
+        if hasattr(self, "logger"):
             cleanup_logger_handlers(self.logger)
 
     @staticmethod

pythonLogs/core/factory.py

@@ -215,7 +215,7 @@ def get_memory_limits(cls) -> dict[str, int]:
             Dictionary with current max_loggers and ttl_seconds settings
         """
         with cls._registry_lock:
-            return {'max_loggers': cls._max_loggers, 'ttl_seconds': cls._logger_ttl}
+            return {"max_loggers": cls._max_loggers, "ttl_seconds": cls._logger_ttl}
 
     @staticmethod
     def create_logger(logger_type: LoggerType | str, config: LoggerConfig | None = None, **kwargs) -> logging.Logger:
@@ -248,20 +248,20 @@ def create_logger(logger_type: LoggerType | str, config: LoggerConfig | None = N
 
         # Create a new config with kwargs overriding config values
         final_config = LoggerConfig(
-            level=kwargs.get('level', config.level),
-            name=kwargs.get('name', config.name),
-            directory=kwargs.get('directory', config.directory),
-            filenames=kwargs.get('filenames', config.filenames),
-            encoding=kwargs.get('encoding', config.encoding),
-            datefmt=kwargs.get('datefmt', config.datefmt),
-            timezone=kwargs.get('timezone', config.timezone),
-            streamhandler=kwargs.get('streamhandler', config.streamhandler),
-            showlocation=kwargs.get('showlocation', config.showlocation),
-            maxmbytes=kwargs.get('maxmbytes', config.maxmbytes),
-            when=kwargs.get('when', config.when),
-            sufix=kwargs.get('sufix', config.sufix),
-            rotateatutc=kwargs.get('rotateatutc', config.rotateatutc),
-            daystokeep=kwargs.get('daystokeep', config.daystokeep),
+            level=kwargs.get("level", config.level),
+            name=kwargs.get("name", config.name),
+            directory=kwargs.get("directory", config.directory),
+            filenames=kwargs.get("filenames", config.filenames),
+            encoding=kwargs.get("encoding", config.encoding),
+            datefmt=kwargs.get("datefmt", config.datefmt),
+            timezone=kwargs.get("timezone", config.timezone),
+            streamhandler=kwargs.get("streamhandler", config.streamhandler),
+            showlocation=kwargs.get("showlocation", config.showlocation),
+            maxmbytes=kwargs.get("maxmbytes", config.maxmbytes),
+            when=kwargs.get("when", config.when),
+            sufix=kwargs.get("sufix", config.sufix),
+            rotateatutc=kwargs.get("rotateatutc", config.rotateatutc),
+            daystokeep=kwargs.get("daystokeep", config.daystokeep),
         )
 
         # Convert enum values to strings for logger classes

pythonLogs/core/log_utils.py

@@ -24,13 +24,13 @@ def init(self) -> None: ...
 
     def __enter__(self):
         """Context manager entry."""
-        if not hasattr(self, 'logger') or self.logger is None:
+        if not hasattr(self, "logger") or self.logger is None:
             self.init()
         return self.logger
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Context manager exit with automatic cleanup."""
-        if hasattr(self, 'logger'):
+        if hasattr(self, "logger"):
             cleanup_logger_handlers(self.logger)
 
     @staticmethod

pythonLogs/core/memory_utils.py

@@ -126,13 +126,13 @@ def get_memory_stats() -> dict[str, Any]:
     directory_stats = log_utils.get_directory_cache_stats()
 
     return {
-        'registry_size': registry_size,
-        'formatter_cache_size': formatter_cache_size,
-        'directory_cache_size': directory_stats['cached_directories'],
-        'active_logger_count': get_active_logger_count(),
-        'max_registry_size': factory_limits['max_loggers'],
-        'max_formatter_cache': _max_formatters,
-        'max_directory_cache': directory_stats['max_directories'],
+        "registry_size": registry_size,
+        "formatter_cache_size": formatter_cache_size,
+        "directory_cache_size": directory_stats["cached_directories"],
+        "active_logger_count": get_active_logger_count(),
+        "max_registry_size": factory_limits["max_loggers"],
+        "max_formatter_cache": _max_formatters,
+        "max_directory_cache": directory_stats["max_directories"],
     }
 
 
@@ -173,7 +173,7 @@ def force_garbage_collection() -> dict[str, int]:
     collected = gc.collect()
 
     return {
-        'objects_collected': collected,
-        'garbage_count': len(gc.garbage),
-        'reference_cycles': gc.get_count(),
+        "objects_collected": collected,
+        "garbage_count": len(gc.garbage),
+        "reference_cycles": gc.get_count(),
     }

pythonLogs/core/thread_safety.py

@@ -3,7 +3,7 @@
 from collections.abc import Callable
 from typing import Any, TypeVar
 
-F = TypeVar('F', bound=Callable[..., Any])
+F = TypeVar("F", bound=Callable[..., Any])
 
 
 class ThreadSafeMeta(type):
@@ -14,20 +14,20 @@ def __new__(mcs, name: str, bases: tuple, namespace: dict[str, Any], **kwargs):
         cls = super().__new__(mcs, name, bases, namespace)
 
         # Add a class-level lock if not already present
-        if not hasattr(cls, '_lock'):
+        if not hasattr(cls, "_lock"):
             cls._lock = threading.RLock()
 
         # Get methods that should be thread-safe (exclude private/dunder methods)
-        thread_safe_methods = getattr(cls, '_thread_safe_methods', None)
+        thread_safe_methods = getattr(cls, "_thread_safe_methods", None)
         if thread_safe_methods is None:
             # Auto-detect public methods that modify state
             thread_safe_methods = [
                 method_name
                 for method_name in namespace
                 if (
                     callable(getattr(cls, method_name, None))
-                    and not method_name.startswith('_')
-                    and method_name not in ['__enter__', '__exit__', '__init__']
+                    and not method_name.startswith("_")
+                    and method_name not in ["__enter__", "__exit__", "__init__"]
                 )
             ]
 
@@ -48,10 +48,10 @@ def thread_safe(func: F) -> F:
     @functools.wraps(func)
     def wrapper(self, *args, **kwargs):
         # Use instance lock if available, otherwise class lock
-        lock = getattr(self, '_lock', None)
+        lock = getattr(self, "_lock", None)
         if lock is None:
             # Check if class has lock, if not create one
-            if not hasattr(self.__class__, '_lock'):
+            if not hasattr(self.__class__, "_lock"):
                 self.__class__._lock = threading.RLock()
             lock = self.__class__._lock
 
@@ -68,22 +68,22 @@ def _get_wrappable_methods(cls: type) -> list:
         for method_name in dir(cls)
         if (
             callable(getattr(cls, method_name, None))
-            and not method_name.startswith('_')
-            and method_name not in ['__enter__', '__exit__', '__init__']
+            and not method_name.startswith("_")
+            and method_name not in ["__enter__", "__exit__", "__init__"]
         )
     ]
 
 
 def _ensure_class_has_lock(cls: type) -> None:
     """Ensure the class has a lock attribute."""
-    if not hasattr(cls, '_lock'):
+    if not hasattr(cls, "_lock"):
         cls._lock = threading.RLock()
 
 
 def _should_wrap_method(cls: type, method_name: str, original_method: Any) -> bool:
     """Check if a method should be wrapped with thread safety."""
     return (
-        hasattr(cls, method_name) and callable(original_method) and not hasattr(original_method, '_thread_safe_wrapped')
+        hasattr(cls, method_name) and callable(original_method) and not hasattr(original_method, "_thread_safe_wrapped")
     )
 
 
@@ -117,21 +117,21 @@ class AutoThreadSafe:
     """Base class that provides automatic thread safety for all public methods."""
 
     def __init__(self):
-        if not hasattr(self, '_lock'):
+        if not hasattr(self, "_lock"):
             self._lock = threading.RLock()
 
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
 
         # Add class-level lock
-        if not hasattr(cls, '_lock'):
+        if not hasattr(cls, "_lock"):
             cls._lock = threading.RLock()
 
         # Auto-wrap public methods
         for attr_name in dir(cls):
-            if not attr_name.startswith('_'):
+            if not attr_name.startswith("_"):
                 attr = getattr(cls, attr_name)
-                if callable(attr) and not hasattr(attr, '_thread_safe_wrapped'):
+                if callable(attr) and not hasattr(attr, "_thread_safe_wrapped"):
                     wrapped_attr = thread_safe(attr)
                     wrapped_attr._thread_safe_wrapped = True
                     setattr(cls, attr_name, wrapped_attr)

pythonLogs/size_rotating.py

@@ -20,7 +20,7 @@
 from pythonLogs.core.thread_safety import auto_thread_safe
 
 
-@auto_thread_safe(['init'])
+@auto_thread_safe(["init"])
 class SizeRotatingLog(RotatingLogMixin):
     """Size-based rotating logger with context manager support for automatic resource cleanup."""
 

pythonLogs/timed_rotating.py

@@ -16,7 +16,7 @@
 from pythonLogs.core.thread_safety import auto_thread_safe
 
 
-@auto_thread_safe(['init'])
+@auto_thread_safe(["init"])
 class TimedRotatingLog(RotatingLogMixin):
     """
     Time-based rotating logger with context manager support for automatic resource cleanup.

tests/context_management/test_context_managers.py

@@ -71,7 +71,7 @@ def test_size_rotating_context_manager(self):
             assert logger.level == logging.DEBUG
 
             # Should have file handlers
-            file_handlers = [h for h in logger.handlers if hasattr(h, 'baseFilename')]
+            file_handlers = [h for h in logger.handlers if hasattr(h, "baseFilename")]
             assert len(file_handlers) > 0
 
             # Test logging
@@ -98,7 +98,7 @@ def test_timed_rotating_context_manager(self):
             assert logger.level == logging.WARNING
 
             # Should have file handlers
-            file_handlers = [h for h in logger.handlers if hasattr(h, 'baseFilename')]
+            file_handlers = [h for h in logger.handlers if hasattr(h, "baseFilename")]
             assert len(file_handlers) > 0
 
             # Test logging
@@ -134,7 +134,7 @@ def test_context_manager_without_init(self):
 
         with logger_instance as logger:
             # Context manager should have called init()
-            assert hasattr(logger_instance, 'logger')
+            assert hasattr(logger_instance, "logger")
             assert logger_instance.logger is not None
             assert isinstance(logger, logging.Logger)
             logger.info("Test message")
@@ -148,7 +148,7 @@ def test_context_manager_with_existing_init(self):
 
         # Call init() manually first
         manual_logger = logger_instance.init()
-        assert hasattr(logger_instance, 'logger')
+        assert hasattr(logger_instance, "logger")
 
         with logger_instance as context_logger:
             # Should return the same logger
@@ -167,7 +167,7 @@ def test_multiple_file_handlers_cleanup(self):
             name=logger_name, directory=self.temp_dir, filenames=multiple_files, maxmbytes=1
         ) as logger:
             # Should have multiple file handlers
-            file_handlers = [h for h in logger.handlers if hasattr(h, 'baseFilename')]
+            file_handlers = [h for h in logger.handlers if hasattr(h, "baseFilename")]
             assert len(file_handlers) == len(multiple_files)
 
             logger.info("Test message to multiple files")
@@ -188,7 +188,7 @@ def test_stream_handler_cleanup(self):
         ) as logger:
             # Should have both file and stream handlers
             stream_handlers = [h for h in logger.handlers if isinstance(h, logging.StreamHandler)]
-            file_handlers = [h for h in logger.handlers if hasattr(h, 'baseFilename')]
+            file_handlers = [h for h in logger.handlers if hasattr(h, "baseFilename")]
 
             assert len(stream_handlers) > 0
             assert len(file_handlers) > 0

tests/context_management/test_resource_management.py

@@ -165,7 +165,7 @@ def test_registry_clear_with_file_handlers(self):
         logger.info("Test message before cleanup")
 
         # Verify we have multiple handlers
-        file_handlers = [h for h in logger.handlers if hasattr(h, 'baseFilename')]
+        file_handlers = [h for h in logger.handlers if hasattr(h, "baseFilename")]
         stream_handlers = [h for h in logger.handlers if isinstance(h, logging.StreamHandler)]
 
         assert len(file_handlers) == 2  # Two file handlers