loggingsetup 0.0.1__py3-none-any.whl

logging_setup/__init__.py

@@ -0,0 +1,50 @@
+"""
+Initializes the application's logging system.
+
+Features:
+- Automatically creates a `logs/` directory if it doesn't exist.
+- Logs messages from DEBUG up to WARNING into `logs/app-YYYY-MM-DD.log`.
+- Logs all ERROR and CRITICAL messages into `logs/error-YYYY-MM-DD.log`.
+- Creates a new log file every day (daily rotation by date, UTC).
+- Colored console output:
+    - DEBUG — white
+    - INFO — cyan
+    - WARNING — yellow
+    - ERROR — red
+    - CRITICAL — bright red
+- STDOUT receives messages up to WARNING, STDERR receives ERROR and above.
+- Works without `logging.getLogger(__name__)`: records sent through the root
+  logger (`logging.info(...)`) get the module name (e.g. `app.bot`) instead of `root`.
+- All uncaught exceptions (`sys.excepthook`) and uncaught exceptions in threads
+  (`threading.excepthook`) are logged as ERRORs.
+- Noisy third-party loggers (urllib3, aiohttp, selenium, telethon, pyrogram,
+  asyncio, apscheduler) are limited to WARNING.
+- Old log files older than 30 days are deleted in the background:
+  once at startup and then every day (`APScheduler`, background scheduler).
+- Repeated calls of `init_logging()` are ignored.
+
+Example of generated log files:
+- logs/app-2025-06-20.log
+- logs/error-2025-06-20.log
+
+Usage:
+- Call once in the main entry script:
+      from logging_setup import init_logging
+      init_logging()
+- In all other modules just use:
+      import logging
+      logging.info("message")
+  (`logger = logging.getLogger(__name__)` still works, but is optional.)
+
+Note:
+- The module name is calculated from the file path relative to the current
+  working directory. If the project is started from another folder, pass the
+  path to `install_module_name_factory(...)`.
+- The entry script is shown as `main`, not `__main__`.
+- The system is modular and extensible via `filters.py`, `formats.py`, `cleanup_old_logs.py`.
+"""
+from .my_setup import init_logging
+
+__all__ = [
+    'init_logging',
+]

logging_setup/cleanup_old_logs.py

@@ -0,0 +1,37 @@
+import logging
+
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def cleanup_old_logs_by_filename(
+        logs_dir: str = "logs",
+        days: int = 30,
+        delete_old_logs: bool = True
+) -> None:
+    """
+    The function for deleting old logging files is automatic.
+
+    :param logs_dir: The directory where the logs are stored, from where they will be deleted.
+    :param days: Deleting logs that are older than the specified days.
+    :param delete_old_logs: A bullseye value, if True, it deletes the old logs.
+    """
+    if not delete_old_logs:
+        return
+
+    cutoff = datetime.now(timezone.utc).date() - timedelta(days=days)
+    deleted_files = 0
+
+    for file in Path(logs_dir).glob("*-????-??-??.log"):
+        try:
+            file_date = datetime.strptime(file.stem[-10:], "%Y-%m-%d").date()
+            if file_date < cutoff:
+                file.unlink()
+                deleted_files += 1
+                logger.info(f"[logging-setup] The log was deleted: {file.name}")
+        except Exception as e:
+            logger.warning(f"[logging-setup] File problem {file.name}: {e}")
+
+    logger.info(f"[logging-setup] Deleted {deleted_files} logs older than {days} days.")

logging_setup/filters.py

@@ -0,0 +1,29 @@
+import logging
+import sys
+
+
+def max_level_filter(max_level_name: str):
+    max_level = getattr(logging, max_level_name.upper(), logging.WARNING)
+
+    class MaxLevelFilter(logging.Filter):
+        def filter(self, record):
+            return record.levelno <= max_level
+
+    return MaxLevelFilter()
+
+
+def handle_exception(exc_type, exc_value, exc_traceback):
+    if issubclass(exc_type, KeyboardInterrupt):
+        sys.__excepthook__(exc_type, exc_value, exc_traceback)
+        return
+
+    logging.error("[logging-setup] Uncaught exception", exc_info=(exc_type, exc_value, exc_traceback))
+
+
+def handle_thread_exception(args):
+    if issubclass(args.exc_type, SystemExit):
+        return
+    logging.error(
+        "[logging-setup] Uncaught exception in thread",
+        exc_info=(args.exc_type, args.exc_value, args.exc_traceback),
+    )

