pyessential 0.1.0__tar.gz

pyessential-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Abhishek Kumar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyessential-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md LICENSE
+recursive-include tests *.py

pyessential-0.1.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: pyessential
+Version: 0.1.0
+Summary: A growing collection of Python utilities and decorators.
+Home-page: https://github.com/Abhi39054/PyEssential.git
+Author: Abhishek Kumar
+Author-email: abhishekkumar39054@gmail.com
+Maintainer: Abhishek Kumar
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🐍 PyEssential
+
+**A growing collection of Python utilities and decorators to simplify common development tasks.**
+
+---
+
+[![PyPI version](https://img.shields.io/pypi/v/pyessential.svg)](https://pypi.org/project/pyessential/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+## ✨ Features
+
+`PyEssential` aims to be the go-to library for small, reusable tools that you often find yourself writing from scratch.
+
+* **Performance:** Includes the ready-to-use `@timeit` decorator for simple function benchmarking.
+* **Code Clarity:** Provides utility functions for common tasks like string manipulation (e.g., casing). (Coming soon!)
+* **Scalability:** Structured for easy addition of new utility groups (e.g., `networking`, `file_io`, `validation`).
+
+## 🚀 Installation
+
+`PyEssential` is currenlty still in development stage. Once development is completed, It will be published in the Pypi for the community to use.
+
+
+```bash
+pip install pyessential
+```

pyessential-0.1.0/README.md

@@ -0,0 +1,25 @@
+# 🐍 PyEssential
+
+**A growing collection of Python utilities and decorators to simplify common development tasks.**
+
+---
+
+[![PyPI version](https://img.shields.io/pypi/v/pyessential.svg)](https://pypi.org/project/pyessential/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+## ✨ Features
+
+`PyEssential` aims to be the go-to library for small, reusable tools that you often find yourself writing from scratch.
+
+* **Performance:** Includes the ready-to-use `@timeit` decorator for simple function benchmarking.
+* **Code Clarity:** Provides utility functions for common tasks like string manipulation (e.g., casing). (Coming soon!)
+* **Scalability:** Structured for easy addition of new utility groups (e.g., `networking`, `file_io`, `validation`).
+
+## 🚀 Installation
+
+`PyEssential` is currenlty still in development stage. Once development is completed, It will be published in the Pypi for the community to use.
+
+
+```bash
+pip install pyessential
+```

pyessential-0.1.0/pyessential/__init__.py

@@ -0,0 +1,16 @@
+
+from .decorators import timeit
+from .generators import generate_random_int, generate_secret_key
+from .logger import Logger
+
+# Version and Author Info
+__version__ = "0.1.0" 
+__author__ = "Abhishek Kumar"
+
+
+__all__ = [
+    "timeit",
+    "generate_random_int",
+    "generate_secret_key",
+    "Logger",
+]

pyessential-0.1.0/pyessential/decorators/__init__.py

@@ -0,0 +1,3 @@
+from .timer import timeit
+
+__all__ = ["timeit"]

pyessential-0.1.0/pyessential/decorators/timer.py

@@ -0,0 +1,13 @@
+import time
+from functools import wraps
+
+def timeit(func):
+    """Decorator to measure and print function execution time."""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        execution_time = time.time() - start_time
+        print(f"[{func.__name__}] executed in {execution_time:.4f} seconds.")
+        return result
+    return wrapper

pyessential-0.1.0/pyessential/generators.py

@@ -0,0 +1,31 @@
+"""
+    Name: pyessential.generators
+    Description: A module providing utility functions for generating random data.
+    Author: Abhishek Kumar
+"""
+
+import secrets
+
+def generate_random_int(min_value=0, max_value=100):
+    """Generate a random integer within a specified range.
+
+    Args:
+        min_value (int): The minimum value of the range. Default is 0.
+        max_value (int): The maximum value of the range. Default is 100.
+
+    Returns:
+        int: A randomly generated integer within the specified range.
+    """
+    return secrets.randbelow(max_value - min_value + 1) + min_value
+
+
+def generate_secret_key(length=32):
+    """Generate a secure random secret key.
+
+    Args:
+        length (int): The length of the secret key. Default is 32.
+
+    Returns:
+        str: A securely generated random secret key.
+    """
+    return secrets.token_hex(length)

pyessential-0.1.0/pyessential/logger.py

@@ -0,0 +1,265 @@
+"""
+    Logger utility for application logging.
+
+    This module provides the 'Logger' class, a robust logging utility that
+    integrates with Python's standard 'logging' library. It configures
+    three separate loggers/files for STDIN (ingress), STDOUT (general/info),
+    and STDERR (errors/critical) messages, with support for
+    timed log rotation and console output.
+
+"""
+
+import os
+import sys
+import traceback
+import logging
+from datetime import datetime
+from logging.handlers import TimedRotatingFileHandler
+
+
+class Logger:
+    """
+    A logging utility class for managing application logs with separate streams.
+
+    It sets up three distinct, rotation-enabled log files:
+    1. STDIN (for input/ingress events)
+    2. STDOUT (for general debug/info/warning messages)
+    3. STDERR (for error/critical messages and exceptions)
+
+    The class is designed to be used as a context manager to ensure log closure.
+
+    Example:
+    >>> log = Logger(log_name="my_app", enable_console=True)
+    >>> log.info("Application started.")
+    >>> log.error("Something went wrong!")
+
+    or 
+
+    >>> with Logger(log_name="my_app", enable_console=True) as log:
+    ...     log.info("Application started.")
+    ...     log.error("Something went wrong!")
+    ...
+    """
+
+    _LEVEL_MAP = {
+        "debug":logging.DEBUG,
+        "info": logging.INFO,
+        "warning": logging.WARNING,
+        "error": logging.ERROR,
+        "critical": logging.CRITICAL,
+    }
+
+    def __init__(
+            self,
+            log_dir="../logs",
+            log_name="project",
+            level="debug",
+            when="midnight",
+            interval=1,
+            backup_count=7,
+            enable_console=False,
+            fmt="%(asctime)s.%(msecs)03d - %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+            encoding="utf-8"
+    ):
+        """
+        Args:
+            log_dir (str) : Directory to store log files. Default is '../logs'.
+            log_name (str) : Base name for the three log files (<log_name>_stdin.log, <log_name>_stdout.log, <log_name>_stderr.log).
+            level (str) : Logging level. Default is 'debug'.
+            when (str) : Time interval for log rotation. Default is 'midnight'.
+            interval (int) : Interval for log rotation. Default is 1.
+            backup_count (int) : Number of backup log files to keep. Default is 7.
+            enable_console (bool) : Enable console logging. Default is False.
+            fmt (str) : Log message format. Default is "%(asctime)s.%(msecs)03d - %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s".
+            datefmt (str) : Date format in logs. Default is "%Y-%m-%d %H:%M:%S".
+            encoding (str) : Encoding for log files. Default is "utf-8".
+        """
+
+        self.log_dir = os.path.abspath(log_dir)
+        self.log_name = log_name
+
+        # Filenames (with 'logs' extension as is common; can be changed if needed)
+        self.stdin_path = os.path.join(self.log_dir, f"{self.log_name}_stdin.log")
+        self.stdout_path = os.path.join(self.log_dir, f"{self.log_name}_stdout.log")
+        self.error_path = os.path.join(self.log_dir, f"{self.log_name}_error.log")
+
+        # Ensure Directory
+        os.makedirs(self.log_dir, exist_ok=True)
+
+        # Common formatter
+        formatter = logging.Formatter(fmt=fmt, datefmt=datefmt)
+
+        # Create three dedicated loggers so routing is explicit and simple
+        self._stdin_logger = self._build_logger(
+            name=f"{self.log_name}.stdin",
+            filepath=self.stdin_path,
+            level=level,
+            when=when,
+            interval=interval,
+            backup_count=backup_count,
+            formatter=formatter,
+            encoding=encoding,
+            enable_console=False,   # stdin is typically not logged to console
+        )
+
+        self._stdout_logger = self._build_logger(
+            name=f"{self.log_name}.stdout",
+            filepath=self.stdout_path,
+            level=level,
+            when=when,
+            interval=interval,
+            backup_count=backup_count,
+            formatter=formatter,
+            encoding=encoding,
+            enable_console=enable_console,
+            console_to_stderr=False # stdout -> sys.stdout
+        )
+
+        self._error_logger = self._build_logger(
+            name=f"{self.log_name}.error",
+            filepath=self.error_path,
+            level=level,
+            when=when,
+            interval=interval,
+            backup_count=backup_count,
+            formatter=formatter,
+            encoding=encoding,
+            enable_console=enable_console,
+            console_to_stderr=True # stderr -> sys.stderr
+        )
+
+    # --------------- Public Methods ---------------
+    def debug(self, msg, *args, exc_info=False, stacklevel=2, **kwargs):
+        """Log a debug message to stdout logger."""
+        self._stdout_logger.debug(msg, *args, exc_info=exc_info, stacklevel=stacklevel, **kwargs)
+
+    def info(self, msg, *args, exc_info=False, stacklevel=2, **kwargs):
+        """Log an info message to stdout logger."""
+        self._stdout_logger.info(msg, *args, exc_info=exc_info, stacklevel=stacklevel, **kwargs)
+
+    def warning(self, msg, *args, exc_info=False, stacklevel=2, **kwargs):
+        """Log a warning message to stdout logger."""
+        self._stdout_logger.warning(msg, *args, exc_info=exc_info, stacklevel=stacklevel, **kwargs)
+
+    def error(self, msg, *args, exc_info=False, stacklevel=2, **kwargs):
+        """Log an error message to error logger."""
+        self._error_logger.error(msg, *args, exc_info=exc_info, stacklevel=stacklevel, **kwargs)
+    
+    def critical(self, msg, *args, exc_info=False, stacklevel=2, **kwargs):
+        """Log a critical message to error logger."""
+        self._error_logger.critical(msg, *args, exc_info=exc_info, stacklevel=stacklevel, **kwargs)
+    
+    def exception(self, msg, *args, exc_info=False, stacklevel=2, **kwargs):
+        """Log an exception message to error logger."""
+        self._error_logger.error(msg, *args, exc_info=True, stacklevel=stacklevel, **kwargs)
+
+    def stdin(self, msg, *args, exc_info=False, stacklevel=2, **kwargs):
+        """Explicitly record 'input' or ingress events."""
+        self._stdin_logger.info(msg, *args, exc_info=exc_info, stacklevel=stacklevel, **kwargs) 
+
+    def log_error(self, err: Exception):
+        """Log an exception with traceback to the error logger.
+
+        Args:
+            err (Exception): The exception instance to log.
+        """
+        
+        exc_type, exc_obj, exc_tb = sys.exc_info()
+
+        if exc_tb is None:
+            # It means getting called outputside except block.
+            filename = "<unknown>"
+            lineno = -1
+            func_name = "<unknown>"
+        else:
+            filename = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
+            lineno = exc_tb.tb_lineno
+            func_name = traceback.extract_tb(exc_tb, 1)[0][2]
+        
+        e_type = err.__class__.__name__
+
+        data = {
+            "exception_type": e_type,
+            "exception_message": str(err),
+            "filename": filename,
+            "lineno": lineno,
+            "function": func_name,
+            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "traceback": traceback.format_exc()
+        }
+
+        # log to stderr file
+        self.error(data, exc_info=True, stacklevel=2)
+        return data
+    
+    def close(self):
+        """
+        Flush and close all handlers explicitly.
+        """
+
+        for lg in (self._stdin_logger, self._stdout_logger, self._error_logger):
+            for h in list(lg.handlers):
+                try:
+                    h.flush()
+                except Exception:
+                    pass
+                
+                try:
+                    h.close()
+                except Exception:
+                    pass
+
+                lg.removeHandler(h)
+
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+
+    # --------------- Internals ---------------
+    @classmethod
+    def _build_logger(
+            cls,
+            name,
+            filepath,
+            level,
+            when,
+            interval,
+            backup_count,
+            formatter,
+            encoding,
+            enable_console=False,
+            console_to_stderr=False
+    ):
+        
+        log_level = cls._LEVEL_MAP.get(level.lower(), logging.DEBUG)
+        logger = logging.getLogger(name)
+        logger.setLevel(log_level)
+        logger.handlers.clear()  # Avoid duplicate handlers on re-initialization
+        logger.propagate = False # Prevent log messages from being propagated to the root logger
+
+        # Timed Rotating File Handler
+        fh = TimedRotatingFileHandler(
+            filename=filepath,
+            when=when,
+            interval=interval,
+            backupCount=backup_count,
+            encoding=encoding,
+            delay=True,
+            utc=False
+        )
+        
+        fh.setFormatter(formatter)
+        logger.addHandler(fh)
+
+        if enable_console:
+            stream = sys.stderr if console_to_stderr else sys.stdout
+            sh = logging.StreamHandler(stream)
+            sh.setFormatter(formatter)
+            sh.setLevel(log_level)
+            logger.addHandler(sh)
+
+        return logger

pyessential-0.1.0/pyessential.egg-info/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: pyessential
+Version: 0.1.0
+Summary: A growing collection of Python utilities and decorators.
+Home-page: https://github.com/Abhi39054/PyEssential.git
+Author: Abhishek Kumar
+Author-email: abhishekkumar39054@gmail.com
+Maintainer: Abhishek Kumar
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🐍 PyEssential
+
+**A growing collection of Python utilities and decorators to simplify common development tasks.**
+
+---
+
+[![PyPI version](https://img.shields.io/pypi/v/pyessential.svg)](https://pypi.org/project/pyessential/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+## ✨ Features
+
+`PyEssential` aims to be the go-to library for small, reusable tools that you often find yourself writing from scratch.
+
+* **Performance:** Includes the ready-to-use `@timeit` decorator for simple function benchmarking.
+* **Code Clarity:** Provides utility functions for common tasks like string manipulation (e.g., casing). (Coming soon!)
+* **Scalability:** Structured for easy addition of new utility groups (e.g., `networking`, `file_io`, `validation`).
+
+## 🚀 Installation
+
+`PyEssential` is currenlty still in development stage. Once development is completed, It will be published in the Pypi for the community to use.
+
+
+```bash
+pip install pyessential
+```

pyessential-0.1.0/pyessential.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+setup.py
+pyessential/__init__.py
+pyessential/generators.py
+pyessential/logger.py
+pyessential.egg-info/PKG-INFO
+pyessential.egg-info/SOURCES.txt
+pyessential.egg-info/dependency_links.txt
+pyessential.egg-info/top_level.txt
+pyessential/decorators/__init__.py
+pyessential/decorators/timer.py
+tests/test_decorators.py
+tests/test_generators.py
+tests/test_logger.py

pyessential-0.1.0/pyessential.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyessential-0.1.0/pyessential.egg-info/top_level.txt

@@ -0,0 +1 @@
+pyessential

pyessential-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"

pyessential-0.1.0/setup.cfg

@@ -0,0 +1,32 @@
+[metadata]
+name = pyessential
+version = 0.1.0
+author = Abhishek Kumar
+author_email = abhishekkumar39054@gmail.com
+maintainer = Abhishek Kumar
+description = A growing collection of Python utilities and decorators.
+long_description = file: README.md
+long_description_content_type = text/markdown
+url = https://github.com/Abhi39054/PyEssential.git
+license = MIT
+classifiers = 
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3.8
+	Programming Language :: Python :: 3.9
+	Programming Language :: Python :: 3.10
+	License :: OSI Approved :: MIT License
+	Operating System :: OS Independent
+
+[options]
+packages = find:
+install_requires = 
+python_requires = >=3.8
+
+[options.packages.find]
+exclude = 
+	tests*
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyessential-0.1.0/setup.py

@@ -0,0 +1,6 @@
+
+import setuptools
+
+if __name__ == '__main__':
+    # This command automatically reads configuration from setup.cfg
+    setuptools.setup()

pyessential-0.1.0/tests/test_decorators.py

@@ -0,0 +1,23 @@
+# tests/test_decorators.py
+import time
+from pyessential.decorators import timeit
+
+# Example: Simple test to ensure the function returns correctly
+def test_time_it_returns_correct_value():
+    @timeit
+    def add(a, b):
+        return a + b
+
+    # Check if the result is correct
+    assert add(2, 3) == 5
+
+# Example: Test with some time delay
+def test_time_it_execution_time(capsys):
+    @timeit
+    def sleep_a_bit():
+        time.sleep(0.01)
+
+    sleep_a_bit()
+
+    captured = capsys.readouterr()
+    assert "executed in" in captured.out

pyessential-0.1.0/tests/test_generators.py

@@ -0,0 +1,59 @@
+# tests/test_generators.py
+import time
+from pyessential.generators import generate_random_int, generate_secret_key
+
+
+# Test to ensure the generated integer is within the specified range
+def test_generate_random_int_within_range():
+    min_value = 0
+    max_value = 100
+    result = generate_random_int(min_value, max_value)
+    assert min_value <= result <= max_value, f"Result {result} is not within range {min_value}-{max_value}"
+
+# Test to check the default range
+def test_generate_random_int_default_range():
+    result = generate_random_int()
+    assert 0 <= result <= 100, f"Result {result} is not within default range 0-100"
+
+# Test to check multiple calls produce different results
+def test_generate_random_int_multiple_calls():
+    results = {generate_random_int() for _ in range(10)}
+    assert len(results) > 1, "Multiple calls to generate_random_int produced the same result"
+
+# Test to check edge case where min_value equals max_value
+def test_generate_random_int_edge_case():
+    min_value = 10
+    max_value = 10
+    result = generate_random_int(min_value, max_value)
+    assert result == min_value, f"Result {result} is not equal to the edge case value {min_value}"
+
+# Test to check negative range
+def test_generate_random_int_negative_range():
+    min_value = -10
+    max_value = -5
+    result = generate_random_int(min_value, max_value)
+    assert min_value <= result <= max_value, f"Result {result} is not within range {min_value}-{max_value}"
+
+# Test to check large range
+def test_generate_random_int_large_range():
+    min_value = 1000
+    max_value = 2000
+    result = generate_random_int(min_value, max_value)
+    assert min_value <= result <= max_value, f"Result {result} is not within range {min_value}-{max_value}"
+
+# Test for generate secret key
+def test_generate_secret_key_length():
+    length = 16
+    result = generate_secret_key(length)
+    assert len(result) == length * 2, f"Secret key length {len(result)} does not match expected length {length * 2}"
+
+def test_generate_secret_key_different_calls():
+    result1 = generate_secret_key()
+    result2 = generate_secret_key()
+    assert result1 != result2, "Multiple calls to generate_secret_key produced the same result"
+
+def test_generate_secret_key_default_length():
+    default_length = 32
+    result = generate_secret_key()
+    assert len(result) == default_length * 2 , f"Default secret key length {len(result)} does not match expected length {default_length * 2}"
+    

pyessential-0.1.0/tests/test_logger.py

@@ -0,0 +1,182 @@
+import pytest
+import os
+import shutil
+import re
+import json
+import sys
+import logging
+from pyessential.logger import Logger # Assuming the main Logger class is saved in 'logger.py'
+
+# --- Configuration ---
+TEMP_LOG_DIR = "./temp_pytest_logs"
+TEST_LOG_NAME = "test_app"
+
+def get_log_paths(log_dir, log_name):
+    """Utility function to generate expected log paths."""
+    return {
+        'stdin': os.path.join(log_dir, f"{log_name}_stdin.log"),
+        'stdout': os.path.join(log_dir, f"{log_name}_stdout.log"),
+        'error': os.path.join(log_dir, f"{log_name}_error.log"),
+    }
+
+def get_log_content(filepath):
+    """Utility function to read content from a log file."""
+    if not os.path.exists(filepath):
+        return ""
+    with open(filepath, 'r', encoding='utf-8') as f:
+        return f.read()
+
+@pytest.fixture(scope="session")
+def log_setup():
+    """
+    Pytest fixture to create and clean up the temporary log directory.
+    This runs once per test session.
+    """
+    # Setup
+    if os.path.exists(TEMP_LOG_DIR):
+        shutil.rmtree(TEMP_LOG_DIR)
+    os.makedirs(TEMP_LOG_DIR)
+    
+    paths = get_log_paths(TEMP_LOG_DIR, TEST_LOG_NAME)
+    
+    # Yield the log paths to the tests
+    yield paths
+
+    # Teardown
+    if os.path.exists(TEMP_LOG_DIR):
+        shutil.rmtree(TEMP_LOG_DIR)
+
+@pytest.fixture(autouse=True)
+def clean_logs(log_setup):
+    """
+    Pytest fixture to clean up individual log files before each test.
+    This mimics the setUp() method in unittest.
+    """
+    for path in log_setup.values():
+        if os.path.exists(path):
+            os.remove(path)
+    
+    # Yield control back to the test
+    yield
+
+# Use a test class to group related tests
+class TestLoggerPytest:
+    """Test suite for the Logger class using Pytest conventions."""
+    
+    def test_01_initialization_and_path_check(self, log_setup):
+        """Test if the Logger initializes correctly and reports the correct file paths."""
+        with Logger(log_dir=TEMP_LOG_DIR, log_name=TEST_LOG_NAME) as log:
+            # Check path properties
+            assert log.stdin_path.endswith(f"{TEST_LOG_NAME}_stdin.log")
+            assert log.stdout_path.endswith(f"{TEST_LOG_NAME}_stdout.log")
+            assert log.error_path.endswith(f"{TEST_LOG_NAME}_error.log")
+        
+        # Re-initialize to check internal logger handlers
+        log_check = Logger(log_dir=TEMP_LOG_DIR, log_name=TEST_LOG_NAME)
+        # Check that only one FileHandler is present by default
+        assert len(log_check._stdout_logger.handlers) == 1 
+        log_check.close()
+
+
+    def test_02_message_routing_and_content(self, log_setup):
+        """Test if messages are routed correctly to STDOUT, STDIN, and STDERR logs."""
+        message_info = "The process is running."
+        message_error = "Failed to connect to service."
+        message_stdin = "User input received."
+
+        with Logger(log_dir=TEMP_LOG_DIR, log_name=TEST_LOG_NAME, level="DEBUG") as log:
+            log.debug("A detailed debug message.")
+            log.info(message_info)
+            log.warning("Potential issue detected.")
+            
+            log.error(message_error)
+            log.critical("System shutdown imminent.")
+            
+            log.stdin(message_stdin)
+
+        # 1. Check STDOUT Log (debug, info, warning)
+        stdout_content = get_log_content(log_setup['stdout'])
+        assert message_info in stdout_content
+        assert message_error not in stdout_content
+        assert message_stdin not in stdout_content # STDIN messages go to separate file
+        
+        # 2. Check STDERR Log (error, critical)
+        error_content = get_log_content(log_setup['error'])
+        assert message_error in error_content
+        assert "System shutdown imminent." in error_content
+        assert message_info not in error_content
+
+        # 3. Check STDIN Log (stdin)
+        stdin_content = get_log_content(log_setup['stdin'])
+        assert message_stdin in stdin_content
+        assert "INFO" in stdin_content # stdin uses info level internally
+        assert message_error not in stdin_content
+
+    def test_03_exception_and_traceback_logging(self, log_setup):
+        """Test logging of exceptions using both exception() and log_error()."""
+        
+        with Logger(log_dir=TEMP_LOG_DIR, log_name=TEST_LOG_NAME) as log:
+            try:
+                raise KeyError("Test key error for structured logging.")
+            except KeyError as e:
+                # 1. Test log.exception()
+                log.exception("Handled error during dictionary lookup.")
+                
+                # 2. Test log.log_error(e)
+                structured_data = log.log_error(e)
+
+        error_content = get_log_content(log_setup['error'])
+
+        # 1. Check for standard traceback (from log.exception())
+        assert "Traceback (most recent call last):" in error_content
+        assert "KeyError: 'Test key error for structured logging.'" in error_content
+        assert "Handled error during dictionary lookup." in error_content
+        
+        # 2. Check for structured log data (from log.log_error). This should be a string representation of a dict.
+        # Since log_error logs the whole dict object, we check for stringified parts.
+        assert "'exception_type': 'KeyError'" in error_content
+        assert "'lineno':" in error_content
+        
+        # 3. Check returned structured data integrity
+        assert structured_data["exception_type"] == "KeyError"
+        assert "Test key error for structured logging." in structured_data["exception_message"]
+    
+    def test_04_console_handler_presence(self):
+        """Test if StreamHandlers are correctly added when enable_console is True."""
+        # Use a temporary logger instance for this test
+        log_console = Logger(log_dir=TEMP_LOG_DIR, log_name="console_test", enable_console=True)
+        
+        # STDOUT logger should have FileHandler and StreamHandler (2 total)
+        assert len(log_console._stdout_logger.handlers) == 2
+        # STDERR logger should have FileHandler and StreamHandler (2 total)
+        assert len(log_console._error_logger.handlers) == 2
+        # STDIN logger should only have FileHandler (1 total)
+        assert len(log_console._stdin_logger.handlers) == 1
+        
+        # Verify the console handler streams
+        sh_stdout = [h for h in log_console._stdout_logger.handlers if isinstance(h, logging.StreamHandler)]
+        assert sh_stdout[1].stream == sys.stdout
+
+        sh_error = [h for h in log_console._error_logger.handlers if isinstance(h, logging.StreamHandler)]
+        assert sh_error[1].stream == sys.stderr
+
+        log_console.close()
+
+    def test_05_context_manager_cleanup(self, log_setup):
+        """Test if the __exit__ method calls close() and cleans up handlers."""
+        log = Logger(log_dir=TEMP_LOG_DIR, log_name="cleanup_test")
+        
+        # Handlers exist before exit
+        assert len(log._stdout_logger.handlers) > 0
+        
+        # Enter and immediately exit the context manager
+        with log:
+            log.info("Testing cleanup.")
+        
+        # Check if handlers were removed after __exit__ (which calls close)
+        assert len(log._stdout_logger.handlers) == 0
+        assert len(log._error_logger.handlers) == 0
+        assert len(log._stdin_logger.handlers) == 0
+        
+        # Check if files were written
+        assert os.path.exists(log.stdout_path)