python-fast-logger 0.1.0__tar.gz

python_fast_logger-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,196 @@
+# 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/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__",
+]

python_fast_logger-0.1.0/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/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "python-fast-logger"
+version = "0.1.0"
+description = "A simple, no-fuss logging setup for Python applications"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "Ravi Mishra", email = "ravi@paisafintech.com"}
+]
+maintainers = [
+    {name = "Ravi Mishra", email = "ravi@paisafintech.com"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: System :: Logging",
+]
+keywords = ["logging", "logger", "simple", "fast", "rotating", "file"]
+requires-python = ">=3.7"
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=6.0",
+    "pytest-cov>=2.0",
+    "black>=21.0",
+    "flake8>=3.8",
+    "mypy>=0.800",
+]
+
+[project.urls]
+Homepage = "https://github.com/RaviMishra-94/fast-logger"
+Documentation = "https://github.com/RaviMishra-94/fast-logger/blob/main/README.md"
+Repository = "https://github.com/RaviMishra-94/fast-logger.git"
+"Bug Tracker" = "https://github.com/RaviMishra-94/fast-logger/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["fast_logger*"]
+
+
+
+[tool.black]
+line-length = 88
+target-version = ['py37', 'py38', 'py39', 'py310', 'py311']
+
+[tool.mypy]
+python_version = "3.7"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true

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

@@ -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/python_fast_logger.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.cfg
+fast_logger/__init__.py
+fast_logger/core.py
+python_fast_logger.egg-info/PKG-INFO
+python_fast_logger.egg-info/SOURCES.txt
+python_fast_logger.egg-info/dependency_links.txt
+python_fast_logger.egg-info/requires.txt
+python_fast_logger.egg-info/top_level.txt
+tests/test_fast_logger.py

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

@@ -0,0 +1 @@
+

python_fast_logger-0.1.0/python_fast_logger.egg-info/requires.txt

@@ -0,0 +1,7 @@
+
+[dev]
+pytest>=6.0
+pytest-cov>=2.0
+black>=21.0
+flake8>=3.8
+mypy>=0.800

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

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

python_fast_logger-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

python_fast_logger-0.1.0/tests/test_fast_logger.py