logging_setup/formats.py

@@ -0,0 +1,61 @@
+import logging
+from functools import lru_cache
+from logging.handlers import TimedRotatingFileHandler
+from pathlib import Path
+
+from colorama import Fore, Style
+
+
+class ColorFormatter(logging.Formatter):
+    LEVEL_COLORS = {
+        logging.DEBUG: Fore.WHITE,
+        logging.INFO: Fore.CYAN,
+        logging.WARNING: Fore.YELLOW,
+        logging.ERROR: Fore.RED,
+        logging.CRITICAL: Fore.RED + Style.BRIGHT
+    }
+
+    def format(self, record):
+        color = self.LEVEL_COLORS.get(record.levelno, "")
+        message = super().format(record)
+        return f"{color}{message}{Style.RESET_ALL}"
+
+
+class DatedTimedRotatingFileHandler(TimedRotatingFileHandler):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def rotation_filename(self, default_name):
+        date_part = Path(default_name).suffix.lstrip(".")  # 2025-06-20
+        base = Path(self.baseFilename)
+        return str(base.with_name(f"{base.stem}-{date_part}.log"))
+
+
+def install_module_name_factory(project_root: str | Path | None = None) -> None:
+    """
+    Replaces the logger name 'root' with the module path (like app.bot),
+    so logging.info(...) works without logger = logging.getLogger(__name__).
+    """
+    root_dir = Path(project_root or Path.cwd()).resolve()
+
+    @lru_cache(maxsize=None)
+    def module_name(pathname: str) -> str:
+        try:
+            relative = Path(pathname).resolve().relative_to(root_dir)
+            return ".".join(relative.with_suffix("").parts)
+        except ValueError:
+            return Path(pathname).stem  # file is outside the project
+
+    old_factory = logging.getLogRecordFactory()
+
+    def factory(*args, **kwargs):
+        record = old_factory(*args, **kwargs)
+        if record.name == "root":
+            record.name = module_name(record.pathname)
+        return record
+
+    logging.setLogRecordFactory(factory)
+
+
+file_fmt = "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s"
+date_fmt = "%Y-%m-%d %H:%M:%S"

logging_setup/my_setup.py

