python-coloured-logger 0.1.1__tar.gz

python_coloured_logger-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Skulldorom
+
+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_coloured_logger-0.1.1/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: python-coloured-logger
+Version: 0.1.1
+Summary: Simple coloured logging for Flask and FastAPI apps
+Author: Skulldorom
+License-Expression: MIT
+Keywords: logging,flask,fastapi,color
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# python-coloured-logger
+
+A lightweight Python package that provides clean, coloured logging output for Flask, FastAPI, and any standard Python application.
+
+It extends Python’s built-in `logging` module with readable coloured console output and simple setup helpers.
+
+---
+
+## Features
+
+- Coloured console logging
+- Works with standard Python `logging`
+- Flask integration
+- FastAPI / Uvicorn integration
+- Simple setup API
+- Lightweight with minimal configuration
+
+---
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install python-coloured-logger
+```
+
+---
+
+## Quick Start
+
+```python
+from coloured_logger import get_logger
+
+logger = get_logger("my-app")
+
+logger.debug("Debug message")
+logger.info("Server started")
+logger.success("Database connected")
+logger.warning("High memory usage")
+logger.error("Request failed")
+logger.critical("System crash")
+```
+
+Example output:
+
+```text
+[2026-05-27 12:00:00] INFO     Server started
+[2026-05-27 12:00:01] SUCCESS  Database connected
+[2026-05-27 12:00:02] WARNING  High memory usage
+[2026-05-27 12:00:03] ERROR    Request failed
+```
+
+---
+
+## Flask Integration
+
+```python
+from flask import Flask
+from coloured_logger import setup_logging
+
+app = Flask(__name__)
+
+setup_logging(logger_name="flask.app")
+
+@app.route("/")
+def index():
+    app.logger.info("Request received")
+    return "Hello World"
+```
+
+---
+
+## FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from coloured_logger import setup_logging
+
+app = FastAPI()
+
+setup_logging(logger_name="uvicorn")
+
+@app.get("/")
+async def root():
+    return {"message": "Hello World"}
+```
+
+---
+
+## Standard Python Logging
+
+```python
+from coloured_logger import setup_logging
+import logging
+
+setup_logging()
+
+logger = logging.getLogger("example")
+
+logger.info("Using standard logging")
+```
+
+---
+
+## Environment Variables
+
+### Enable or Disable Colours
+
+By default, colours are enabled.
+
+```bash
+COLOURED_LOGGER_COLOR=True
+```
+
+or for Flask-specific configuration:
+
+```bash
+FLASK_LOG_COLOR=True
+```
+
+Disable colours:
+
+```bash
+COLOURED_LOGGER_COLOR=False
+```
+
+---
+
+### Custom Date Format
+
+```bash
+COLOURED_LOGGER_DATE_FORMAT=%Y-%m-%d %H:%M:%S
+```
+
+or:
+
+```bash
+FLASK_LOG_DATE_FORMAT=%H:%M:%S
+```
+
+---
+
+## Supported Log Levels
+
+| Level | Description |
+|---|---|
+| `debug` | Debug information |
+| `info` | General information |
+| `success` | Successful operations |
+| `warning` | Warning messages |
+| `error` | Error messages |
+| `critical` | Critical failures |
+
+---
+
+
+## Requirements
+
+- Python 3.9+
+- Flask (optional)
+- FastAPI / Uvicorn (optional)
+
+---
+
+## License
+
+MIT License
+
+---
+
+## Contributing
+
+Pull requests, issues, and suggestions are welcome.
+
+If you find a bug or want to improve the package, feel free to open an issue or submit a PR.
+
+---
+
+## Links
+
+- PyPI: `https://pypi.org/project/python-coloured-logger/`
+- GitHub: `https://github.com/Skulldorom/python-coloured-logger`

python_coloured_logger-0.1.1/README.md

