pythonLogs 4.0.4__tar.gz → 4.0.6__tar.gz

{pythonlogs-4.0.4 → pythonlogs-4.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pythonLogs
-Version: 4.0.4
+Version: 4.0.6
 Summary: High-performance Python logging library with file rotation and optimized caching for better performance
 License: MIT
 Keywords: python3,python-3,python,log,logging,logger,logutils,log-utils,pythonLogs
@@ -21,7 +21,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: pydantic (>=2.11.7,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.10.1,<3.0.0)
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Project-URL: Homepage, https://pypi.org/project/pythonLogs
@@ -35,8 +34,10 @@ Description-Content-Type: text/markdown
 [![PyPi](https://img.shields.io/pypi/v/pythonLogs.svg)](https://pypi.python.org/pypi/pythonLogs)
 [![PyPI Downloads](https://static.pepy.tech/badge/pythonLogs)](https://pepy.tech/projects/pythonLogs)
 [![codecov](https://codecov.io/gh/ddc/pythonLogs/graph/badge.svg?token=QsjwsmYzgD)](https://codecov.io/gh/ddc/pythonLogs)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![CI/CD Pipeline](https://github.com/ddc/pythonLogs/actions/workflows/workflow.yml/badge.svg)](https://github.com/ddc/pythonLogs/actions/workflows/workflow.yml)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=ddc_pythonLogs&metric=alert_status)](https://sonarcloud.io/dashboard?id=ddc_pythonLogs)  
 [![Build Status](https://img.shields.io/endpoint.svg?url=https%3A//actions-badge.atrox.dev/ddc/pythonLogs/badge?ref=main&label=build&logo=none)](https://actions-badge.atrox.dev/ddc/pythonLogs/goto?ref=main)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 [![Python](https://img.shields.io/pypi/pyversions/pythonLogs.svg)](https://www.python.org/downloads)
 
 [![Support me on GitHub](https://img.shields.io/badge/Support_me_on_GitHub-154c79?style=for-the-badge&logo=github)](https://github.com/sponsors/ddc)

{pythonlogs-4.0.4 → pythonlogs-4.0.6}/README.md

@@ -5,8 +5,10 @@
 [![PyPi](https://img.shields.io/pypi/v/pythonLogs.svg)](https://pypi.python.org/pypi/pythonLogs)
 [![PyPI Downloads](https://static.pepy.tech/badge/pythonLogs)](https://pepy.tech/projects/pythonLogs)
 [![codecov](https://codecov.io/gh/ddc/pythonLogs/graph/badge.svg?token=QsjwsmYzgD)](https://codecov.io/gh/ddc/pythonLogs)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![CI/CD Pipeline](https://github.com/ddc/pythonLogs/actions/workflows/workflow.yml/badge.svg)](https://github.com/ddc/pythonLogs/actions/workflows/workflow.yml)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=ddc_pythonLogs&metric=alert_status)](https://sonarcloud.io/dashboard?id=ddc_pythonLogs)  
 [![Build Status](https://img.shields.io/endpoint.svg?url=https%3A//actions-badge.atrox.dev/ddc/pythonLogs/badge?ref=main&label=build&logo=none)](https://actions-badge.atrox.dev/ddc/pythonLogs/goto?ref=main)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 [![Python](https://img.shields.io/pypi/pyversions/pythonLogs.svg)](https://www.python.org/downloads)
 
 [![Support me on GitHub](https://img.shields.io/badge/Support_me_on_GitHub-154c79?style=for-the-badge&logo=github)](https://github.com/sponsors/ddc)

{pythonlogs-4.0.4 → pythonlogs-4.0.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pythonLogs"
-version = "4.0.4"
+version = "4.0.6"
 description = "High-performance Python logging library with file rotation and optimized caching for better performance"
 license = "MIT"
 readme = "README.md"
@@ -32,7 +32,6 @@ classifiers = [
 
 [tool.poetry.dependencies]
 python = "^3.10"
-pydantic = "^2.11.7"
 pydantic-settings = "^2.10.1"
 python-dotenv = "^1.1.1"
 

{pythonlogs-4.0.4 → pythonlogs-4.0.6}/pythonLogs/basic_log.py

@@ -34,7 +34,14 @@ class BasicLog:
         logger.setLevel(self.level)
         logging.Formatter.converter = get_timezone_function(self.timezone)
         _format = get_format(self.showlocation, self.appname, self.timezone)
-        logging.basicConfig(datefmt=self.datefmt, encoding=self.encoding, format=_format)
+        
+        # Only add handler if logger doesn't have any handlers
+        if not logger.handlers:
+            handler = logging.StreamHandler()
+            formatter = logging.Formatter(_format, datefmt=self.datefmt)
+            handler.setFormatter(formatter)
+            logger.addHandler(handler)
+        
         self.logger = logger
         # Register weak reference for memory tracking
         register_logger_weakref(logger)

{pythonlogs-4.0.4 → pythonlogs-4.0.6}/pythonLogs/constants.py

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8 -*-
+import logging
 from enum import Enum
 
 # File and Directory Constants
@@ -40,3 +41,15 @@ class RotateWhen(str, Enum):
     SUNDAY = "W6"
     HOURLY = "H"
     DAILY = "D"
+
+
+# Level mapping for performance optimization
+LEVEL_MAP = {
+    LogLevel.DEBUG.value.lower(): logging.DEBUG,
+    LogLevel.WARNING.value.lower(): logging.WARNING,
+    LogLevel.WARN.value.lower(): logging.WARNING,
+    LogLevel.ERROR.value.lower(): logging.ERROR,
+    LogLevel.CRITICAL.value.lower(): logging.CRITICAL,
+    LogLevel.CRIT.value.lower(): logging.CRITICAL,
+    LogLevel.INFO.value.lower(): logging.INFO,
+}

{pythonlogs-4.0.4 → pythonlogs-4.0.6}/pythonLogs/factory.py

@@ -3,6 +3,7 @@ import atexit
 import logging
 import threading
 import time
+from dataclasses import dataclass
 from enum import Enum
 from typing import Dict, Optional, Tuple, Union
 from pythonLogs.basic_log import BasicLog
@@ -12,6 +13,25 @@ from pythonLogs.size_rotating import SizeRotatingLog
 from pythonLogs.timed_rotating import TimedRotatingLog
 
 
+@dataclass
+class LoggerConfig:
+    """Configuration class to group logger parameters"""
+    level: Optional[Union[LogLevel, str]] = None
+    name: Optional[str] = None
+    directory: Optional[str] = None
+    filenames: Optional[list | tuple] = None
+    encoding: Optional[str] = None
+    datefmt: Optional[str] = None
+    timezone: Optional[str] = None
+    streamhandler: Optional[bool] = None
+    showlocation: Optional[bool] = None
+    maxmbytes: Optional[int] = None
+    when: Optional[Union[RotateWhen, str]] = None
+    sufix: Optional[str] = None
+    rotateatutc: Optional[bool] = None
+    daystokeep: Optional[int] = None
+
+
 class LoggerType(str, Enum):
     """Available logger types"""
     BASIC = "basic"
@@ -80,7 +100,7 @@ class LoggerFactory:
 
             # Check if logger already exists in the registry
             if name in cls._logger_registry:
-                logger, timestamp = cls._logger_registry[name]
+                logger, _ = cls._logger_registry[name]
                 # Update timestamp for LRU tracking
                 cls._logger_registry[name] = (logger, time.time())
                 return logger
@@ -189,21 +209,8 @@ class LoggerFactory:
     @staticmethod
     def create_logger(
         logger_type: Union[LoggerType, str],
-        level: Optional[Union[LogLevel, str]] = None,
-        name: Optional[str] = None,
-        directory: Optional[str] = None,
-        filenames: Optional[list | tuple] = None,
-        encoding: Optional[str] = None,
-        datefmt: Optional[str] = None,
-        timezone: Optional[str] = None,
-        streamhandler: Optional[bool] = None,
-        showlocation: Optional[bool] = None,  # Size rotating specific
-        maxmbytes: Optional[int] = None,  # Timed rotating specific
-        when: Optional[Union[RotateWhen, str]] = None,
-        sufix: Optional[str] = None,
-        rotateatutc: Optional[bool] = None,
-        # Common
-        daystokeep: Optional[int] = None,
+        config: Optional[LoggerConfig] = None,
+        **kwargs
     ) -> logging.Logger:
 
         """
@@ -211,20 +218,8 @@ class LoggerFactory:
         
         Args:
             logger_type: Type of logger to create (LoggerType enum or string)
-            level: Log level (LogLevel enum or string: DEBUG, INFO, WARNING, ERROR, CRITICAL)
-            name: Logger name
-            directory: Log directory path
-            filenames: List/tuple of log filenames
-            encoding: File encoding
-            datefmt: Date format string
-            timezone: Timezone for timestamps
-            streamhandler: Enable console output
-            showlocation: Show file location in logs
-            maxmbytes: Max file size in MB (size rotating only)
-            when: When to rotate (RotateWhen enum or string: MIDNIGHT, HOURLY, DAILY, etc.)
-            sufix: Date suffix for rotated files (timed rotating only)
-            rotateatutc: Rotate at UTC time (timed rotating only)
-            daystokeep: Days to keep old logs
+            config: LoggerConfig object with logger parameters
+            **kwargs: Individual logger parameters (for backward compatibility)
             
         Returns:
             Configured logger instance
@@ -239,50 +234,72 @@ class LoggerFactory:
             except ValueError:
                 raise ValueError(f"Invalid logger type: {logger_type}. Valid types: {[t.value for t in LoggerType]}")
 
+        # Merge config and kwargs (kwargs take precedence for backward compatibility)
+        if config is None:
+            config = LoggerConfig()
+        
+        # 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)
+        )
+
         # Convert enum values to strings for logger classes
-        level_str = level.value if isinstance(level, LogLevel) else level
-        when_str = when.value if isinstance(when, RotateWhen) else when
+        level_str = final_config.level.value if isinstance(final_config.level, LogLevel) else final_config.level
+        when_str = final_config.when.value if isinstance(final_config.when, RotateWhen) else final_config.when
 
         # Create logger based on type
         match logger_type:
             case LoggerType.BASIC:
                 logger_instance = BasicLog(
                     level=level_str,
-                    name=name,
-                    encoding=encoding,
-                    datefmt=datefmt,
-                    timezone=timezone,
-                    showlocation=showlocation, )
+                    name=final_config.name,
+                    encoding=final_config.encoding,
+                    datefmt=final_config.datefmt,
+                    timezone=final_config.timezone,
+                    showlocation=final_config.showlocation, )
 
             case LoggerType.SIZE_ROTATING:
                 logger_instance = SizeRotatingLog(
                     level=level_str,
-                    name=name,
-                    directory=directory,
-                    filenames=filenames,
-                    maxmbytes=maxmbytes,
-                    daystokeep=daystokeep,
-                    encoding=encoding,
-                    datefmt=datefmt,
-                    timezone=timezone,
-                    streamhandler=streamhandler,
-                    showlocation=showlocation, )
+                    name=final_config.name,
+                    directory=final_config.directory,
+                    filenames=final_config.filenames,
+                    maxmbytes=final_config.maxmbytes,
+                    daystokeep=final_config.daystokeep,
+                    encoding=final_config.encoding,
+                    datefmt=final_config.datefmt,
+                    timezone=final_config.timezone,
+                    streamhandler=final_config.streamhandler,
+                    showlocation=final_config.showlocation, )
 
             case LoggerType.TIMED_ROTATING:
                 logger_instance = TimedRotatingLog(
                     level=level_str,
-                    name=name,
-                    directory=directory,
-                    filenames=filenames,
+                    name=final_config.name,
+                    directory=final_config.directory,
+                    filenames=final_config.filenames,
                     when=when_str,
-                    sufix=sufix,
-                    daystokeep=daystokeep,
-                    encoding=encoding,
-                    datefmt=datefmt,
-                    timezone=timezone,
-                    streamhandler=streamhandler,
-                    showlocation=showlocation,
-                    rotateatutc=rotateatutc, )
+                    sufix=final_config.sufix,
+                    daystokeep=final_config.daystokeep,
+                    encoding=final_config.encoding,
+                    datefmt=final_config.datefmt,
+                    timezone=final_config.timezone,
+                    streamhandler=final_config.streamhandler,
+                    showlocation=final_config.showlocation,
+                    rotateatutc=final_config.rotateatutc, )
 
             case _:
                 raise ValueError(f"Unsupported logger type: {logger_type}")

{pythonlogs-4.0.4 → pythonlogs-4.0.6}/pythonLogs/log_utils.py

@@ -12,7 +12,7 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Callable, Set
 from zoneinfo import ZoneInfo
-from pythonLogs.constants import DEFAULT_FILE_MODE, LogLevel
+from pythonLogs.constants import DEFAULT_FILE_MODE, LEVEL_MAP
 
 
 # Global cache for checked directories with thread safety and size limits
@@ -182,17 +182,7 @@ def get_level(level: str) -> int:
         write_stderr(f"Unable to get log level. Setting default level to: 'INFO' ({logging.INFO})")
         return logging.INFO
 
-    level_map = {
-        LogLevel.DEBUG.value.lower(): logging.DEBUG,
-        LogLevel.WARNING.value.lower(): logging.WARNING,
-        LogLevel.WARN.value.lower(): logging.WARNING,
-        LogLevel.ERROR.value.lower(): logging.ERROR,
-        LogLevel.CRITICAL.value.lower(): logging.CRITICAL,
-        LogLevel.CRIT.value.lower(): logging.CRITICAL,
-        LogLevel.INFO.value.lower(): logging.INFO,
-    }
-
-    return level_map.get(level.lower(), logging.INFO)
+    return LEVEL_MAP.get(level.lower(), logging.INFO)
 
 
 def get_log_path(directory: str, filename: str) -> str:

{pythonlogs-4.0.4 → pythonlogs-4.0.6}/pythonLogs/settings.py

@@ -11,7 +11,7 @@ from pythonLogs.constants import (
     DEFAULT_ROTATE_SUFFIX,
     DEFAULT_TIMEZONE,
     LogLevel,
-    RotateWhen
+    RotateWhen,
 )
 
 

{pythonlogs-4.0.4 → pythonlogs-4.0.6}/pythonLogs/thread_safety.py

@@ -1,7 +1,8 @@
 # -*- encoding: utf-8 -*-
 import functools
 import threading
-from typing import Any, Callable, Dict, TypeVar, Type
+from typing import Any, Callable, Dict, Type, TypeVar
+
 
 F = TypeVar('F', bound=Callable[..., Any])
 
@@ -58,34 +59,49 @@ def thread_safe(func: F) -> F:
     return wrapper
 
 
+def _get_wrappable_methods(cls: Type) -> list:
+    """Helper function to get methods that should be made thread-safe."""
+    return [
+        method_name 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__'])
+    ]
+
+
+def _ensure_class_has_lock(cls: Type) -> None:
+    """Ensure the class has a lock attribute."""
+    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'))
+
+
 def auto_thread_safe(thread_safe_methods: list = None):
     """Class decorator that adds automatic thread safety to specified methods."""
     
     def decorator(cls: Type) -> Type:
-        # Add lock to class if not present
-        if not hasattr(cls, '_lock'):
-            cls._lock = threading.RLock()
+        _ensure_class_has_lock(cls)
         
         # Store thread-safe methods list
         if thread_safe_methods:
             cls._thread_safe_methods = thread_safe_methods
         
         # Get methods to make thread-safe
-        methods_to_wrap = thread_safe_methods or [
-            method_name 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__'])
-        ]
+        methods_to_wrap = thread_safe_methods or _get_wrappable_methods(cls)
         
         # Wrap each method
         for method_name in methods_to_wrap:
-            if hasattr(cls, method_name):
-                original_method = getattr(cls, method_name)
-                if callable(original_method) and not hasattr(original_method, '_thread_safe_wrapped'):
-                    wrapped_method = thread_safe(original_method)
-                    wrapped_method._thread_safe_wrapped = True
-                    setattr(cls, method_name, wrapped_method)
+            original_method = getattr(cls, method_name, None)
+            if _should_wrap_method(cls, method_name, original_method):
+                wrapped_method = thread_safe(original_method)
+                wrapped_method._thread_safe_wrapped = True
+                setattr(cls, method_name, wrapped_method)
         
         return cls
     
@@ -132,4 +148,4 @@ class ThreadSafeContext:
         return self
     
     def __exit__(self, exc_type, exc_val, exc_tb):
-        self.lock.release()
+        self.lock.release()

{pythonlogs-4.0.4 → pythonlogs-4.0.6}/pythonLogs/timed_rotating.py

@@ -10,7 +10,7 @@ from pythonLogs.log_utils import (
     get_logger_and_formatter,
     get_stream_handler,
     gzip_file_with_sufix,
-    remove_old_logs,
+     remove_old_logs,
 )
 from pythonLogs.memory_utils import cleanup_logger_handlers, register_logger_weakref
 from pythonLogs.settings import get_log_settings