@@ -0,0 +1,209 @@
+import unittest
+import tempfile
+import shutil
+import logging
+from pathlib import Path
+from fast_logger import FastLogger, quick_logger, get_logger, setup_logger
+
+
+class TestFastLogger(unittest.TestCase):
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.test_name = "test_logger"
+
+    def tearDown(self):
+        """Clean up after tests."""
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def test_basic_logger_creation(self):
+        """Test basic logger creation."""
+        logger = FastLogger(
+            name=self.test_name,
+            base_path=self.temp_dir
+        )
+
+        self.assertIsNotNone(logger.get_logger())
+        self.assertEqual(logger.name, self.test_name)
+        self.assertEqual(logger.level, logging.INFO)
+
+    def test_log_file_creation(self):
+        """Test that log files are created."""
+        logger = FastLogger(
+            name=self.test_name,
+            base_path=self.temp_dir
+        )
+
+        logger.info("Test message")
+
+        # Force flush to ensure file is written
+        for handler in logger.get_logger().handlers:
+            if hasattr(handler, 'flush'):
+                handler.flush()
+
+        log_file = Path(self.temp_dir) / "logs" / f"{self.test_name}.log"
+        self.assertTrue(log_file.exists())
+
+    def test_log_content(self):
+        """Test that log content is written correctly."""
+        logger = FastLogger(
+            name=self.test_name,
+            base_path=self.temp_dir,
+            console_output=False  # Only file output for testing
+        )
+
+        test_message = "Test log message"
+        logger.info(test_message)
+
+        # Force flush to ensure file is written
+        for handler in logger.get_logger().handlers:
+            if hasattr(handler, 'flush'):
+                handler.flush()
+
+        log_file = Path(self.temp_dir) / "logs" / f"{self.test_name}.log"
+        with open(log_file, 'r') as f:
+            content = f.read()
+
+        self.assertIn(test_message, content)
+        self.assertIn("INFO", content)
+
+    def test_different_log_levels(self):
+        """Test different logging levels."""
+        logger = FastLogger(
+            name=self.test_name,
+            base_path=self.temp_dir,
+            level=logging.DEBUG,
+            console_output=False
+        )
+
+        logger.debug("Debug message")
+        logger.info("Info message")
+        logger.warning("Warning message")
+        logger.error("Error message")
+        logger.critical("Critical message")
+
+        # Force flush to ensure file is written
+        for handler in logger.get_logger().handlers:
+            if hasattr(handler, 'flush'):
+                handler.flush()
+
+        log_file = Path(self.temp_dir) / "logs" / f"{self.test_name}.log"
+        with open(log_file, 'r') as f:
+            content = f.read()
+
+        self.assertIn("DEBUG", content)
+        self.assertIn("INFO", content)
+        self.assertIn("WARNING", content)
+        self.assertIn("ERROR", content)
+        self.assertIn("CRITICAL", content)
+
+    def test_string_level_parsing(self):
+        """Test string level parsing."""
+        logger = FastLogger(
+            name=self.test_name,
+            base_path=self.temp_dir,
+            level="DEBUG"
+        )
+
+        self.assertEqual(logger.level, logging.DEBUG)
+
+        logger = FastLogger(
+            name=self.test_name + "2",
+            base_path=self.temp_dir,
+            level="warning"
+        )
+
+        self.assertEqual(logger.level, logging.WARNING)
+
+    def test_custom_log_folder(self):
+        """Test custom log folder."""
+        custom_folder = "custom_logs"
+        logger = FastLogger(
+            name=self.test_name,
+            base_path=self.temp_dir,
+            log_folder=custom_folder
+        )
+
+        logger.info("Test message")
+
+        # Force flush to ensure file is written
+        for handler in logger.get_logger().handlers:
+            if hasattr(handler, 'flush'):
+                handler.flush()
+
+        log_file = Path(self.temp_dir) / custom_folder / f"{self.test_name}.log"
+        self.assertTrue(log_file.exists())
+
+    def test_quick_logger_function(self):
+        """Test quick_logger convenience function."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # This is tricky to test since quick_logger uses caller's directory
+            # We'll just test that it returns a logger
+            logger = quick_logger(self.test_name)
+            self.assertIsInstance(logger, logging.Logger)
+            self.assertEqual(logger.name, self.test_name)
+
+    def test_get_logger_function(self):
+        """Test get_logger convenience function."""
+        logger = get_logger(self.test_name, base_path=self.temp_dir)
+        self.assertIsInstance(logger, FastLogger)
+        self.assertEqual(logger.name, self.test_name)
+
+    def test_setup_logger_function(self):
+        """Test setup_logger convenience function."""
+        logger = setup_logger(self.test_name, base_path=self.temp_dir)
+        self.assertIsInstance(logger, logging.Logger)
+        self.assertEqual(logger.name, self.test_name)
+
+    def test_no_duplicate_handlers(self):
+        """Test that creating the same logger twice doesn't duplicate handlers."""
+        logger1 = FastLogger(name=self.test_name, base_path=self.temp_dir)
+        initial_handler_count = len(logger1.get_logger().handlers)
+
+        logger2 = FastLogger(name=self.test_name, base_path=self.temp_dir)
+        final_handler_count = len(logger2.get_logger().handlers)
+
+        self.assertEqual(initial_handler_count, final_handler_count)
+
+    def test_console_output_disabled(self):
+        """Test logger with console output disabled."""
+        logger = FastLogger(
+            name=self.test_name,
+            base_path=self.temp_dir,
+            console_output=False
+        )
+
+        # Should have only file handler
+        handlers = logger.get_logger().handlers
+        self.assertEqual(len(handlers), 1)
+        self.assertTrue(any(handler.__class__.__name__ == 'RotatingFileHandler'
+                            for handler in handlers))
+
+    def test_custom_format(self):
+        """Test custom log format."""
+        custom_format = "%(levelname)s: %(message)s"
+        logger = FastLogger(
+            name=self.test_name,
+            base_path=self.temp_dir,
+            log_format=custom_format,
+            console_output=False
+        )
+
+        logger.info("Test message")
+
+        # Force flush to ensure file is written
+        for handler in logger.get_logger().handlers:
+            if hasattr(handler, 'flush'):
+                handler.flush()
+
+        log_file = Path(self.temp_dir) / "logs" / f"{self.test_name}.log"
+        with open(log_file, 'r') as f:
+            content = f.read().strip()
+
+        # Should match our custom format
+        self.assertTrue(content.startswith("INFO: Test message"))
+
+
+if __name__ == '__main__':
+    unittest.main()