@@ -0,0 +1,183 @@
+# python-coloured-logger
+
+A lightweight Python package that provides clean, coloured logging output for Flask, FastAPI, and any standard Python application.
+
+It extends Python’s built-in `logging` module with readable coloured console output and simple setup helpers.
+
+---
+
+## Features
+
+- Coloured console logging
+- Works with standard Python `logging`
+- Flask integration
+- FastAPI / Uvicorn integration
+- Simple setup API
+- Lightweight with minimal configuration
+
+---
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install python-coloured-logger
+```
+
+---
+
+## Quick Start
+
+```python
+from coloured_logger import get_logger
+
+logger = get_logger("my-app")
+
+logger.debug("Debug message")
+logger.info("Server started")
+logger.success("Database connected")
+logger.warning("High memory usage")
+logger.error("Request failed")
+logger.critical("System crash")
+```
+
+Example output:
+
+```text
+[2026-05-27 12:00:00] INFO     Server started
+[2026-05-27 12:00:01] SUCCESS  Database connected
+[2026-05-27 12:00:02] WARNING  High memory usage
+[2026-05-27 12:00:03] ERROR    Request failed
+```
+
+---
+
+## Flask Integration
+
+```python
+from flask import Flask
+from coloured_logger import setup_logging
+
+app = Flask(__name__)
+
+setup_logging(logger_name="flask.app")
+
+@app.route("/")
+def index():
+    app.logger.info("Request received")
+    return "Hello World"
+```
+
+---
+
+## FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from coloured_logger import setup_logging
+
+app = FastAPI()
+
+setup_logging(logger_name="uvicorn")
+
+@app.get("/")
+async def root():
+    return {"message": "Hello World"}
+```
+
+---
+
+## Standard Python Logging
+
+```python
+from coloured_logger import setup_logging
+import logging
+
+setup_logging()
+
+logger = logging.getLogger("example")
+
+logger.info("Using standard logging")
+```
+
+---
+
+## Environment Variables
+
+### Enable or Disable Colours
+
+By default, colours are enabled.
+
+```bash
+COLOURED_LOGGER_COLOR=True
+```
+
+or for Flask-specific configuration:
+
+```bash
+FLASK_LOG_COLOR=True
+```
+
+Disable colours:
+
+```bash
+COLOURED_LOGGER_COLOR=False
+```
+
+---
+
+### Custom Date Format
+
+```bash
+COLOURED_LOGGER_DATE_FORMAT=%Y-%m-%d %H:%M:%S
+```
+
+or:
+
+```bash
+FLASK_LOG_DATE_FORMAT=%H:%M:%S
+```
+
+---
+
+## Supported Log Levels
+
+| Level | Description |
+|---|---|
+| `debug` | Debug information |
+| `info` | General information |
+| `success` | Successful operations |
+| `warning` | Warning messages |
+| `error` | Error messages |
+| `critical` | Critical failures |
+
+---
+
+
+## Requirements
+
+- Python 3.9+
+- Flask (optional)
+- FastAPI / Uvicorn (optional)
+
+---
+
+## License
+
+MIT License
+
+---
+
+## Contributing
+
+Pull requests, issues, and suggestions are welcome.
+
+If you find a bug or want to improve the package, feel free to open an issue or submit a PR.
+
+---
+
+## Links
+
+- PyPI: `https://pypi.org/project/python-coloured-logger/`
+- GitHub: `https://github.com/Skulldorom/python-coloured-logger`

python_coloured_logger-0.1.1/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "python-coloured-logger"
+version = "0.1.1"
+description = "Simple coloured logging for Flask and FastAPI apps"
+readme = "README.md"
+requires-python = ">=3.8"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Skulldorom" }]
+keywords = ["logging", "flask", "fastapi", "color"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Operating System :: OS Independent",
+]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

python_coloured_logger-0.1.1/setup.cfg

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

python_coloured_logger-0.1.1/src/coloured_logger/__init__.py

@@ -0,0 +1,3 @@
+from .formatter import ColouredFormatter, SUCCESS_LEVEL, get_logger, log, setup_logging
+
+__all__ = ["ColouredFormatter", "SUCCESS_LEVEL", "get_logger", "log", "setup_logging"]

python_coloured_logger-0.1.1/src/coloured_logger/formatter.py

