pythonLogs 6.0.0__tar.gz → 6.0.2__tar.gz

{pythonlogs-6.0.0 → pythonlogs-6.0.2}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: pythonLogs
-Version: 6.0.0
+Version: 6.0.2
 Summary: High-performance Python logging library with file rotation and optimized caching for better performance
-Project-URL: Homepage, https://pypi.org/project/pythonLogs
 Project-URL: Repository, https://github.com/ddc/pythonLogs
-Author-email: Daniel Costa <danieldcsta@gmail.com>
+Project-URL: Homepage, https://pypi.org/project/pythonLogs
+Author-email: Daniel Costa <ddcsoftwares@proton.me>
 Maintainer: Daniel Costa
 License: MIT
 License-File: LICENSE
@@ -16,17 +16,13 @@ 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.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.12
-Requires-Dist: pydantic-settings>=2.12.0
-Provides-Extra: test
-Requires-Dist: poethepoet>=0.40.0; extra == 'test'
-Requires-Dist: psutil>=7.2.1; extra == 'test'
-Requires-Dist: pytest-cov>=7.0.0; extra == 'test'
-Requires-Dist: pytest>=9.0.2; extra == 'test'
+Requires-Python: >=3.11
+Requires-Dist: pydantic-settings>=2.11.0
 Description-Content-Type: text/markdown
 
 <h1 align="center">
@@ -39,9 +35,9 @@ Description-Content-Type: text/markdown
     <a href="https://www.paypal.com/ncp/payment/6G9Z78QHUD4RJ"><img src="https://img.shields.io/badge/Donate-PayPal-brightgreen.svg?style=plastic" alt="Donate"/></a>
     <a href="https://github.com/sponsors/ddc"><img src="https://img.shields.io/static/v1?style=plastic&label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=ff69b4" alt="Sponsor"/></a>
     <br>
+    <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=plastic" alt="Code style: black"/></a>
     <a href="https://github.com/astral-sh/uv"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json?style=plastic" alt="uv"/></a>
     <a href="https://github.com/astral-sh/ruff"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json?style=plastic" alt="Ruff"/></a>
-    <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=plastic" alt="Code style: black"/></a>
     <br>
     <a href="https://www.python.org/downloads"><img src="https://img.shields.io/pypi/pyversions/pythonLogs.svg?style=plastic&logo=python&cacheSeconds=3600" alt="Python"/></a>
     <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg?style=plastic" alt="License: MIT"/></a>