@@ -0,0 +1,121 @@
+import logging
+import os
+import sys
+import threading
+from datetime import datetime, timezone
+
+from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.triggers.interval import IntervalTrigger
+from colorama import init
+
+from logging_setup.cleanup_old_logs import cleanup_old_logs_by_filename
+from logging_setup.filters import max_level_filter, handle_exception, handle_thread_exception
+from logging_setup.formats import ColorFormatter, file_fmt, date_fmt, DatedTimedRotatingFileHandler, \
+    install_module_name_factory
+
+_initialized = False
+
+NOISY_LOGGERS = (
+    "urllib3", "aiohttp", "selenium", "telethon",
+    "pyrogram", "asyncio", "apscheduler",
+)
+
+
+def init_logging(
+        directory: str = "logs",
+        enable_console: bool = True,
+        delete_old_logs: bool = True,
+        days_to_delete_old_logs: int = 30,
+):
+    """
+    Initialization of logging of the entire project and configuration.
+
+    :param directory: The directory where the logs (app/error) from the root of the project will be stored.
+    :param enable_console: Enable or Disable logging to the console.
+    :param delete_old_logs: Delete or Not Delete old logs.
+    :param days_to_delete_old_logs: Delete logs older than these days.
+    """
+    global _initialized
+    if _initialized:
+        return
+    _initialized = True
+
+    # Automatically reset the color
+    init(autoreset=True)
+
+    os.makedirs(directory, exist_ok=True)
+
+    color_formatter = ColorFormatter(fmt=file_fmt, datefmt=date_fmt)
+    file_formatter = logging.Formatter(fmt=file_fmt, datefmt=date_fmt)
+    handlers: list[logging.Handler] = []
+
+    # Console handlers
+    if enable_console:
+        stdout_handler = logging.StreamHandler(sys.stdout)
+        stdout_handler.setLevel(logging.DEBUG)
+        stdout_handler.setFormatter(color_formatter)
+        stdout_handler.addFilter(max_level_filter("WARNING"))
+
+        stderr_handler = logging.StreamHandler(sys.stderr)
+        stderr_handler.setLevel(logging.ERROR)
+        stderr_handler.setFormatter(color_formatter)
+
+        handlers.extend((stdout_handler, stderr_handler))
+
+    # File handlers with date rotation
+    # backupCount=0: old files are deleted only by cleanup_old_logs_by_filename
+    rotating_file = DatedTimedRotatingFileHandler(
+        filename=f"{directory}/app.log",
+        when="midnight",
+        interval=1,
+        backupCount=0,
+        encoding="utf-8",
+        utc=True,
+    )
+    rotating_file.setLevel(logging.DEBUG)
+    rotating_file.setFormatter(file_formatter)
+    rotating_file.addFilter(max_level_filter("WARNING"))
+
+    rotating_error = DatedTimedRotatingFileHandler(
+        filename=f"{directory}/error.log",
+        when="midnight",
+        interval=1,
+        backupCount=0,
+        encoding="utf-8",
+        utc=True,
+    )
+    rotating_error.setLevel(logging.ERROR)
+    rotating_error.setFormatter(file_formatter)
+
+    handlers.extend((rotating_file, rotating_error))
+
+    # Replace logger name "root" with the module name
+    install_module_name_factory()
+
+    # Root logger (force=True replaces handlers that were set before)
+    logging.basicConfig(level=logging.DEBUG, handlers=handlers, force=True)
+
+    # Make noisy libraries quiet
+    for name in NOISY_LOGGERS:
+        logging.getLogger(name).setLevel(logging.WARNING)
+
+    # Global error interception
+    sys.excepthook = handle_exception
+    threading.excepthook = handle_thread_exception
+
+    # Background cleanup of old logs
+    scheduler = BackgroundScheduler()
+    scheduler.start()
+
+    scheduler.add_job(
+        cleanup_old_logs_by_filename,
+        IntervalTrigger(days=1),
+        id="cleanup_old_logs",
+        replace_existing=True,
+        next_run_time=datetime.now(timezone.utc),
+        kwargs={
+            "delete_old_logs": delete_old_logs,
+            "days": days_to_delete_old_logs,
+            "logs_dir": directory,
+        },
+    )