@@ -0,0 +1,119 @@
+import logging
+import os
+from typing import Optional, TextIO
+
+SUCCESS_LEVEL = 25
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _resolve_use_color(use_color: Optional[bool]) -> bool:
+    if use_color is not None:
+        return use_color
+    if os.getenv("FLASK_LOG_COLOR") is not None:
+        return _env_bool("FLASK_LOG_COLOR", True)
+    return _env_bool("COLOURED_LOGGER_COLOR", True)
+
+
+def _resolve_datefmt(datefmt: Optional[str]) -> str:
+    if datefmt:
+        return datefmt
+    return os.getenv("FLASK_LOG_DATE_FORMAT") or os.getenv("COLOURED_LOGGER_DATE_FORMAT") or "%d/%b/%Y %H:%M:%S"
+
+
+class ColouredFormatter(logging.Formatter):
+    RESET = "\033[0m"
+    DEFAULT_COLORS = {
+        logging.DEBUG: "\033[36m",
+        logging.INFO: "\033[34m",
+        SUCCESS_LEVEL: "\033[32m",
+        logging.WARNING: "\033[33m",
+        logging.ERROR: "\033[31m",
+        logging.CRITICAL: "\033[35m",
+    }
+
+    def __init__(
+        self,
+        fmt: Optional[str] = None,
+        datefmt: Optional[str] = None,
+        use_color: Optional[bool] = None,
+    ) -> None:
+        self.use_color = _resolve_use_color(use_color)
+        super().__init__(
+            fmt=fmt or "[%(asctime)s] [%(levelname)s] %(message)s",
+            datefmt=_resolve_datefmt(datefmt),
+        )
+
+    def format(self, record: logging.LogRecord) -> str:
+        message = super().format(record)
+        if not self.use_color:
+            return message
+        color = self.DEFAULT_COLORS.get(record.levelno)
+        if not color:
+            return message
+        return f"{color}{message}{self.RESET}"
+
+
+def _ensure_success_level() -> None:
+    if logging.getLevelName(SUCCESS_LEVEL) != "SUCCESS":
+        logging.addLevelName(SUCCESS_LEVEL, "SUCCESS")
+
+    if hasattr(logging.Logger, "success"):
+        return
+
+    def success(self: logging.Logger, msg: str, *args, **kwargs) -> None:
+        if self.isEnabledFor(SUCCESS_LEVEL):
+            self._log(SUCCESS_LEVEL, msg, args, **kwargs)
+
+    setattr(logging.Logger, "success", success)
+
+
+def setup_logging(
+    logger_name: Optional[str] = None,
+    level: int = logging.INFO,
+    stream: Optional[TextIO] = None,
+    use_color: Optional[bool] = None,
+    datefmt: Optional[str] = None,
+    fmt: Optional[str] = None,
+) -> logging.Logger:
+    _ensure_success_level()
+    logger = logging.getLogger(logger_name)
+    logger.setLevel(level)
+
+    managed_handler_exists = any(
+        isinstance(handler, logging.StreamHandler) and isinstance(handler.formatter, ColouredFormatter)
+        for handler in logger.handlers
+    )
+    if not managed_handler_exists:
+        handler = logging.StreamHandler(stream)
+        handler.setFormatter(ColouredFormatter(fmt=fmt, datefmt=datefmt, use_color=use_color))
+        logger.addHandler(handler)
+
+    return logger
+
+
+def get_logger(name: Optional[str] = None, **kwargs) -> logging.Logger:
+    return setup_logging(logger_name=name, **kwargs)
+
+
+class log:
+    def __init__(self, *messages) -> None:
+        self.string = "".join(str(message) for message in messages)
+        self.logger = get_logger(__name__)
+
+    def success(self) -> None:
+        self.logger.success(self.string)
+
+    def info(self) -> None:
+        self.logger.info(self.string)
+
+    def warning(self) -> None:
+        self.logger.warning(self.string)
+
+    def error(self) -> None:
+        self.logger.error(self.string)