@@ -69,9 +65,12 @@ Description-Content-Type: text/markdown
 - [Context Manager Support](#context-manager-support)
 - [Using With Multiple Log Levels and Files](#using-with-multiple-log-levels-and-files)
 - [Environment Variables](#env-variables-optional)
+  - [Settings Cache Management](#settings-cache-management)
 - [Flexible Configuration Options](#flexible-configuration-options)
 - [Development](#development)
-  - [Create DEV Environment, Running Tests and Building Wheel](#create-dev-environment-running-tests-and-building-wheel)
+  - [Create DEV Environment and Running Tests](#create-dev-environment-and-running-tests)
+  - [Update DEV Environment Packages](#update-dev-environment-packages)
+  - [Building Wheel](#building-wheel)
   - [Optionals](#optionals)
 - [License](#license)
 - [Support](#support)
@@ -316,6 +315,25 @@ LOG_ROTATE_AT_UTC=True
 LOG_ROTATE_FILE_SUFIX="%Y%m%d"
 ```
 
+## Settings Cache Management
+
+Use `get_log_settings()` to inspect current configuration and `clear_settings_cache()` to reload configuration from environment variables:
+
+```python
+from pythonLogs import get_log_settings, clear_settings_cache
+
+# Inspect current settings
+settings = get_log_settings()
+print(settings.level)      # Current log level
+print(settings.timezone)   # Current timezone
+
+# Clear cache and reload .env on next access (default)
+clear_settings_cache()
+
+# Clear cache but keep current .env values
+clear_settings_cache(reload_env=False)
+```
+
 
 
 
@@ -360,20 +378,34 @@ RotateWhen.MONDAY     # "W0"
 
 # Development
 
-Must have [UV](https://uv.run/docs/getting-started/installation),
-[Black](https://black.readthedocs.io/en/stable/getting_started.html),
-[Ruff](https://docs.astral.sh/ruff/installation/), and
-[Poe the Poet](https://poethepoet.naber.dev/installation) installed.
+Must have [UV](https://uv.run/docs/getting-started/installation) installed.
 
-## Create DEV Environment, Running Tests and Building Wheel
+## Create DEV Environment and Running Tests
+
+> **Note:** All poe tasks automatically run ruff linter along with Black formatting
 
 ```shell
-uv sync --all-extras
-poe linter
+uv sync --all-extras --all-groups
 poe test
+```
+
+
+## Update DEV Environment Packages
+This will update all packages dependencies
+
+```shell
+poe updatedev
+```
+
+
+## Building Wheel
+This will update all packages, run linter, both unit and integration tests and finally build the wheel
+
+```shell
 poe build
 ```
 
+
 ## Optionals
 
 ### Create a cprofile.prof file from unit tests

{pythonlogs-6.0.0 → pythonlogs-6.0.2}/README.md

@@ -8,9 +8,9 @@
     <a href="https://www.paypal.com/ncp/payment/6G9Z78QHUD4RJ"><img src="https://img.shields.io/badge/Donate-PayPal-brightgreen.svg?style=plastic" alt="Donate"/></a>
     <a href="https://github.com/sponsors/ddc"><img src="https://img.shields.io/static/v1?style=plastic&label=Sponsor&message=%E2%9D%A4&logo=GitHub&color=ff69b4" alt="Sponsor"/></a>
     <br>
+    <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=plastic" alt="Code style: black"/></a>
     <a href="https://github.com/astral-sh/uv"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json?style=plastic" alt="uv"/></a>
     <a href="https://github.com/astral-sh/ruff"><img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json?style=plastic" alt="Ruff"/></a>
-    <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg?style=plastic" alt="Code style: black"/></a>
     <br>
     <a href="https://www.python.org/downloads"><img src="https://img.shields.io/pypi/pyversions/pythonLogs.svg?style=plastic&logo=python&cacheSeconds=3600" alt="Python"/></a>
     <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg?style=plastic" alt="License: MIT"/></a>
@@ -38,9 +38,12 @@
 - [Context Manager Support](#context-manager-support)
 - [Using With Multiple Log Levels and Files](#using-with-multiple-log-levels-and-files)
 - [Environment Variables](#env-variables-optional)
+  - [Settings Cache Management](#settings-cache-management)
 - [Flexible Configuration Options](#flexible-configuration-options)
 - [Development](#development)
-  - [Create DEV Environment, Running Tests and Building Wheel](#create-dev-environment-running-tests-and-building-wheel)
+  - [Create DEV Environment and Running Tests](#create-dev-environment-and-running-tests)
+  - [Update DEV Environment Packages](#update-dev-environment-packages)
+  - [Building Wheel](#building-wheel)
   - [Optionals](#optionals)
 - [License](#license)
 - [Support](#support)
@@ -285,6 +288,25 @@ LOG_ROTATE_AT_UTC=True
 LOG_ROTATE_FILE_SUFIX="%Y%m%d"
 ```
 
+## Settings Cache Management
+
+Use `get_log_settings()` to inspect current configuration and `clear_settings_cache()` to reload configuration from environment variables:
+
+```python
+from pythonLogs import get_log_settings, clear_settings_cache
+
+# Inspect current settings
+settings = get_log_settings()
+print(settings.level)      # Current log level
+print(settings.timezone)   # Current timezone
+
+# Clear cache and reload .env on next access (default)
+clear_settings_cache()
+
+# Clear cache but keep current .env values
+clear_settings_cache(reload_env=False)
+```
+
 
 
 
@@ -329,20 +351,34 @@ RotateWhen.MONDAY     # "W0"
 
 # Development
 
-Must have [UV](https://uv.run/docs/getting-started/installation),
-[Black](https://black.readthedocs.io/en/stable/getting_started.html),
-[Ruff](https://docs.astral.sh/ruff/installation/), and
-[Poe the Poet](https://poethepoet.naber.dev/installation) installed.
+Must have [UV](https://uv.run/docs/getting-started/installation) installed.
+
+## Create DEV Environment and Running Tests
 
-## Create DEV Environment, Running Tests and Building Wheel
+> **Note:** All poe tasks automatically run ruff linter along with Black formatting
 
 ```shell
-uv sync --all-extras
-poe linter
+uv sync --all-extras --all-groups
 poe test
+```
+
+
+## Update DEV Environment Packages
+This will update all packages dependencies
+
+```shell
+poe updatedev
+```
+
+
+## Building Wheel
+This will update all packages, run linter, both unit and integration tests and finally build the wheel
+
+```shell
 poe build
 ```
 
+
 ## Optionals
 
 ### Create a cprofile.prof file from unit tests

{pythonlogs-6.0.0 → pythonlogs-6.0.2}/pyproject.toml

@@ -2,16 +2,31 @@
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.hatch.build]
+include = ["pythonLogs/**/*"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["pythonLogs"]
+
 [project]
 name = "pythonLogs"
-version = "6.0.0"
+version = "6.0.2"
 description = "High-performance Python logging library with file rotation and optimized caching for better performance"
+urls.Repository = "https://github.com/ddc/pythonLogs"
+urls.Homepage = "https://pypi.org/project/pythonLogs"
 license = {text = "MIT"}
 readme = "README.md"
-authors = [{name = "Daniel Costa", email = "danieldcsta@gmail.com"}]
-maintainers = [{name = "Daniel Costa"}]
+authors = [
+    {name = "Daniel Costa", email = "ddcsoftwares@proton.me"},
+]
+maintainers = [
+    {name = "Daniel Costa"},
+]
 keywords = [
-    "python3", "python-3", "python",
+    "python", "python3", "python-3",
     "log", "logging", "logger",
     "logutils", "log-utils", "pythonLogs"
 ]
@@ -20,6 +35,7 @@ classifiers = [
     "Development Status :: 5 - Production/Stable",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
@@ -28,52 +44,44 @@ classifiers = [
     "Intended Audience :: Developers",
     "Natural Language :: English",
 ]
-requires-python = ">=3.12"
+requires-python = ">=3.11"
 dependencies = [
-    "pydantic-settings>=2.12.0",
+    "pydantic-settings>=2.11.0",
 ]
 
-[project.urls]
-Homepage = "https://pypi.org/project/pythonLogs"
-Repository = "https://github.com/ddc/pythonLogs"
-
-[project.optional-dependencies]
-test = [
-    "poethepoet>=0.40.0",
-    "psutil>=7.2.1",
-    "pytest>=9.0.2",
+[dependency-groups]
+dev = [
+    "psutil>=7.2.2",
     "pytest-cov>=7.0.0",
+    "poethepoet>=0.41.0",
+    "ruff>=0.15.0",
+    "black>=26.1.0",
 ]
 
-[tool.hatch.build]
-include = ["pythonLogs/**/*"]
-
-[tool.hatch.build.targets.wheel]
-packages = ["pythonLogs"]
-
 [tool.poe.tasks]
-build = "uv build --wheel"
-updatedev.shell = "uv lock && uv sync --no-install-project --all-extras"
-linter.shell = "uv run ruff check --fix --select I . && uv run black ."
-profile = "uv run python -m cProfile -o cprofile.prof -m pytest"
-test = "uv run pytest"
+linter.shell = "uv run ruff check --fix . && uv run black ."
+profile.sequence = ["linter", {shell = "uv run python -m cProfile -o cprofile_unit.prof -m pytest --no-cov"}]
+test.sequence = ["linter", {shell = "uv run pytest"}]
+updatedev.sequence = ["linter", {shell = "uv lock --upgrade && uv sync --all-extras --group dev"}]
+build.sequence = ["updatedev", "test", {shell = "uv build --wheel"}]
 
 [tool.pytest.ini_options]
 addopts = "-v --cov --cov-report=term --cov-report=xml --junitxml=junit.xml"
 junit_family = "legacy"
 testpaths = ["tests"]
 markers = [
-    "slow: marks tests as slow (deselect with '-m \"not slow\"')"
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
 ]
 
 [tool.coverage.run]
 omit = [
     "tests/*",
     "*/__init__.py",
-    "*/_version.py",
 ]
 
 [tool.coverage.report]
+show_missing = true
+skip_covered = false
 exclude_lines = [
     "pragma: no cover",
     "def __repr__",
@@ -86,8 +94,6 @@ exclude_lines = [
     "class .*\\bProtocol\\):",
     "@(abc\\.)?abstractmethod",
 ]
-show_missing = true
-skip_covered = false
 
 [tool.black]
 line-length = 120
@@ -95,11 +101,18 @@ skip-string-normalization = true
 
 [tool.ruff]
 line-length = 120
+target-version = "py311"
 
 [tool.ruff.lint]
-select = ["I"]
+select = ["E", "W", "F", "I", "B", "C4", "UP"]
+ignore = ["E501", "E402", "UP046", "UP047"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
+"tests/**/*.py" = ["S101", "S105", "S106", "S311", "SLF001", "F841"]
 
 [tool.ruff.lint.isort]
 known-first-party = ["pythonLogs"]
-force-sort-within-sections = true
+force-sort-within-sections = false
+from-first = false
 no-sections = true

{pythonlogs-6.0.0 → pythonlogs-6.0.2}/pythonLogs/.env.example

@@ -15,6 +15,7 @@ LOG_STREAM_HANDLER=True
 LOG_SHOW_LOCATION=False
 # Memory Management Settings
 LOG_MAX_LOGGERS=50
+LOG_MAX_FORMATTERS=50
 LOG_LOGGER_TTL_SECONDS=1800
 
 # SizeRotatingLog Settings (only needed when using SizeRotatingLog)

pythonlogs-6.0.2/pythonLogs/__init__.py

@@ -0,0 +1,24 @@
+import logging
+from importlib.metadata import version
+from pythonLogs.core.constants import LogLevel, RotateWhen
+from pythonLogs.core.factory import BasicLog, SizeRotatingLog, TimedRotatingLog
+from pythonLogs.core.settings import clear_settings_cache, get_log_settings
+
+__all__ = (
+    "BasicLog",
+    "SizeRotatingLog",
+    "TimedRotatingLog",
+    "LogLevel",
+    "RotateWhen",
+    "clear_settings_cache",
+    "get_log_settings",
+)
+
+__title__ = "pythonLogs"
+__author__ = "Daniel Costa"
+__email__ = "ddcsoftwares@proton.me"
+__license__ = "MIT"
+__copyright__ = "Copyright 2024-present DDC Softwares"
+__version__ = version(__title__)
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())

{pythonlogs-6.0.0 → pythonlogs-6.0.2}/pythonLogs/basic_log.py

@@ -5,7 +5,7 @@ from pythonLogs.core.settings import get_log_settings
 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 @@ class BasicLog:
 
     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-6.0.0 → pythonlogs-6.0.2}/pythonLogs/core/constants.py

@@ -1,5 +1,5 @@
-from enum import Enum
 import logging
+from enum import StrEnum
 
 # File and Directory Constants
 MB_TO_BYTES = 1024 * 1024
@@ -17,7 +17,7 @@ DEFAULT_ENCODING = "UTF-8"
 DEFAULT_TIMEZONE = "UTC"
 
 
-class LogLevel(str, Enum):
+class LogLevel(StrEnum):
     """Log levels"""
 
     CRITICAL = "CRITICAL"
@@ -29,7 +29,7 @@ class LogLevel(str, Enum):
     DEBUG = "DEBUG"
 
 
-class RotateWhen(str, Enum):
+class RotateWhen(StrEnum):
     """Rotation timing options for TimedRotatingLog"""
 
     MIDNIGHT = "midnight"

{pythonlogs-6.0.0 → pythonlogs-6.0.2}/pythonLogs/core/factory.py

@@ -1,39 +1,39 @@
 import atexit
-from dataclasses import dataclass
-from enum import Enum
 import logging
+import threading
+import time
+from dataclasses import dataclass
+from enum import StrEnum
 from pythonLogs.basic_log import BasicLog as _BasicLogImpl
 from pythonLogs.core.constants import LogLevel, RotateWhen
 from pythonLogs.core.log_utils import cleanup_logger_handlers
 from pythonLogs.core.settings import get_log_settings
 from pythonLogs.size_rotating import SizeRotatingLog as _SizeRotatingLogImpl
 from pythonLogs.timed_rotating import TimedRotatingLog as _TimedRotatingLogImpl
-import threading
-import time
-from typing import Dict, Optional, Tuple, Union, assert_never
+from typing import assert_never
 
 
 @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):
+    level: LogLevel | str | None = None
+    name: str | None = None
+    directory: str | None = None
+    filenames: list | tuple | None = None
+    encoding: str | None = None
+    datefmt: str | None = None
+    timezone: str | None = None
+    streamhandler: bool | None = None
+    showlocation: bool | None = None
+    maxmbytes: int | None = None
+    when: RotateWhen | str | None = None
+    sufix: str | None = None
+    rotateatutc: bool | None = None
+    daystokeep: int | None = None
+
+
+class LoggerType(StrEnum):
     """Available logger types"""
 
     BASIC = "basic"
@@ -45,7 +45,7 @@ class LoggerFactory:
     """Factory for creating different types of loggers with optimized instantiation and memory management"""
 
     # Logger registry for reusing loggers by name with timestamp tracking
-    _logger_registry: Dict[str, Tuple[logging.Logger, float]] = {}
+    _logger_registry: dict[str, tuple[logging.Logger, float]] = {}
     # Thread lock for registry access
     _registry_lock = threading.RLock()
     # Memory optimization settings
@@ -71,8 +71,8 @@ class LoggerFactory:
     @classmethod
     def get_or_create_logger(
         cls,
-        logger_type: Union[LoggerType, str],
-        name: Optional[str] = None,
+        logger_type: LoggerType | str,
+        name: str | None = None,
         **kwargs,
     ) -> logging.Logger:
         """
@@ -215,12 +215,10 @@ class LoggerFactory:
             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: Union[LoggerType, str], config: Optional[LoggerConfig] = None, **kwargs
-    ) -> logging.Logger:
+    def create_logger(logger_type: LoggerType | str, config: LoggerConfig | None = None, **kwargs) -> logging.Logger:
         """
         Factory method to create loggers based on type.
 
@@ -239,8 +237,10 @@ class LoggerFactory:
         if isinstance(logger_type, str):
             try:
                 logger_type = LoggerType(logger_type.lower())
-            except ValueError:
-                raise ValueError(f"Invalid logger type: {logger_type}. Valid types: {[t.value for t in LoggerType]}")
+            except ValueError as err:
+                raise ValueError(
+                    f"Invalid logger type: {logger_type}. Valid types: {[t.value for t in LoggerType]}"
+                ) from err
 
         # Merge config and kwargs (kwargs take precedence for backward compatibility)
         if config is None:
@@ -248,20 +248,20 @@ class LoggerFactory:
 
         # 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
@@ -314,12 +314,12 @@ class LoggerFactory:
 
     @staticmethod
     def create_basic_logger(
-        level: Optional[Union[LogLevel, str]] = None,
-        name: Optional[str] = None,
-        encoding: Optional[str] = None,
-        datefmt: Optional[str] = None,
-        timezone: Optional[str] = None,
-        showlocation: Optional[bool] = None,
+        level: LogLevel | str | None = None,
+        name: str | None = None,
+        encoding: str | None = None,
+        datefmt: str | None = None,
+        timezone: str | None = None,
+        showlocation: bool | None = None,
     ) -> logging.Logger:
         """Convenience method for creating a basic logger"""
         return LoggerFactory.create_logger(
@@ -334,17 +334,17 @@ class LoggerFactory:
 
     @staticmethod
     def create_size_rotating_logger(
-        level: Optional[Union[LogLevel, str]] = None,
-        name: Optional[str] = None,
-        directory: Optional[str] = None,
-        filenames: Optional[list | tuple] = None,
-        maxmbytes: Optional[int] = None,
-        daystokeep: Optional[int] = None,
-        encoding: Optional[str] = None,
-        datefmt: Optional[str] = None,
-        timezone: Optional[str] = None,
-        streamhandler: Optional[bool] = None,
-        showlocation: Optional[bool] = None,
+        level: LogLevel | str | None = None,
+        name: str | None = None,
+        directory: str | None = None,
+        filenames: list | tuple | None = None,
+        maxmbytes: int | None = None,
+        daystokeep: int | None = None,
+        encoding: str | None = None,
+        datefmt: str | None = None,
+        timezone: str | None = None,
+        streamhandler: bool | None = None,
+        showlocation: bool | None = None,
     ) -> logging.Logger:
         """Convenience method for creating a size rotating logger"""
         return LoggerFactory.create_logger(
@@ -364,19 +364,19 @@ class LoggerFactory:
 
     @staticmethod
     def create_timed_rotating_logger(
-        level: Optional[Union[LogLevel, str]] = None,
-        name: Optional[str] = None,
-        directory: Optional[str] = None,
-        filenames: Optional[list | tuple] = None,
-        when: Optional[Union[RotateWhen, str]] = None,
-        sufix: Optional[str] = None,
-        daystokeep: Optional[int] = None,
-        encoding: Optional[str] = None,
-        datefmt: Optional[str] = None,
-        timezone: Optional[str] = None,
-        streamhandler: Optional[bool] = None,
-        showlocation: Optional[bool] = None,
-        rotateatutc: Optional[bool] = None,
+        level: LogLevel | str | None = None,
+        name: str | None = None,
+        directory: str | None = None,
+        filenames: list | tuple | None = None,
+        when: RotateWhen | str | None = None,
+        sufix: str | None = None,
+        daystokeep: int | None = None,
+        encoding: str | None = None,
+        datefmt: str | None = None,
+        timezone: str | None = None,
+        streamhandler: bool | None = None,
+        showlocation: bool | None = None,
+        rotateatutc: bool | None = None,
     ) -> logging.Logger:
         """Convenience method for creating a timed rotating logger"""
         return LoggerFactory.create_logger(
@@ -432,12 +432,12 @@ class BasicLog(_LoggerMixin):
 
     def __init__(
         self,
-        level: Optional[Union[LogLevel, str]] = None,
-        name: Optional[str] = None,
-        encoding: Optional[str] = None,
-        datefmt: Optional[str] = None,
-        timezone: Optional[str] = None,
-        showlocation: Optional[bool] = None,
+        level: LogLevel | str | None = None,
+        name: str | None = None,
+        encoding: str | None = None,
+        datefmt: str | None = None,
+        timezone: str | None = None,
+        showlocation: bool | None = None,
     ):
         self._logger = LoggerFactory.create_basic_logger(
             level=level,
@@ -465,17 +465,17 @@ class SizeRotatingLog(_LoggerMixin):
 
     def __init__(
         self,
-        level: Optional[Union[LogLevel, str]] = None,
-        name: Optional[str] = None,
-        directory: Optional[str] = None,
-        filenames: Optional[list | tuple] = None,
-        maxmbytes: Optional[int] = None,
-        daystokeep: Optional[int] = None,
-        encoding: Optional[str] = None,
-        datefmt: Optional[str] = None,
-        timezone: Optional[str] = None,
-        streamhandler: Optional[bool] = None,
-        showlocation: Optional[bool] = None,
+        level: LogLevel | str | None = None,
+        name: str | None = None,
+        directory: str | None = None,
+        filenames: list | tuple | None = None,
+        maxmbytes: int | None = None,
+        daystokeep: int | None = None,
+        encoding: str | None = None,
+        datefmt: str | None = None,
+        timezone: str | None = None,
+        streamhandler: bool | None = None,
+        showlocation: bool | None = None,
     ):
         self._logger = LoggerFactory.create_size_rotating_logger(
             level=level,
@@ -508,19 +508,19 @@ class TimedRotatingLog(_LoggerMixin):
 
     def __init__(
         self,
-        level: Optional[Union[LogLevel, str]] = None,
-        name: Optional[str] = None,
-        directory: Optional[str] = None,
-        filenames: Optional[list | tuple] = None,
-        when: Optional[Union[RotateWhen, str]] = None,
-        sufix: Optional[str] = None,
-        daystokeep: Optional[int] = None,
-        encoding: Optional[str] = None,
-        datefmt: Optional[str] = None,
-        timezone: Optional[str] = None,
-        streamhandler: Optional[bool] = None,
-        showlocation: Optional[bool] = None,
-        rotateatutc: Optional[bool] = None,
+        level: LogLevel | str | None = None,
+        name: str | None = None,
+        directory: str | None = None,
+        filenames: list | tuple | None = None,
+        when: RotateWhen | str | None = None,
+        sufix: str | None = None,
+        daystokeep: int | None = None,
+        encoding: str | None = None,
+        datefmt: str | None = None,
+        timezone: str | None = None,
+        streamhandler: bool | None = None,
+        showlocation: bool | None = None,
+        rotateatutc: bool | None = None,
     ):
         self._logger = LoggerFactory.create_timed_rotating_logger(
             level=level,

{pythonlogs-6.0.0 → pythonlogs-6.0.2}/pythonLogs/core/log_utils.py

@@ -1,18 +1,17 @@
-from datetime import datetime, timedelta
-from datetime import timezone as dttz
 import errno
-from functools import lru_cache
 import gzip
 import logging
 import logging.handlers
 import os
-from pathlib import Path
-from pythonLogs.core.constants import DEFAULT_FILE_MODE, LEVEL_MAP
 import shutil
 import sys
 import threading
 import time
-from typing import Callable, Optional, Set
+from collections.abc import Callable
+from datetime import UTC, datetime, timedelta
+from functools import lru_cache
+from pathlib import Path
+from pythonLogs.core.constants import DEFAULT_FILE_MODE, LEVEL_MAP
 from zoneinfo import ZoneInfo
 
 
@@ -21,15 +20,17 @@ class RotatingLogMixin:
 
     logger: logging.Logger | None
 
+    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
@@ -39,7 +40,7 @@ class RotatingLogMixin:
 
 
 # Global cache for checked directories with thread safety and size limits
-_checked_directories: Set[str] = set()
+_checked_directories: set[str] = set()
 _directory_lock = threading.Lock()
 _max_cached_directories = 500  # Limit cache size to prevent unbounded growth
 
@@ -109,7 +110,7 @@ def check_directory_permissions(directory_path: str) -> None:
             except PermissionError as e:
                 err_msg = f"Unable to create directory | {directory_path}"
                 write_stderr(f"{err_msg} | {type(e).__name__}: {e}")
-                raise PermissionError(err_msg)
+                raise PermissionError(err_msg) from e
 
         # Add to cache with size limit enforcement
         if len(_checked_directories) >= _max_cached_directories:
@@ -129,7 +130,7 @@ def remove_old_logs(logs_dir: str, days_to_keep: int) -> None:
             try:
                 if file_path.stat().st_mtime < cutoff_time.timestamp():
                     file_path.unlink()
-            except (OSError, IOError) as e:
+            except OSError as e:
                 write_stderr(f"Unable to delete old log | {file_path} | {type(e).__name__}: {e}")
     except OSError as e:
         write_stderr(f"Unable to scan directory for old logs | {logs_dir} | {type(e).__name__}: {e}")
@@ -196,7 +197,7 @@ def write_stderr(msg: str) -> None:
             # Use local timezone
             dt = datetime.now()
         else:
-            dt = datetime.now(dttz.utc).astimezone(tz)
+            dt = datetime.now(UTC).astimezone(tz)
         dt_timezone = dt.strftime("%Y-%m-%dT%H:%M:%S.%f%z")
         sys.stderr.write(f"[{dt_timezone}]:[ERROR]:{msg}\n")
     except (OSError, ValueError, KeyError):
@@ -286,7 +287,7 @@ def gzip_file_with_sufix(file_path: str, sufix: str) -> str | None:
             # Final attempt failed or not Windows - treat as regular error
             write_stderr(f"Unable to gzip log file | {file_path} | {type(e).__name__}: {e}")
             raise e
-        except (OSError, IOError) as e:
+        except OSError as e:
             write_stderr(f"Unable to gzip log file | {file_path} | {type(e).__name__}: {e}")
             raise e
 
@@ -324,7 +325,7 @@ def get_timezone_function(time_zone: str) -> Callable:
 
 
 # Shared handler cleanup utility
-def cleanup_logger_handlers(logger: Optional[logging.Logger]) -> None:
+def cleanup_logger_handlers(logger: logging.Logger | None) -> None:
     """Clean up logger resources by closing all handlers.
 
     This is a centralized utility to ensure consistent cleanup behavior

{pythonlogs-6.0.0 → pythonlogs-6.0.2}/pythonLogs/core/memory_utils.py

@@ -1,17 +1,18 @@
-from . import log_utils
-from functools import lru_cache
 import logging
 import threading
-from typing import Any, Dict, Optional, Set
 import weakref
+from . import log_utils
+from .settings import get_log_settings
+from functools import lru_cache
+from typing import Any
 
 # Formatter cache to reduce memory usage for identical formatters
-_formatter_cache: Dict[str, logging.Formatter] = {}
+_formatter_cache: dict[str, logging.Formatter] = {}
 _formatter_cache_lock = threading.Lock()
-_max_formatters = 50  # Limit formatter cache size
+_max_formatters = get_log_settings().max_formatters
 
 
-def get_cached_formatter(format_string: str, datefmt: Optional[str] = None) -> logging.Formatter:
+def get_cached_formatter(format_string: str, datefmt: str | None = None) -> logging.Formatter:
     """Get a cached formatter or create and cache a new one.
 
     This reduces memory usage by reusing formatter instances with
@@ -66,7 +67,7 @@ def clear_directory_cache() -> None:
 
 
 # Weak reference registry for tracking active loggers without preventing GC
-_active_loggers: Set[weakref.ReferenceType] = set()
+_active_loggers: set[weakref.ReferenceType] = set()
 _weak_ref_lock = threading.Lock()
 
 
@@ -103,7 +104,7 @@ def get_active_logger_count() -> int:
         return len(_active_loggers)
 
 
-def get_memory_stats() -> Dict[str, Any]:
+def get_memory_stats() -> dict[str, Any]:
     """Get memory usage statistics for the logging system.
 
     Returns:
@@ -125,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"],
     }
 
 
@@ -153,7 +154,7 @@ def optimize_lru_cache_sizes() -> None:
     log_utils.get_stderr_timezone = lru_cache(maxsize=4)(log_utils.get_stderr_timezone.__wrapped__)
 
 
-def force_garbage_collection() -> Dict[str, int]:
+def force_garbage_collection() -> dict[str, int]:
     """Force garbage collection and return collection statistics.
 
     This can be useful for testing memory leaks or forcing cleanup
@@ -172,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-6.0.0 → pythonlogs-6.0.2}/pythonLogs/core/settings.py

@@ -16,6 +16,14 @@ from pythonLogs.core.constants import (
 _dotenv_loaded = False
 
 
+def _ensure_dotenv_loaded() -> None:
+    """Ensure dotenv is loaded only once."""
+    global _dotenv_loaded
+    if not _dotenv_loaded:
+        load_dotenv()
+        _dotenv_loaded = True
+
+
 class LogSettings(BaseSettings):
     """If any ENV variable is omitted, it falls back to default values here"""
 
@@ -67,6 +75,10 @@ class LogSettings(BaseSettings):
         default=100,
         description="Maximum number of loggers to track in memory",
     )
+    max_formatters: int = Field(
+        default=50,
+        description="Maximum number of formatters to cache in memory",
+    )
     logger_ttl_seconds: int = Field(
         default=3600,
         description="Time-to-live in seconds for logger references",
@@ -95,9 +107,18 @@ class LogSettings(BaseSettings):
 
 @lru_cache(maxsize=1)
 def get_log_settings() -> LogSettings:
-    """Get cached log settings instance to avoid repeated instantiation"""
-    global _dotenv_loaded
-    if not _dotenv_loaded:
-        load_dotenv()
-        _dotenv_loaded = True
+    """Get cached log settings instance to avoid repeated instantiation."""
+    _ensure_dotenv_loaded()
     return LogSettings()
+
+
+def clear_settings_cache(reload_env: bool = True) -> None:
+    """Clear log settings cache. Next call to get_log_settings() will create fresh instance.
+
+    Args:
+        reload_env: If True, also reset dotenv loaded flag to reload .env on next access
+    """
+    global _dotenv_loaded
+    get_log_settings.cache_clear()
+    if reload_env:
+        _dotenv_loaded = False

{pythonlogs-6.0.0 → pythonlogs-6.0.2}/pythonLogs/core/thread_safety.py

@@ -1,23 +1,24 @@
 import functools
 import threading
-from typing import Any, Callable, Dict, Type, TypeVar
+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):
     """Metaclass that automatically adds thread safety to class methods."""
 
-    def __new__(mcs, name: str, bases: tuple, namespace: Dict[str, Any], **kwargs):
+    def __new__(mcs, name: str, bases: tuple, namespace: dict[str, Any], **kwargs):
         # Create the class first
         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 = [
@@ -25,8 +26,8 @@ class ThreadSafeMeta(type):
                 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__"]
                 )
             ]
 
@@ -47,12 +48,12 @@ 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'):
-                setattr(self.__class__, '_lock', threading.RLock())
-            lock = getattr(self.__class__, '_lock')
+            if not hasattr(self.__class__, "_lock"):
+                self.__class__._lock = threading.RLock()
+            lock = self.__class__._lock
 
         with lock:
             return func(self, *args, **kwargs)
@@ -60,36 +61,36 @@ def thread_safe(func: F) -> F:
     return wrapper
 
 
-def _get_wrappable_methods(cls: Type) -> list:
+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__']
+            and not method_name.startswith("_")
+            and method_name not in ["__enter__", "__exit__", "__init__"]
         )
     ]
 
 
-def _ensure_class_has_lock(cls: Type) -> None:
+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:
+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")
     )
 
 
 def auto_thread_safe(thread_safe_methods: list = None):
     """Class decorator that adds automatic thread safety to specified methods."""
 
-    def decorator(cls: Type) -> Type:
+    def decorator(cls: type) -> type:
         _ensure_class_has_lock(cls)
 
         # Store thread-safe methods list
@@ -116,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-6.0.0 → pythonlogs-6.0.2}/pythonLogs/size_rotating.py

@@ -1,5 +1,6 @@
 import logging.handlers
 import os
+import re
 from pathlib import Path
 from pythonLogs.core.constants import MB_TO_BYTES
 from pythonLogs.core.log_utils import (
@@ -17,10 +18,9 @@ from pythonLogs.core.log_utils import (
 from pythonLogs.core.memory_utils import register_logger_weakref
 from pythonLogs.core.settings import get_log_settings
 from pythonLogs.core.thread_safety import auto_thread_safe
-import re
 
 
-@auto_thread_safe(['init'])
+@auto_thread_safe(["init"])
 class SizeRotatingLog(RotatingLogMixin):
     """Size-based rotating logger with context manager support for automatic resource cleanup."""
 

{pythonlogs-6.0.0 → pythonlogs-6.0.2}/pythonLogs/timed_rotating.py

@@ -16,7 +16,7 @@ from pythonLogs.core.settings import get_log_settings
 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.

pythonlogs-6.0.0/pythonLogs/__init__.py

@@ -1,63 +0,0 @@
-from importlib.metadata import version
-import logging
-from pythonLogs.core.constants import LogLevel, RotateWhen
-from pythonLogs.core.factory import BasicLog, SizeRotatingLog, TimedRotatingLog
-from typing import Literal, NamedTuple
-
-__all__ = (
-    "BasicLog",
-    "SizeRotatingLog",
-    "TimedRotatingLog",
-    "LogLevel",
-    "RotateWhen",
-)
-
-__title__ = "pythonLogs"
-__author__ = "Daniel Costa"
-__email__ = "danieldcsta@gmail.com>"
-__license__ = "MIT"
-__copyright__ = "Copyright 2024-present DDC Softwares"
-_req_python_version = (3, 12, 0)
-
-
-try:
-    _version = tuple(int(x) for x in version(__title__).split("."))
-except ModuleNotFoundError:
-    _version = (0, 0, 0)
-
-
-class VersionInfo(NamedTuple):
-    major: int
-    minor: int
-    micro: int
-    releaselevel: Literal["alpha", "beta", "candidate", "final"]
-    serial: int
-
-
-__version__ = _version
-__version_info__: VersionInfo = VersionInfo(
-    major=__version__[0],
-    minor=__version__[1],
-    micro=__version__[2],
-    releaselevel="final",
-    serial=0,
-)
-__req_python_version__: VersionInfo = VersionInfo(
-    major=_req_python_version[0],
-    minor=_req_python_version[1],
-    micro=_req_python_version[2],
-    releaselevel="final",
-    serial=0,
-)
-
-logging.getLogger(__name__).addHandler(logging.NullHandler())
-
-del (
-    logging,
-    NamedTuple,
-    Literal,
-    VersionInfo,
-    version,
-    _version,
-    _req_python_version,
-)