python-fast-logger 0.1.0__py3-none-any.whl

fast_logger/__init__.py

@@ -0,0 +1,43 @@
+"""
+Fast Logger - A simple, no-fuss logging setup for Python applications.
+
+This package provides a quick and easy way to set up logging in Python applications
+with sensible defaults, rotating file handlers, and console output.
+
+Basic usage:
+    from fast_logger import get_logger
+
+    logger = get_logger("my_app")
+    logger.info("Hello, world!")
+
+Quick setup:
+    from fast_logger import quick_logger
+
+    logger = quick_logger("my_app")
+    logger.info("Hello, world!")
+
+Advanced usage:
+    from fast_logger import FastLogger
+
+    logger = FastLogger(
+        name="my_app",
+        level="DEBUG",
+        max_file_size_mb=100,
+        backup_count=5
+    )
+    logger.info("Hello, world!")
+"""
+
+from .core import FastLogger, setup_logger, get_logger, quick_logger
+
+__version__ = "0.1.0"
+__author__ = "Ravi Mishra"
+__email__ = "ravi@paisafintech.com"
+
+__all__ = [
+    "FastLogger",
+    "setup_logger",
+    "get_logger",
+    "quick_logger",
+    "__version__",
+]

fast_logger/core.py

@@ -0,0 +1,187 @@
+"""
+Fast Logger - A simple, no-fuss logging setup for Python applications
+"""
+
+import logging
+import sys
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+from typing import Optional, Union
+
+
+class FastLogger:
+    """A simple logger setup with sensible defaults."""
+
+    def __init__(self,
+                 name: str,
+                 level: Union[int, str] = logging.INFO,
+                 log_folder: str = 'logs',
+                 max_file_size_mb: int = 50,
+                 backup_count: int = 3,
+                 log_format: Optional[str] = None,
+                 console_output: bool = True,
+                 base_path: Optional[str] = None):
+        """
+        Initialize FastLogger with configuration.
+
+        Args:
+            name: Logger name (will be used as filename)
+            level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+            log_folder: Directory name for log files
+            max_file_size_mb: Maximum size of each log file in MB
+            backup_count: Number of backup files to keep
+            log_format: Custom log format string
+            console_output: Whether to output to console
+            base_path: Base directory for logs (defaults to caller's directory)
+        """
+        self.name = name
+        self.level = self._parse_level(level)
+        self.log_folder = log_folder
+        self.max_file_size_mb = max_file_size_mb
+        self.backup_count = backup_count
+        self.console_output = console_output
+        self.base_path = base_path
+
+        # Default format
+        self.log_format = log_format or (
+            '%(asctime)s - %(name)s [%(filename)s:%(lineno)d] - '
+            '%(levelname)s - %(message)s'
+        )
+
+        self._logger = None
+        self._setup_logger()
+
+    @staticmethod
+    def _parse_level(level: Union[int, str]) -> int:
+        """Parse logging level from string or int."""
+        if isinstance(level, str):
+            return getattr(logging, level.upper(), logging.INFO)
+        return level
+
+    def _get_log_directory(self) -> Path:
+        """Get the log directory path."""
+        if self.base_path:
+            base = Path(self.base_path)
+        else:
+            # Use the directory of the calling script
+            import inspect
+            frame = inspect.currentframe()
+            try:
+                # Go up the stack to find the caller
+                caller_frame = frame.f_back.f_back.f_back  # Go up one more level
+                caller_file = caller_frame.f_code.co_filename
+                base = Path(caller_file).parent
+            finally:
+                del frame
+
+        log_dir = base / self.log_folder
+        log_dir.mkdir(parents=True, exist_ok=True)
+        return log_dir
+
+    def _setup_logger(self):
+        """Set up the logger with file and console handlers."""
+        # Get or create logger
+        self._logger = logging.getLogger(self.name)
+
+        # Clear any existing handlers to avoid duplicates
+        self._logger.handlers.clear()
+        self._logger.setLevel(self.level)
+
+        # Create formatter
+        formatter = logging.Formatter(self.log_format)
+
+        # File handler
+        log_dir = self._get_log_directory()
+        log_file = log_dir / f"{self.name}.log"
+
+        file_handler = RotatingFileHandler(
+            str(log_file),  # Convert Path to string
+            maxBytes=self.max_file_size_mb * 1024 * 1024,
+            backupCount=self.backup_count,
+            encoding='utf-8'
+        )
+        file_handler.setLevel(self.level)
+        file_handler.setFormatter(formatter)
+        self._logger.addHandler(file_handler)
+
+        # Console handler (only if enabled)
+        if self.console_output:
+            console_handler = logging.StreamHandler(sys.stdout)
+            console_handler.setLevel(self.level)
+            console_handler.setFormatter(formatter)
+            self._logger.addHandler(console_handler)
+
+        # Prevent propagation to root logger
+        self._logger.propagate = False
+
+    def get_logger(self) -> logging.Logger:
+        """Get the configured logger instance."""
+        return self._logger
+
+    def debug(self, message: str, *args, **kwargs):
+        """Log a debug message."""
+        self._logger.debug(message, *args, **kwargs)
+
+    def info(self, message: str, *args, **kwargs):
+        """Log an info message."""
+        self._logger.info(message, *args, **kwargs)
+
+    def warning(self, message: str, *args, **kwargs):
+        """Log a warning message."""
+        self._logger.warning(message, *args, **kwargs)
+
+    def error(self, message: str, *args, **kwargs):
+        """Log an error message."""
+        self._logger.error(message, *args, **kwargs)
+
+    def critical(self, message: str, *args, **kwargs):
+        """Log a critical message."""
+        self._logger.critical(message, *args, **kwargs)
+
+    def exception(self, message: str, *args, **kwargs):
+        """Log an exception with traceback."""
+        self._logger.exception(message, *args, **kwargs)
+
+
+def setup_logger(name: str, **kwargs) -> logging.Logger:
+    """
+    Quick setup function for backward compatibility and convenience.
+
+    Args:
+        name: Logger name
+        **kwargs: Additional arguments passed to FastLogger
+
+    Returns:
+        Configured logger instance
+    """
+    fast_logger = FastLogger(name, **kwargs)
+    return fast_logger.get_logger()
+
+
+def get_logger(name: str, **kwargs) -> FastLogger:
+    """
+    Get a FastLogger instance with fluent interface.
+
+    Args:
+        name: Logger name
+        **kwargs: Additional arguments passed to FastLogger
+
+    Returns:
+        FastLogger instance
+    """
+    return FastLogger(name, **kwargs)
+
+
+# Convenience function for one-liner setup
+def quick_logger(name: str, level: str = 'INFO') -> logging.Logger:
+    """
+    Super quick logger setup with minimal configuration.
+
+    Args:
+        name: Logger name
+        level: Logging level
+
+    Returns:
+        Configured logger instance
+    """
+    return setup_logger(name, level=level)