python_coloured_logger-0.1.1/src/python_coloured_logger.egg-info/PKG-INFO

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: python-coloured-logger
+Version: 0.1.1
+Summary: Simple coloured logging for Flask and FastAPI apps
+Author: Skulldorom
+License-Expression: MIT
+Keywords: logging,flask,fastapi,color
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# python-coloured-logger
+
+A lightweight Python package that provides clean, coloured logging output for Flask, FastAPI, and any standard Python application.
+
+It extends Python’s built-in `logging` module with readable coloured console output and simple setup helpers.
+
+---
+
+## Features
+
+- Coloured console logging
+- Works with standard Python `logging`
+- Flask integration
+- FastAPI / Uvicorn integration
+- Simple setup API
+- Lightweight with minimal configuration
+
+---
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install python-coloured-logger
+```
+
+---
+
+## Quick Start
+
+```python
+from coloured_logger import get_logger
+
+logger = get_logger("my-app")
+
+logger.debug("Debug message")
+logger.info("Server started")
+logger.success("Database connected")
+logger.warning("High memory usage")
+logger.error("Request failed")
+logger.critical("System crash")
+```
+
+Example output:
+
+```text
+[2026-05-27 12:00:00] INFO     Server started
+[2026-05-27 12:00:01] SUCCESS  Database connected
+[2026-05-27 12:00:02] WARNING  High memory usage
+[2026-05-27 12:00:03] ERROR    Request failed
+```
+
+---
+
+## Flask Integration
+
+```python
+from flask import Flask
+from coloured_logger import setup_logging
+
+app = Flask(__name__)
+
+setup_logging(logger_name="flask.app")
+
+@app.route("/")
+def index():
+    app.logger.info("Request received")
+    return "Hello World"
+```
+
+---
+
+## FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from coloured_logger import setup_logging
+
+app = FastAPI()
+
+setup_logging(logger_name="uvicorn")
+
+@app.get("/")
+async def root():
+    return {"message": "Hello World"}
+```
+
+---
+
+## Standard Python Logging
+
+```python
+from coloured_logger import setup_logging
+import logging
+
+setup_logging()
+
+logger = logging.getLogger("example")
+
+logger.info("Using standard logging")
+```
+
+---
+
+## Environment Variables
+
+### Enable or Disable Colours
+
+By default, colours are enabled.
+
+```bash
+COLOURED_LOGGER_COLOR=True
+```
+
+or for Flask-specific configuration:
+
+```bash
+FLASK_LOG_COLOR=True
+```
+
+Disable colours:
+
+```bash
+COLOURED_LOGGER_COLOR=False
+```
+
+---
+
+### Custom Date Format
+
+```bash
+COLOURED_LOGGER_DATE_FORMAT=%Y-%m-%d %H:%M:%S
+```
+
+or:
+
+```bash
+FLASK_LOG_DATE_FORMAT=%H:%M:%S
+```
+
+---
+
+## Supported Log Levels
+
+| Level | Description |
+|---|---|
+| `debug` | Debug information |
+| `info` | General information |
+| `success` | Successful operations |
+| `warning` | Warning messages |
+| `error` | Error messages |
+| `critical` | Critical failures |
+
+---
+
+
+## Requirements
+
+- Python 3.9+
+- Flask (optional)
+- FastAPI / Uvicorn (optional)
+
+---
+
+## License
+
+MIT License
+
+---
+
+## Contributing
+
+Pull requests, issues, and suggestions are welcome.
+
+If you find a bug or want to improve the package, feel free to open an issue or submit a PR.
+
+---
+
+## Links
+
+- PyPI: `https://pypi.org/project/python-coloured-logger/`
+- GitHub: `https://github.com/Skulldorom/python-coloured-logger`

python_coloured_logger-0.1.1/src/python_coloured_logger.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+src/coloured_logger/__init__.py
+src/coloured_logger/formatter.py
+src/python_coloured_logger.egg-info/PKG-INFO
+src/python_coloured_logger.egg-info/SOURCES.txt
+src/python_coloured_logger.egg-info/dependency_links.txt
+src/python_coloured_logger.egg-info/top_level.txt
+tests/test_formatter.py

python_coloured_logger-0.1.1/src/python_coloured_logger.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

python_coloured_logger-0.1.1/src/python_coloured_logger.egg-info/top_level.txt

@@ -0,0 +1 @@
+coloured_logger

python_coloured_logger-0.1.1/tests/test_formatter.py

@@ -0,0 +1,31 @@
+import io
+import logging
+import unittest
+
+from coloured_logger import ColouredFormatter, setup_logging
+
+
+class FormatterTests(unittest.TestCase):
+    def test_formatter_without_color(self):
+        formatter = ColouredFormatter(use_color=False, datefmt="%Y")
+        record = logging.LogRecord("test", logging.INFO, __file__, 1, "hello", (), None)
+        output = formatter.format(record)
+        self.assertIn("[INFO] hello", output)
+        self.assertNotIn("\033[", output)
+
+    def test_logger_adds_success_level_output(self):
+        stream = io.StringIO()
+        logger = setup_logging(
+            logger_name="coloured_logger_test",
+            level=logging.DEBUG,
+            stream=stream,
+            use_color=False,
+            datefmt="%Y",
+        )
+        logger.success("done")
+        value = stream.getvalue()
+        self.assertIn("[SUCCESS] done", value)
+
+
+if __name__ == "__main__":
+    unittest.main()