loggingsetup-0.0.1.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: loggingsetup
+Version: 0.0.1
+Summary: This is an improved and customized version of logging for a quick start.
+Home-page: https://github.com/XEQU4/logging-setup
+Author: xequ4
+Author-email: b.m.04.11reg@gmail.com
+Project-URL: GitHub, https://github.com/XEQU4/logging-setup
+Keywords: logging colorama files logs shceduler archive
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: apscheduler>=3.11.3
+Requires-Dist: colorama>=0.4.6
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# logging-setup
+
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Code style](https://img.shields.io/badge/code%20style-PEP8-lightgrey.svg)](https://peps.python.org/pep-0008/)
+[![Built on](https://img.shields.io/badge/built%20on-logging-yellow.svg)](https://docs.python.org/3/library/logging.html)
+
+A ready-made configuration for Python's standard `logging` module.
+Call `init_logging()` once, and the whole project gets colored console output, daily log files, and automatic cleanup.
+
+## Features
+
+- Colored console output (DEBUG white, INFO cyan, WARNING yellow, ERROR red, CRITICAL bright red)
+- `STDOUT` gets messages up to WARNING, `STDERR` gets ERROR and above
+- Daily log files (UTC):
+  - `logs/app-YYYY-MM-DD.log` for DEBUG to WARNING
+  - `logs/error-YYYY-MM-DD.log` for ERROR and CRITICAL
+- Old logs are deleted automatically (default: older than 30 days), once at startup and then every day
+- No need for `logging.getLogger(__name__)`: `logging.info(...)` shows the real module name (for example `app.bot`) instead of `root`
+- Uncaught exceptions in the main thread and in other threads are logged as errors
+- Noisy libraries (`urllib3`, `aiohttp`, `selenium`, `telethon`, `pyrogram`, `asyncio`, `apscheduler`) are limited to WARNING
+- Calling `init_logging()` twice is safe: the second call is ignored
+
+## Requirements
+
+- Python 3.10+
+- [colorama](https://pypi.org/project/colorama/)
+- [APScheduler](https://pypi.org/project/APScheduler/)
+
+## Installation
+
+```bash
+pip install git+https://github.com/XEQU4/logging-setup.git
+```
+
+Or copy the `logging_setup/` folder into your project.
+
+## Quick start
+
+In your main script, call it once:
+
+```python
+import logging
+from logging_setup import init_logging
+
+init_logging()
+
+logging.info("Hello World!")
+```
+
+In every other module, just use the standard `logging`:
+
+```python
+import logging
+
+def run():
+    logging.info("Bot started")
+    logging.error("Something went wrong")
+```
+
+Example output:
+
+```
+2026-10-20 09:42:16 | INFO     | app.bot | Bot started
+2026-10-20 09:42:16 | ERROR    | app.bot | Something went wrong
+```
+
+> `logger = logging.getLogger(__name__)` still works if you prefer it.
+
+## Parameters
+
+| Parameter                 | Type   | Default  | Description                              |
+|---------------------------|--------|----------|------------------------------------------|
+| `directory`               | `str`  | `"logs"` | Folder for log files                     |
+| `enable_console`          | `bool` | `True`   | Turn console output on or off            |
+| `delete_old_logs`         | `bool` | `True`   | Turn automatic cleanup on or off         |
+| `days_to_delete_old_logs` | `int`  | `30`     | Delete logs older than this many days    |
+
+```python
+init_logging(directory="my_logs", enable_console=False, days_to_delete_old_logs=14)
+```
+
+## Project structure
+
+```
+logging_setup/
+в”њв”Ђв”Ђ __init__.py          # exports init_logging
+в”њв”Ђв”Ђ my_setup.py          # main setup function
+в”њв”Ђв”Ђ formats.py           # color formatter, rotating handler, module name factory
+в”њв”Ђв”Ђ filters.py           # level filters, exception hooks
+в””в”Ђв”Ђ cleanup_old_logs.py  # background cleanup of old log files
+```
+
+## Notes
+
+- The module name is calculated from the file path relative to the current working directory. If you start the project from another folder, pass the project path to `install_module_name_factory(...)`.
+- The entry script is shown as `main`, not `__main__`.
+- Old files are deleted only by the cleanup job, not by `backupCount`.

loggingsetup-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+logging_setup/__init__.py,sha256=snr6txw34CTLq1wrHGFMBm9Ja252mFxwtW9phg4HcjM,1950
+logging_setup/cleanup_old_logs.py,sha256=9CJEu7SRX7BfD7_YDaSNNp0kvdvQlcD7Owy22pf5l8Y,1259
+logging_setup/filters.py,sha256=U3mQJAdVd5vttoXwAvdn4tPIxRwXly2GzuXDJadg_vA,837
+logging_setup/formats.py,sha256=vPWgA_vqMWjL8Gw8w33Nq8aupCDDWJxeBD2yTt2rOYc,1979
+logging_setup/my_setup.py,sha256=Yk_71jLC1CiV9oxE3THHX8Zy_V5eGdXA-7gEUFKN9AE,3891
+loggingsetup-0.0.1.dist-info/METADATA,sha256=LPS4uHyJfisiEZVKpC9-ea8LPsXAYOE5FE5eHyj7mVQ,4719
+loggingsetup-0.0.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+loggingsetup-0.0.1.dist-info/top_level.txt,sha256=Eh3V7lEybRvsh8hA5WYub0Yrfllm6qZLK50nUfRTUl0,14
+loggingsetup-0.0.1.dist-info/RECORD,,

loggingsetup-0.0.1.dist-info/WHEEL

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

loggingsetup-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+logging_setup