fsvlog 0.3.2__py3-none-any.whl

fsvlog/__init__.py

@@ -0,0 +1,18 @@
+__version__ = "0.4.0"
+
+from typing import Tuple
+from .fsvlog import FSVLog, Colors, create_logger
+
+__all__: Tuple[str, ...] = (
+    "FSVLog",
+    "Colors",
+    "create_logger",
+)
+
+def __dir__() -> Tuple[str, ...]:
+    return __all__ + ("__version__", "__doc__")
+
+def __getattr__(name: str) -> object:
+    if name not in __all__:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    return globals()[name]

fsvlog/fsvlog.py

@@ -0,0 +1,381 @@
+import os
+import json
+import inspect
+import sys
+import traceback
+from datetime import datetime
+from typing import Optional, Dict, Any, List
+from collections import defaultdict
+
+
+class Colors:
+    @staticmethod
+    def colorize(text: str, rgb: tuple) -> str:
+        r, g, b = rgb
+        r = max(0, min(255, r))
+        g = max(0, min(255, g))
+        b = max(0, min(255, b))
+        return f"\033[38;2;{r};{g};{b}m{text}\033[0m"
+
+    GREEN = (0, 255, 0)
+    RED = (255, 0, 0)
+    BLUE = (0, 0, 255)
+    YELLOW = (255, 255, 0)
+    CYAN = (0, 255, 255)
+    MAGENTA = (255, 0, 255)
+    WHITE = (255, 255, 255)
+    GRAY = (128, 128, 128)
+
+
+LOG_LEVELS = {
+    'DEBUG': 10,
+    'INFO': 20,
+    'WARNING': 30,
+    'ERROR': 40,
+    'FATAL': 50
+}
+
+
+class FSVLog:
+    def __init__(self, log_folder_path: str = "Logs", max_logs: int = 10,
+                 max_file_size_mb: int = 100, log_format: str = None,
+                 time_format: str = None, filename_time_format: str = None,
+                 file_only: bool = False, console_only: bool = False,
+                 use_json: bool = False, log_level: str = "DEBUG",
+                 enable_metrics: bool = False,
+                 enable_global_exception_logging: bool = True,
+                 exception_format: str = "compact"):
+
+        if not isinstance(log_folder_path, str) or log_folder_path == "":
+            raise ValueError("log_folder_path must be a non-empty string")
+        if not isinstance(max_logs, int) or max_logs <= 0:
+            raise ValueError("max_logs must be a positive integer")
+        if not isinstance(max_file_size_mb, int) or max_file_size_mb <= 0:
+            raise ValueError("max_file_size_mb must be a positive integer")
+        if not isinstance(file_only, bool):
+            raise ValueError("file_only must be a boolean")
+        if not isinstance(console_only, bool):
+            raise ValueError("console_only must be a boolean")
+        if not isinstance(use_json, bool):
+            raise ValueError("use_json must be a boolean")
+        if not isinstance(exception_format, str):
+            raise ValueError("exception_format must be a string")
+        if exception_format not in ["full", "compact", "minimal"]:
+            raise ValueError("exception_format must be 'full', 'compact', or 'minimal'")
+        if file_only and console_only:
+            raise ValueError("file_only and console_only cannot both be True")
+
+        self.log_folder_path = log_folder_path
+        self.max_logs = max_logs
+        self.max_file_size = max_file_size_mb * 1024 * 1024
+        self.log_format = log_format or "{timestamp} [{level}] {message}"
+        self.time_format = time_format or "%Y-%m-%dT%H:%M:%S.%f"
+        self.filename_time_format = filename_time_format or "%Y%m%d_%H%M%S_%f"
+        self.file_only = file_only
+        self.console_only = console_only
+        self.use_json = use_json
+        self.log_level = LOG_LEVELS.get(log_level.upper(), 20)
+        self.enable_metrics = enable_metrics
+        self.exception_format = exception_format
+
+        self._needs_caller_info = any(x in self.log_format for x in ['filename', 'lineno', 'funcname'])
+
+        self.colors = Colors()
+        self._current_log_file = None
+        self._bound_context = {}
+        self._original_excepthook = None
+
+        if enable_metrics:
+            self.metrics = defaultdict(int)
+
+        if not self.console_only:
+            os.makedirs(self.log_folder_path, exist_ok=True)
+            self._open_log_file()
+            self._manage_log_files()
+
+        if enable_global_exception_logging:
+            self.enable_global_exception_logging()
+
+    def _should_log(self, level: str) -> bool:
+        return LOG_LEVELS.get(level, 20) >= self.log_level
+
+    def _update_metrics(self, level: str):
+        if self.enable_metrics:
+            self.metrics[level] += 1
+
+    def _get_timestamp(self) -> str:
+        now = datetime.now()
+        if self.time_format == "%Y-%m-%dT%H:%M:%S.%f":
+            result = now.strftime(self.time_format)[:-3]
+            return result + "Z"
+        elif self.time_format.endswith(".%f"):
+            result = now.strftime(self.time_format)[:-3]
+            return result
+        else:
+            return now.strftime(self.time_format)
+
+    def _get_timestamp_for_filename(self) -> str:
+        now = datetime.now()
+        result = now.strftime(self.filename_time_format)
+        if "%f" in self.filename_time_format:
+            result = result[:-3]
+        return result
+
+    def _get_caller_info(self) -> Dict[str, Any]:
+        if not self._needs_caller_info:
+            return {}
+        try:
+            frame = inspect.currentframe()
+            for _ in range(3):
+                if frame:
+                    frame = frame.f_back
+            if frame and frame.f_code.co_name in ['_log', 'info', 'error', 'warning', 'debug', 'fatal', 'custom',
+                                                  'exception']:
+                frame = frame.f_back
+            if frame:
+                return {
+                    'filename': os.path.basename(frame.f_code.co_filename),
+                    'lineno': frame.f_lineno,
+                    'funcname': frame.f_code.co_name
+                }
+        except Exception:
+            pass
+        return {'filename': 'unknown', 'lineno': 0, 'funcname': 'unknown'}
+
+    def _open_log_file(self):
+        filename = f"log_{self._get_timestamp_for_filename()}.log"
+        self.log_file_path = os.path.join(self.log_folder_path, filename)
+        self._current_log_file = open(self.log_file_path, "a", encoding="utf-8")
+
+    def _rotate_log_file(self):
+        if self._current_log_file:
+            self._current_log_file.close()
+
+        timestamp = self._get_timestamp_for_filename()
+        rotated_name = os.path.join(self.log_folder_path, f"log_{timestamp}.log")
+        os.rename(self.log_file_path, rotated_name)
+        self._open_log_file()
+
+    def _manage_log_files(self):
+        log_files = [
+            os.path.join(self.log_folder_path, f)
+            for f in os.listdir(self.log_folder_path)
+            if os.path.isfile(os.path.join(self.log_folder_path, f)) and f.endswith('.log')
+        ]
+        log_files.sort(key=os.path.getctime)
+        while len(log_files) > self.max_logs:
+            try:
+                os.remove(log_files.pop(0))
+            except Exception as e:
+                print(f"Failed to remove old log file: {e}")
+
+    def _format_log_entry(self, message: str, level: str, extra: Dict[str, Any] = None) -> str:
+        timestamp = self._get_timestamp()
+        caller = self._get_caller_info()
+        context = {**self._bound_context}
+        if extra:
+            context.update(extra)
+        log_type = context.pop('type', '')
+        if self.use_json:
+            log_data = {
+                "timestamp": timestamp,
+                "level": level,
+                "message": message,
+                "pid": os.getpid(),
+                **context,
+                **caller
+            }
+            if log_type:
+                log_data['type'] = log_type
+            return json.dumps(log_data)
+
+        context_str = json.dumps(context, ensure_ascii=False) if context else ""
+        format_vars = {
+            'timestamp': timestamp,
+            'level': level,
+            'message': message,
+            'context': context_str,
+            'type': log_type,
+            **caller,
+            **context
+        }
+        try:
+            result = self.log_format.format(**format_vars)
+            if not log_type:
+                result = result.replace("[{type}]", "").replace("{type}", "").replace("  ", " ").replace("[]", "")
+                while "  " in result:
+                    result = result.replace("  ", " ")
+            if not context_str:
+                while "  " in result:
+                    result = result.replace("  ", " ")
+
+            return result.strip()
+        except KeyError as e:
+            return f"{timestamp} [{level}] ERROR: Invalid format key {e} - {message}"
+
+    def _write_to_file(self, log_entry: str):
+        if self.console_only:
+            return
+        try:
+            if os.path.getsize(self.log_file_path) > self.max_file_size:
+                self._rotate_log_file()
+            self._current_log_file.write(log_entry + "\n")
+            self._current_log_file.flush()
+        except Exception as e:
+            if not self.file_only:
+                error_msg = self._format_log_entry(f"Failed to write to log file: {e}", "ERROR")
+                print(self.colors.colorize(error_msg, Colors.RED))
+
+    def _log(self, message: str, level: str, color: tuple = None, extra: Dict[str, Any] = None):
+        if not self._should_log(level):
+            return None
+        self._update_metrics(level)
+        log_entry = self._format_log_entry(message, level, extra)
+        if not self.file_only:
+            if color:
+                print(self.colors.colorize(log_entry, color))
+            else:
+                print(log_entry)
+        if not self.console_only:
+            self._write_to_file(log_entry)
+        return log_entry
+
+    def _global_exception_handler(self, exc_type, exc_value, exc_traceback):
+        if exc_type is not KeyboardInterrupt:
+            filename = "unknown"
+            lineno = 0
+            funcname = "unknown"
+            if exc_traceback:
+                tb = exc_traceback
+                while tb.tb_next:
+                    tb = tb.tb_next
+                frame = tb.tb_frame
+                filename = os.path.basename(frame.f_code.co_filename)
+                lineno = tb.tb_lineno
+                funcname = frame.f_code.co_name
+
+            if self.exception_format == "compact":
+                error_msg = f"Exception in {filename}:{lineno} ({funcname}): {exc_type.__name__}: {exc_value}"
+            elif self.exception_format == "minimal":
+                error_msg = f"{exc_type.__name__}: {exc_value} [{filename}:{lineno}]"
+            else:
+                tb_text = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+                error_msg = f"Unhandled exception in [{filename}:{lineno}] ({funcname}):\n{tb_text}"
+
+            old_needs_caller = self._needs_caller_info
+            old_format = self.log_format
+            self._needs_caller_info = False
+            self.log_format = "{timestamp} [{level}] {message}"
+            self._log(error_msg, "FATAL", Colors.MAGENTA)
+            self._needs_caller_info = old_needs_caller
+            self.log_format = old_format
+
+    def enable_global_exception_logging(self):
+        self._original_excepthook = sys.excepthook
+        sys.excepthook = lambda *args: self._global_exception_handler(*args)
+
+    def set_exception_format(self, format: str):
+        if format not in ["full", "compact", "minimal"]:
+            raise ValueError("format must be 'full', 'compact', or 'minimal'")
+        self.exception_format = format
+
+    def bind(self, **kwargs) -> 'FSVLog':
+        new_logger = FSVLog(
+            log_folder_path=self.log_folder_path,
+            max_logs=self.max_logs,
+            max_file_size_mb=self.max_file_size // (1024 * 1024),
+            log_format=self.log_format,
+            time_format=self.time_format,
+            filename_time_format=self.filename_time_format,
+            file_only=self.file_only,
+            console_only=self.console_only,
+            use_json=self.use_json,
+            log_level=self._get_log_level_name(),
+            enable_metrics=self.enable_metrics,
+            exception_format=self.exception_format
+        )
+        new_logger._bound_context = {**self._bound_context, **kwargs}
+        return new_logger
+
+    def type(self, log_type: str) -> 'FSVLog':
+        return self.bind(type=log_type)
+
+    def _get_log_level_name(self) -> str:
+        for name, value in LOG_LEVELS.items():
+            if value == self.log_level:
+                return name
+        return "INFO"
+
+    def set_log_level(self, level: str):
+        self.log_level = LOG_LEVELS.get(level.upper(), 20)
+
+    def set_time_format(self, time_format: str):
+        self.time_format = time_format
+
+    def set_log_format(self, log_format: str):
+        self.log_format = log_format
+        self._needs_caller_info = any(x in log_format for x in ['filename', 'lineno', 'funcname'])
+
+    def exception(self, message: str, extra: Dict[str, Any] = None):
+        tb = traceback.format_exc()
+        if tb and tb != "NoneType: None\n":
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            filename = "unknown"
+            lineno = 0
+            funcname = "unknown"
+            if exc_traceback:
+                tb_obj = exc_traceback
+                while tb_obj.tb_next:
+                    tb_obj = tb_obj.tb_next
+                frame = tb_obj.tb_frame
+                filename = os.path.basename(frame.f_code.co_filename)
+                lineno = tb_obj.tb_lineno
+                funcname = frame.f_code.co_name
+            if self.exception_format == "compact":
+                error_msg = f"{message}: {exc_type.__name__}: {exc_value} [{filename}:{lineno}]"
+            elif self.exception_format == "minimal":
+                error_msg = f"{message}: {exc_type.__name__}: {exc_value}"
+            else:
+                error_msg = f"{message}\n{tb}"
+        else:
+            error_msg = message
+
+        return self._log(error_msg, "ERROR", Colors.RED, extra)
+
+    def fatal(self, message: str, extra: Dict[str, Any] = None):
+        return self._log(message, "FATAL", Colors.MAGENTA, extra)
+
+    def error(self, message: str, extra: Dict[str, Any] = None):
+        return self._log(message, "ERROR", Colors.RED, extra)
+
+    def warning(self, message: str, extra: Dict[str, Any] = None):
+        return self._log(message, "WARNING", Colors.YELLOW, extra)
+
+    def info(self, message: str, extra: Dict[str, Any] = None):
+        return self._log(message, "INFO", Colors.GREEN, extra)
+
+    def debug(self, message: str, extra: Dict[str, Any] = None):
+        return self._log(message, "DEBUG", Colors.CYAN, extra)
+
+    def custom(self, message: str, level: str, color: tuple = None, extra: Dict[str, Any] = None):
+        return self._log(message, level.upper(), color, extra)
+
+    def get_current_log_file(self) -> str:
+        return self.log_file_path
+
+    def get_metrics(self) -> Dict[str, int]:
+        if not self.enable_metrics:
+            return {}
+        return dict(self.metrics)
+
+    def reset_metrics(self):
+        if self.enable_metrics:
+            self.metrics.clear()
+
+    def close(self):
+        if hasattr(self, '_current_log_file') and self._current_log_file:
+            self._current_log_file.close()
+
+
+def create_logger(log_folder_path: str = "Logs", max_logs: int = 10, **kwargs):
+    return FSVLog(log_folder_path, max_logs, **kwargs)

