pythonLogs 4.0.5__tar.gz → 5.0.0__tar.gz

{pythonlogs-4.0.5 → pythonlogs-5.0.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: pythonLogs
-Version: 4.0.5
+Version: 5.0.0
 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
 Author: Daniel Costa
 Author-email: danieldcsta@gmail.com
 Maintainer: Daniel Costa
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.12,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Other Environment
 Classifier: Intended Audience :: Developers
@@ -15,8 +15,6 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -34,8 +32,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)
@@ -57,10 +57,12 @@ High-performance Python logging library with file rotation and optimized caching
 - [Memory Management](#memory-management)
 - [Flexible Configuration Options](#flexible-configuration-options)
 - [Migration Guide](#migration-guide)
-- [Development](#source-code)
-- [Run Tests and Get Coverage Report using Poe](#run-tests-and-get-coverage-report-using-poe)
+- [Development](#development)
+- [Development](#development)
+  - [Building from Source](#building-from-source)
+  - [Running Tests](#running-tests)
 - [License](#license)
-- [Buy me a cup of coffee](#buy-me-a-cup-of-coffee)
+- [Support](#support)
 
 
 
@@ -547,26 +549,28 @@ timed_logger = timed_rotating_logger(level=LogLevel.WARNING, name="app", directo
 - 📚 **Centralized configuration** through factory pattern
 
 
-# Source Code
-### Build
+# Development
+
+### Building from Source
 ```shell
 poetry build -f wheel
 ```
 
-
-# Run Tests and Get Coverage Report using Poe
+### Running Tests
 ```shell
 poetry update --with test
-poe test
+poe tests
 ```
 
-
 # License
+
 Released under the [MIT License](LICENSE)
 
+# Support
+
+If you find this project helpful, consider supporting development:
 
-# Buy me a cup of coffee
-+ [GitHub Sponsor](https://github.com/sponsors/ddc)
-+ [ko-fi](https://ko-fi.com/ddcsta)
-+ [Paypal](https://www.paypal.com/ncp/payment/6G9Z78QHUD4RJ)
+- [GitHub Sponsor](https://github.com/sponsors/ddc)
+- [ko-fi](https://ko-fi.com/ddcsta)
+- [PayPal](https://www.paypal.com/ncp/payment/6G9Z78QHUD4RJ)
 

{pythonlogs-4.0.5 → pythonlogs-5.0.0}/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)
@@ -28,10 +30,12 @@ High-performance Python logging library with file rotation and optimized caching
 - [Memory Management](#memory-management)
 - [Flexible Configuration Options](#flexible-configuration-options)
 - [Migration Guide](#migration-guide)
-- [Development](#source-code)
-- [Run Tests and Get Coverage Report using Poe](#run-tests-and-get-coverage-report-using-poe)
+- [Development](#development)
+- [Development](#development)
+  - [Building from Source](#building-from-source)
+  - [Running Tests](#running-tests)
 - [License](#license)
-- [Buy me a cup of coffee](#buy-me-a-cup-of-coffee)
+- [Support](#support)
 
 
 
@@ -518,25 +522,27 @@ timed_logger = timed_rotating_logger(level=LogLevel.WARNING, name="app", directo
 - 📚 **Centralized configuration** through factory pattern
 
 
-# Source Code
-### Build
+# Development
+
+### Building from Source
 ```shell
 poetry build -f wheel
 ```
 
-
-# Run Tests and Get Coverage Report using Poe
+### Running Tests
 ```shell
 poetry update --with test
-poe test
+poe tests
 ```
 
-
 # License
+
 Released under the [MIT License](LICENSE)
 
+# Support
+
+If you find this project helpful, consider supporting development:
 
-# Buy me a cup of coffee
-+ [GitHub Sponsor](https://github.com/sponsors/ddc)
-+ [ko-fi](https://ko-fi.com/ddcsta)
-+ [Paypal](https://www.paypal.com/ncp/payment/6G9Z78QHUD4RJ)
+- [GitHub Sponsor](https://github.com/sponsors/ddc)
+- [ko-fi](https://ko-fi.com/ddcsta)
+- [PayPal](https://www.paypal.com/ncp/payment/6G9Z78QHUD4RJ)

pythonlogs-5.0.0/build.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+import compileall
+import sys
+import tomllib
+from pathlib import Path
+
+
+def parse_python_version_requirement():
+    """Parse Python version requirement from pyproject.toml"""
+    pyproject_path = Path(__file__).parent / "pyproject.toml"
+    
+    with open(pyproject_path, "rb") as f:
+        data = tomllib.load(f)
+    
+    python_req = data["tool"]["poetry"]["dependencies"]["python"]
+    
+    # Parse version constraint like "^3.12"
+    if python_req.startswith("^"):
+        min_version = python_req[1:]
+        major, minor = map(int, min_version.split("."))
+        return major, minor
+    elif python_req.startswith(">="):
+        min_version = python_req[2:]
+        major, minor = map(int, min_version.split("."))
+        return major, minor
+    else:
+        # Default fallback
+        return 3, 12
+
+
+def get_compatible_python_versions(min_major, min_minor):
+    """Generate list of compatible Python versions"""
+    versions = []
+    current_major, current_minor = sys.version_info[:2]
+    
+    # Start from the minimum required version
+    for major in range(min_major, min_major + 1):  # Only Python 3.x for now
+        start_minor = min_minor if major == min_major else 0
+        # Go up to current Python version + 2 minor versions for future compatibility
+        end_minor = max(current_minor + 2, 12) if major == current_major else 12
+        
+        for minor in range(start_minor, end_minor + 1):
+            if major == 3 and minor >= min_minor:
+                versions.append(f"{major}.{minor}")
+    
+    return versions
+
+
+def build():
+    """Build bytecode for all compatible Python versions"""
+    try:
+        min_major, min_minor = parse_python_version_requirement()
+        compatible_versions = get_compatible_python_versions(min_major, min_minor)
+        
+        print(f"Building for Python versions: {', '.join(compatible_versions)}")
+        
+        # Compile for current Python version
+        print(f"Compiling for Python {sys.version_info.major}.{sys.version_info.minor}")
+        compileall.compile_dir('pythonDatabases', force=True)
+        
+        # Note: For actual cross-version bytecode, you'd need multiple Python interpreters
+        # This compiles with current interpreter but documents compatibility
+        print("Build completed successfully")
+        
+    except Exception as e:
+        print(f"Build failed: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    build()

{pythonlogs-4.0.5 → pythonlogs-5.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pythonLogs"
-version = "4.0.5"
+version = "5.0.0"
 description = "High-performance Python logging library with file rotation and optimized caching for better performance"
 license = "MIT"
 readme = "README.md"
@@ -30,8 +30,15 @@ classifiers = [
     "Natural Language :: English",
 ]
 
+[tool.poetry.build]
+script = "build.py"
+generate-setup-file = false
+
+[tool.poetry.group.test]
+optional = true
+
 [tool.poetry.dependencies]
-python = "^3.10"
+python = "^3.12"
 pydantic-settings = "^2.10.1"
 python-dotenv = "^1.1.1"
 
@@ -48,9 +55,6 @@ _coverage_xml = "coverage xml"
 tests = ["_test", "_coverage_report", "_coverage_xml"]
 test = ["tests"]
 
-[tool.poetry.group.test]
-optional = true
-
 [tool.black]
 line-length = 120
 skip-string-normalization = true

{pythonlogs-4.0.5 → pythonlogs-5.0.0}/pythonLogs/__init__.py

@@ -58,7 +58,7 @@ __author__ = "Daniel Costa"
 __email__ = "danieldcsta@gmail.com>"
 __license__ = "MIT"
 __copyright__ = "Copyright 2024-present ddc"
-_req_python_version = (3, 10, 0)
+_req_python_version = (3, 12, 0)
 
 
 try:

{pythonlogs-4.0.5 → pythonlogs-5.0.0}/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.5 → pythonlogs-5.0.0}/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.5 → pythonlogs-5.0.0}/pythonLogs/settings.py

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

{pythonlogs-4.0.5 → pythonlogs-5.0.0}/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.5 → pythonlogs-5.0.0}/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