python_fast_logger-0.1.0.dist-info/METADATA

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: python-fast-logger
+Version: 0.1.0
+Summary: A simple, no-fuss logging setup for Python applications
+Author-email: Ravi Mishra <ravi@paisafintech.com>
+Maintainer-email: Ravi Mishra <ravi@paisafintech.com>
+License: MIT
+Project-URL: Homepage, https://github.com/RaviMishra-94/fast-logger
+Project-URL: Documentation, https://github.com/RaviMishra-94/fast-logger/blob/main/README.md
+Project-URL: Repository, https://github.com/RaviMishra-94/fast-logger.git
+Project-URL: Bug Tracker, https://github.com/RaviMishra-94/fast-logger/issues
+Keywords: logging,logger,simple,fast,rotating,file
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Logging
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.0; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: flake8>=3.8; extra == "dev"
+Requires-Dist: mypy>=0.800; extra == "dev"
+Dynamic: license-file
+
+# Fast Logger
+
+![Tests](https://github.com/RaviMishra-94/fast-logger/actions/workflows/python-app.yml/badge.svg)
+
+A simple, no-fuss logging setup for Python applications with sensible defaults.
+
+## Features
+
+- **Zero configuration**: Works out of the box with sensible defaults
+- **Rotating file logs**: Automatically manages log file sizes and backups
+- **Console output**: Simultaneous logging to file and console
+- **Flexible configuration**: Easy to customize when needed
+- **Type hints**: Full type hint support for better IDE experience
+- **No dependencies**: Uses only Python standard library
+
+## Installation
+
+```bash
+pip install fast-logger
+```
+
+## Quick Start
+
+### Super Simple Usage
+
+```python
+from fast_logger import quick_logger
+
+logger = quick_logger("my_app")
+logger.info("Hello, world!")
+logger.error("Something went wrong!")
+```
+
+### Basic Usage
+
+```python
+from fast_logger import get_logger
+
+logger = get_logger("my_app")
+logger.info("Application started")
+logger.warning("This is a warning")
+logger.error("This is an error")
+```
+
+### Advanced Usage
+
+```python
+from fast_logger import FastLogger
+
+# Custom configuration
+logger = FastLogger(
+    name="my_advanced_app",
+    level="DEBUG",
+    log_folder="custom_logs",
+    max_file_size_mb=100,
+    backup_count=5,
+    console_output=True
+)
+
+logger.info("Advanced logging setup complete")
+logger.debug("Debug information")
+```
+
+### Web Application Example
+
+```python
+from fast_logger import get_logger
+from flask import Flask
+
+app = Flask(__name__)
+logger = get_logger("web_app", level="INFO")
+
+@app.route("/")
+def home():
+    logger.info("Home page accessed")
+    return "Hello, World!"
+
+@app.route("/api/data")
+def get_data():
+    try:
+        # Your API logic here
+        data = {"status": "success"}
+        logger.info("Data retrieved successfully")
+        return data
+    except Exception as e:
+        logger.error(f"Error retrieving data: {e}")
+        return {"status": "error"}, 500
+```
+
+## Configuration Options
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `name` | str | Required | Logger name (used as filename) |
+| `level` | str/int | `INFO` | Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL) |
+| `log_folder` | str | `logs` | Directory name for log files |
+| `max_file_size_mb` | int | `50` | Maximum size of each log file in MB |
+| `backup_count` | int | `3` | Number of backup files to keep |
+| `console_output` | bool | `True` | Whether to output to console |
+| `log_format` | str | Default format | Custom log format string |
+| `base_path` | str | Caller's directory | Base directory for logs |
+
+## Default Log Format
+
+```
+2024-01-15 10:30:45,123 - my_app [main.py:15] - INFO - Hello, world!
+```
+
+## File Structure
+
+By default, logs are created in a `logs` folder relative to your script:
+
+```
+your_project/
+├── main.py
+└── logs/
+    ├── my_app.log
+    ├── my_app.log.1
+    └── my_app.log.2
+```
+
+## API Reference
+
+### FastLogger Class
+
+The main class for advanced usage with full configuration options.
+
+```python
+logger = FastLogger(
+    name="my_app",
+    level="INFO",
+    log_folder="logs",
+    max_file_size_mb=50,
+    backup_count=3,
+    console_output=True,
+    log_format=None,
+    base_path=None
+)
+```
+
+### Convenience Functions
+
+- `quick_logger(name, level="INFO")`: Minimal setup for immediate use
+- `get_logger(name, **kwargs)`: Returns FastLogger instance with fluent interface
+- `setup_logger(name, **kwargs)`: Returns standard logging.Logger instance
+
+## Why Fast Logger?
+
+Most Python applications need logging, but setting it up properly requires boilerplate code:
+
+- Creating formatters
+- Setting up file handlers
+- Configuring rotation
+- Adding console output
+- Managing log directories
+
+Fast Logger eliminates this boilerplate while providing sensible defaults that work for most applications.
+
+## Comparison with Standard Logging
+
+**Standard logging setup:**
+```python
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+
+# 15+ lines of boilerplate code...
+logger = logging.getLogger("my_app")
+logger.setLevel(logging.INFO)
+# ... more setup code
+```
+
+**Fast Logger:**
+```python
+from fast_logger import quick_logger
+
+logger = quick_logger("my_app")
+# Done! 
+```
+
+## Requirements
+
+- Python 3.7+
+- No external dependencies
+
+## License
+
+MIT License. See LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for version history.

python_fast_logger-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+fast_logger/__init__.py,sha256=ZM2ZVkLa8Cp0JUpSJOGEFS4HFSJGcl7lI3YTj0tkUQI,963
+fast_logger/core.py,sha256=VUSY4WzIF61mSSem8OCRUPwGhOP0hgGn7_USF0fr9VM,6021
+python_fast_logger-0.1.0.dist-info/licenses/LICENSE,sha256=zUSVkLSqRvRAvbhtvLfGSC_Tw1ao2TsxwwvHr05VydQ,1067
+python_fast_logger-0.1.0.dist-info/METADATA,sha256=63x7SrKum1vdwoCw7gHNiqom9mgztexFwJrWrAaeq2M,6149
+python_fast_logger-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_fast_logger-0.1.0.dist-info/top_level.txt,sha256=c9NyRn7UsQxVnCzh3hCbwdUmz3kH-7-bWODGfANcGsw,12
+python_fast_logger-0.1.0.dist-info/RECORD,,

python_fast_logger-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

python_fast_logger-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ravi Mishra
+
+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.

python_fast_logger-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fast_logger