fsvlog-0.3.2.dist-info/METADATA

@@ -0,0 +1,290 @@
+Metadata-Version: 2.4
+Name: fsvlog
+Version: 0.3.2
+Summary: Advanced logging library with colored output, file rotation, and flexible configuration
+Author-email: Fsainv028 <fsainv028@gmail.com>
+Project-URL: Homepage, https://github.com/Fsainv028/FSVLog
+Project-URL: Repository, https://github.com/Fsainv028/FSVLog.git
+Project-URL: Release Notes, https://github.com/Fsainv028/FSVLog/releases
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+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: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Logging
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: black>=22.0; extra == "dev"
+Dynamic: license-file
+
+# FSVLog - Advanced Python Logging Library
+> A powerful and flexible logging library with colored console output, file rotation, JSON support, metrics, and global exception handling.
+
+---
+[![PyPI version](https://badge.fury.io/py/fsvlog.svg)](https://badge.fury.io/py/fsvlog)
+[![Python versions](https://img.shields.io/pypi/pyversions/fsvlog.svg)](https://pypi.org/project/fsvlog/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+
+## Features
+- 🎨 Colored output with RGB color support for console logging
+- 📁 File logging with automatic rotation and cleanup
+- 🔄 Flexible modes - File-only, console-only, or both
+- 📏 Size-based rotation to prevent log files from growing too large
+- 🗑️ Automatic cleanup to keep only the newest log files
+- ✨ Custom formatting with flexible log message templates
+- 📊 Metrics tracking to count logs by level
+- 🛡️ Global exception handling to catch and log unhandled exceptions
+- 📋 JSON format support for machine-readable logs
+- 🔗 Context binding to add persistent context to log entries
+- 🎯 Multiple log levels: DEBUG, INFO, WARNING, ERROR, FATAL
+- ⚡ Zero dependencies - pure Python, no external packages
+
+
+## Installation
+```bash
+pip install fsvlog
+```
+---
+## Quick Start
+```python
+from fsvlog import FSVLog
+
+# Create logger with default settings
+logger = FSVLog()
+
+# Log messages with different levels
+logger.debug("Debug message")
+logger.info("Info message")
+logger.warning("Warning message")
+logger.error("Error message")
+logger.fatal("Fatal message")
+```
+## Advanced Usage
+### Basic Configuration
+```python
+logger = FSVLog(
+    log_folder_path="logs",      # Log directory (default: "Logs")
+    max_logs=10,                 # Max log files to keep (default: 10)
+    max_file_size_mb=100,        # Max file size before rotation (default: 100MB)
+    log_level="INFO",            # Minimum log level (default: "DEBUG")
+    file_only=False,             # Log only to file (default: False)
+    console_only=False,          # Log only to console (default: False)
+    use_json=False,              # Use JSON format (default: False)
+    enable_metrics=False,        # Enable metrics tracking (default: False)
+    enable_global_exception_logging=True,  # Catch unhandled exceptions
+    exception_format="compact"   # "full", "compact", or "minimal"
+)
+```
+### Custom Formatting
+```python
+# Custom log format
+logger = FSVLog(
+    log_format="{timestamp} [{level}] [{filename}:{lineno}] {message}",
+    time_format="%Y-%m-%d %H:%M:%S"
+)
+
+logger.info("Custom format example")
+# Output: 2026-07-29 14:30:00 [INFO] [app.py:42] Custom format example
+```
+### Context Binding
+```python
+# Bind context to all subsequent logs
+logger = FSVLog()
+user_logger = logger.bind(user_id=123, session="abc123")
+user_logger.info("User logged in")
+# Output includes user_id and session
+
+# Type-specific logging
+auth_logger = logger.type("AUTH")
+auth_logger.info("Authentication successful")
+# Output: [AUTH] Authentication successful
+```
+### JSON Logging
+```python
+# Enable JSON format for structured logging
+logger = FSVLog(use_json=True)
+logger.info("Structured log", extra={"user": "john", "action": "login"})
+# Output: {"timestamp": "2026-07-29T14:30:00.123Z", "level": "INFO", "message": "Structured log", "user": "john", "action": "login"}
+```
+### Metrics
+```python
+# Enable metrics tracking
+logger = FSVLog(enable_metrics=True)
+logger.info("Message 1")
+logger.error("Error 1")
+logger.info("Message 2")
+
+metrics = logger.get_metrics()
+print(metrics)  # {'INFO': 2, 'ERROR': 1}
+
+logger.reset_metrics()
+```
+### Exception Handling
+```python
+logger = FSVLog(exception_format="compact")
+
+try:
+    result = 1 / 0
+except Exception:
+    logger.exception("Division by zero occurred")
+    # Output: Division by zero occurred: ZeroDivisionError: division by zero [app.py:42]
+```
+### Global Exception Logging
+```python
+# All unhandled exceptions will be automatically logged
+logger = FSVLog(enable_global_exception_logging=True)
+
+# This will be caught and logged
+def buggy_function():
+    raise RuntimeError("Something went wrong!")
+
+buggy_function()  # Automatically logged as FATAL
+```
+### Custom Colors
+```python
+# Use predefined colors
+logger.info("Success!", color=Colors.GREEN)
+logger.error("Danger!", color=Colors.RED)
+
+# Custom RGB colors
+logger.custom("Custom colored message", "CUSTOM", (255, 165, 0))  # Orange
+```
+### Log Levels
+| Level | Method | Color | Use Case |
+|----------|----------|----------|----------|
+| DEBUG | .debug() | Cyan | Detailed debugging info |
+| INFO | .info() | Green | General information |
+| WARNING | .warning() | Yellow | Warning messages |
+| ERROR | .error() | Red | Error conditions |
+| FATAL | .fatal() | Magenta | Critical errors |
+
+---
+## API Reference
+### Class: FSVLog
+Parameters:
+
+- log_folder_path (str): Path to log directory. Default: "Logs"
+- max_logs (int): Maximum number of log files to keep. Default: 10
+- max_file_size_mb (int): Maximum file size in MB before rotation. Default: 100
+- log_format (str): Custom log format template. Default: "{timestamp} [{level}] {message}"
+- time_format (str): Time format string. Default: "%Y-%m-%dT%H:%M:%S.%f"
+- filename_time_format (str): Filename time format. Default: "%Y%m%d_%H%M%S_%f"
+- file_only (bool): Log only to file. Default: False
+- console_only (bool): Log only to console. Default: False
+- use_json (bool): Use JSON format. Default: False
+- log_level (str): Minimum log level. Default: "DEBUG"
+- enable_metrics (bool): Enable metrics tracking. Default: False
+- enable_global_exception_logging (bool): Catch unhandled exceptions. Default: True
+- exception_format (str): Exception format: "full", "compact", or "minimal". Default: "compact"
+
+Available format keys:
+
+    {timestamp} - Current timestamp
+    {level} - Log level
+    {message} - Log message
+    {filename} - Source file name
+    {lineno} - Line number
+    {funcname} - Function name
+    {type} - Custom log type
+    {context} - Bound context (JSON)
+
+Methods:
+
+    debug(msg, extra=None) - Log debug message
+    info(msg, extra=None) - Log info message
+    warning(msg, extra=None) - Log warning message
+    error(msg, extra=None) - Log error message
+    fatal(msg, extra=None) - Log fatal message
+    exception(msg, extra=None) - Log exception with traceback
+    custom(msg, level, color=None, extra=None) - Log with custom level and color
+    bind(**kwargs) - Create logger with bound context
+    type(log_type) - Create logger with specific log type
+    set_log_level(level) - Change minimum log level
+    set_log_format(format) - Change log format
+    set_time_format(format) - Change time format
+    get_current_log_file() - Get current log file path
+    get_metrics() - Get metrics dictionary
+    reset_metrics() - Reset metrics
+    close() - Close log file
+    enable_global_exception_logging() - Enable global exception handler
+    set_exception_format(format) - Set exception format
+
+### Helper Function: create_logger()
+```python
+from fsvlog import create_logger
+
+logger = create_logger("logs", max_logs=5, log_level="INFO")
+```
+## Examples
+### Web Application Logging
+```python
+from fsvlog import FSVLog
+
+logger = FSVLog(log_folder_path="web_logs", enable_metrics=True)
+
+# Bind request context
+req_logger = logger.bind(request_id="req-123", user="alice")
+req_logger.info("Request received")
+req_logger.error("Database connection failed")
+
+# Type-based logging
+access_logger = logger.type("ACCESS")
+access_logger.info("GET /api/users 200")
+```
+### Microservice Logging
+```python
+logger = FSVLog(
+    log_folder_path="/var/log/myapp",
+    use_json=True,
+    enable_global_exception_logging=True,
+    exception_format="full"
+)
+
+# Add service context
+svc_logger = logger.bind(service="auth-service", version="1.2.3")
+svc_logger.info("Service started")
+```
+### Development Debugging
+```python
+import time
+from fsvlog import FSVLog
+
+logger = FSVLog(
+    console_only=True,  # Console only for development
+    log_level="DEBUG",
+    log_format="{timestamp} [{level}] [{funcname}()] {message}"
+)
+
+def process_data():
+    logger.debug("Processing data...")
+    # ... processing
+    logger.info("Data processed successfully")
+
+process_data()
+```
+---
+# License
+**MIT License - see LICENSE file for details**
+
+---
+# Contributing
+**Contributions are welcome! Please feel free to submit a Pull Request.**
+
+---
+## Support
+- **GitHub**: [Fsainv028/FSVLog](https://github.com/Fsainv028/FSVLog)
+- **Issues**: [Report a bug](https://github.com/Fsainv028/FSVLog/issues)
+- **Email**: fsainv028@gmail.com
+
+---
+Made with ❤️ by Fsainv028

fsvlog-0.3.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+fsvlog/__init__.py,sha256=iTEqkpC7PSDQe7Au48e1kvEmJky-5Ka-siIWGWAcEyY,434
+fsvlog/fsvlog.py,sha256=isA5EH2Z7mps29B_QvnaO2pUb8AYpKCIHUdMFUSWkto,14802
+fsvlog-0.3.2.dist-info/licenses/LICENSE.txt,sha256=IB9EP7RwSoUPAMI3OLuqpdMA2qfXXwvSMg1ddLJFoMU,1091
+fsvlog-0.3.2.dist-info/METADATA,sha256=VxpIQzp63w5J6UtccXPrcSko4gpJwt9tvl9RlQMUXVA,10073
+fsvlog-0.3.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+fsvlog-0.3.2.dist-info/top_level.txt,sha256=ZcNecbCB2QfYomNWys6x8m7L4d7-nCGXHTl72cxs6Rs,7
+fsvlog-0.3.2.dist-info/RECORD,,

fsvlog-0.3.2.dist-info/WHEEL

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

fsvlog-0.3.2.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [Fsainv028]
+
+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.

fsvlog-0.3.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+fsvlog