handsome-log 0.1.0__tar.gz

handsome_log-0.1.0/LICENSE.md

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2025 Pedro Dellazzari
+
+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.

handsome_log-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: handsome-log
+Version: 0.1.0
+Summary: Universal logger with custom levels for ETL and automation processes.
+Author: Pedro Dellazzari
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: colorlog>=6.7.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# handsome_log
+
+`handsome_log` is a universal logger designed for ETL pipelines, automation tasks, and web scraping scripts in Python.
+
+This library is built on top of Python's standard `logging` module and the excellent `colorlog` package. Full credit and gratitude go to the developers of those foundational libraries.
+
+The main goal of `handsome_log` is to provide custom log levels that make it easier to structure and monitor all stages of your data processes. These levels help you track your pipeline with meaningful, semantically distinct messages.
+
+By default, the following custom levels are included:
+
+| Level        | When to Use                                         | Color        |
+|--------------|------------------------------------------------------|--------------|
+| `STARTUP`    | When initializing or starting a process              | Bold Blue    |
+| `VALIDATION` | When validating data, schema, or credentials         | Blue         |
+| `DRY_RUN`    | For simulation runs that don't commit any changes    | Purple       |
+| `SUCCESS`    | When a process completes successfully                | Bold Green   |
+| `INFO`       | For general runtime information                      | Green        |
+| `WARNING`    | When something unexpected happens, but the process continues | Yellow  |
+| `ERROR`      | When a failure occurs but the system stays alive     | Red          |
+| `CRITICAL`   | When a critical error occurs and the process halts   | Bold Red     |
+| `DEBUG`      | For detailed technical/debugging messages            | Cyan         |
+
+---
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install handsome_log
+```
+
+## Features
+Normal logging with colors
+
+Normal logging without colors
+
+For loop logging
+
+## Usage 
+To import and use the library you can use: 
+
+```bash
+#import
+from handsome_log import get_logger 
+
+#create logger object
+logger = get_logger(__name__)
+
+#testing different logging levels
+logger.startup("Startup Script")
+logger.info("General Info")
+logger.validation("Validation Logging")
+logger.dry_run("TEST RUN")
+logger.success("Success information")
+logger.warning("Warning")
+logger.error("Error")
+logger.critical("Critical Error")
+```
+
+![handsome_log_example_01](https://github.com/user-attachments/assets/dacbad77-5f89-410a-83bd-1e622f68e0ed)
+
+

handsome_log-0.1.0/README.md

@@ -0,0 +1,63 @@
+# handsome_log
+
+`handsome_log` is a universal logger designed for ETL pipelines, automation tasks, and web scraping scripts in Python.
+
+This library is built on top of Python's standard `logging` module and the excellent `colorlog` package. Full credit and gratitude go to the developers of those foundational libraries.
+
+The main goal of `handsome_log` is to provide custom log levels that make it easier to structure and monitor all stages of your data processes. These levels help you track your pipeline with meaningful, semantically distinct messages.
+
+By default, the following custom levels are included:
+
+| Level        | When to Use                                         | Color        |
+|--------------|------------------------------------------------------|--------------|
+| `STARTUP`    | When initializing or starting a process              | Bold Blue    |
+| `VALIDATION` | When validating data, schema, or credentials         | Blue         |
+| `DRY_RUN`    | For simulation runs that don't commit any changes    | Purple       |
+| `SUCCESS`    | When a process completes successfully                | Bold Green   |
+| `INFO`       | For general runtime information                      | Green        |
+| `WARNING`    | When something unexpected happens, but the process continues | Yellow  |
+| `ERROR`      | When a failure occurs but the system stays alive     | Red          |
+| `CRITICAL`   | When a critical error occurs and the process halts   | Bold Red     |
+| `DEBUG`      | For detailed technical/debugging messages            | Cyan         |
+
+---
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install handsome_log
+```
+
+## Features
+Normal logging with colors
+
+Normal logging without colors
+
+For loop logging
+
+## Usage 
+To import and use the library you can use: 
+
+```bash
+#import
+from handsome_log import get_logger 
+
+#create logger object
+logger = get_logger(__name__)
+
+#testing different logging levels
+logger.startup("Startup Script")
+logger.info("General Info")
+logger.validation("Validation Logging")
+logger.dry_run("TEST RUN")
+logger.success("Success information")
+logger.warning("Warning")
+logger.error("Error")
+logger.critical("Critical Error")
+```
+
+![handsome_log_example_01](https://github.com/user-attachments/assets/dacbad77-5f89-410a-83bd-1e622f68e0ed)
+
+

handsome_log-0.1.0/handsome_log/__init__.py

@@ -0,0 +1 @@
+from .logger import get_logger

handsome_log-0.1.0/handsome_log/config.py

@@ -0,0 +1,12 @@
+# Cores para cada nível de log, usadas pelo colorlog
+LOG_COLORS = {
+    "DEBUG": "cyan",
+    "INFO": "green",
+    "WARNING": "yellow",
+    "ERROR": "red",
+    "CRITICAL": "bold_red",
+    "SUCCESS": "bold_green",
+    "STARTUP": "bold_blue",
+    "VALIDATION": "blue",
+    "DRY_RUN": "purple",
+}

handsome_log-0.1.0/handsome_log/levels.py

@@ -0,0 +1,39 @@
+import logging
+
+# Custom log level values
+SUCCESS_LEVEL = 25
+STARTUP_LEVEL = 15
+VALIDATION_LEVEL = 21
+DRY_RUN_LEVEL = 16
+
+# Register custom levels
+logging.addLevelName(SUCCESS_LEVEL, "SUCCESS")
+logging.addLevelName(STARTUP_LEVEL, "STARTUP")
+logging.addLevelName(VALIDATION_LEVEL, "VALIDATION")
+logging.addLevelName(DRY_RUN_LEVEL, "DRY_RUN")
+
+# Custom log methods
+def success(self, message, *args, **kwargs):
+    if self.isEnabledFor(SUCCESS_LEVEL):
+        self._log(SUCCESS_LEVEL, message, args, **kwargs)
+
+def startup(self, message, *args, **kwargs):
+    if self.isEnabledFor(STARTUP_LEVEL):
+        self._log(STARTUP_LEVEL, message, args, **kwargs)
+
+def validation(self, message, *args, **kwargs):
+    if self.isEnabledFor(VALIDATION_LEVEL):
+        self._log(VALIDATION_LEVEL, message, args, **kwargs)
+
+def dry_run(self, message, *args, **kwargs):
+    if self.isEnabledFor(DRY_RUN_LEVEL):
+        self._log(DRY_RUN_LEVEL, message, args, **kwargs)
+
+def register_custom_levels():
+    """
+    Binds custom logging methods to the Logger class.
+    """
+    logging.Logger.success = success
+    logging.Logger.startup = startup
+    logging.Logger.validation = validation
+    logging.Logger.dry_run = dry_run

handsome_log-0.1.0/handsome_log/logger.py

@@ -0,0 +1,74 @@
+import logging
+import sys
+from pathlib import Path
+from typing import Optional
+
+from .config import LOG_COLORS
+from .levels import register_custom_levels
+from .loop import loop_status
+
+# Bind loop_status method to Logger
+logging.Logger.loop_status = loop_status
+register_custom_levels()
+
+
+def get_logger(
+    name: str,
+    level: int = logging.DEBUG,
+    log_to_file: bool = False,
+    log_file_path: Optional[str] = None,
+    use_colors: bool = True,
+    overwrite_handlers: bool = False,
+    show_seconds: bool = True
+) -> logging.Logger:
+    """
+    Creates a logger with color and file output support.
+
+    Args:
+        name: Logger name (usually script/module name).
+        level: Logging level (e.g., logging.INFO).
+        log_to_file: If True, writes logs to a file.
+        log_file_path: Path to the file for log output.
+        use_colors: Enables ANSI color output (terminal only).
+        overwrite_handlers: If True, clears existing handlers.
+        show_seconds: Include seconds in the log timestamp.
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    if overwrite_handlers:
+        logger.handlers.clear()
+
+    if not logger.handlers:
+        time_format = "%H:%M:%S" if show_seconds else "%H:%M"
+
+        try:
+            import colorlog
+
+            formatter = colorlog.ColoredFormatter(
+                fmt=f"%(log_color)s[%(asctime)s] [{name}] [%(levelname)s] : %(message)s",
+                datefmt=time_format,
+                log_colors=LOG_COLORS,
+            )
+        except ImportError:
+            formatter = logging.Formatter(
+                fmt=f"[%(asctime)s] [{name}] [%(levelname)s] : %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S",
+            )
+
+        console_handler = logging.StreamHandler(sys.stdout)
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+        if log_to_file and log_file_path:
+            log_path = Path(log_file_path)
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            file_handler = logging.FileHandler(log_path, encoding="utf-8")
+            file_handler.setFormatter(logging.Formatter(
+                fmt=f"[{name}][%(asctime)s] [%(levelname)s] : %(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S"
+            ))
+            logger.addHandler(file_handler)
+
+    logger.propagate = False
+    return logger

handsome_log-0.1.0/handsome_log/loop.py

@@ -0,0 +1,67 @@
+import itertools
+import threading
+import time
+import sys
+from datetime import timedelta
+
+def loop_status(
+    self,
+    iterable,
+    message="Processing",
+    delay=0.1,
+    show_spinner=True,
+    show_percent=False,
+    end_message="done ✓"
+):
+    """
+    Displays a live terminal spinner while looping through an iterable.
+
+    Args:
+        iterable: The iterable to loop through.
+        message: Text to show alongside the spinner.
+        delay: Delay between frames (in seconds).
+        show_spinner: Toggle spinner display.
+        show_percent: Display progress as a percentage.
+        end_message: Message displayed after loop completion.
+    """
+    spinner = itertools.cycle(["|", "/", "-", "\\"])
+    stop = False
+    total = len(iterable) if hasattr(iterable, '__len__') else None
+    start_time = time.time()
+
+    def spin():
+        index = 0
+        while not stop:
+            spin_char = next(spinner) if show_spinner else ""
+            percent_text = ""
+            if show_percent and total:
+                percent = int((index / total) * 100)
+                percent_text = f" {percent:3d}%"
+            sys.stdout.write(f"\r[{self.name}] {message}{percent_text} {spin_char}")
+            sys.stdout.flush()
+            time.sleep(delay)
+            index += 1
+
+        elapsed = timedelta(seconds=time.time() - start_time)
+        elapsed_str = (
+            str(elapsed).split(".")[0]
+            if elapsed.total_seconds() > 60
+            else f"{elapsed.total_seconds():.2f}s"
+        )
+        sys.stdout.write(
+            f"\r[{self.name}] {message} {end_message} (Elapsed time: {elapsed_str})\n"
+        )
+
+    def wrapped():
+        nonlocal stop
+        t = threading.Thread(target=spin)
+        t.daemon = True
+        t.start()
+        try:
+            for i, item in enumerate(iterable):
+                yield item
+        finally:
+            stop = True
+            t.join()
+
+    return wrapped()

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

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: handsome-log
+Version: 0.1.0
+Summary: Universal logger with custom levels for ETL and automation processes.
+Author: Pedro Dellazzari
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: colorlog>=6.7.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# handsome_log
+
+`handsome_log` is a universal logger designed for ETL pipelines, automation tasks, and web scraping scripts in Python.
+
+This library is built on top of Python's standard `logging` module and the excellent `colorlog` package. Full credit and gratitude go to the developers of those foundational libraries.
+
+The main goal of `handsome_log` is to provide custom log levels that make it easier to structure and monitor all stages of your data processes. These levels help you track your pipeline with meaningful, semantically distinct messages.
+
+By default, the following custom levels are included:
+
+| Level        | When to Use                                         | Color        |
+|--------------|------------------------------------------------------|--------------|
+| `STARTUP`    | When initializing or starting a process              | Bold Blue    |
+| `VALIDATION` | When validating data, schema, or credentials         | Blue         |
+| `DRY_RUN`    | For simulation runs that don't commit any changes    | Purple       |
+| `SUCCESS`    | When a process completes successfully                | Bold Green   |
+| `INFO`       | For general runtime information                      | Green        |
+| `WARNING`    | When something unexpected happens, but the process continues | Yellow  |
+| `ERROR`      | When a failure occurs but the system stays alive     | Red          |
+| `CRITICAL`   | When a critical error occurs and the process halts   | Bold Red     |
+| `DEBUG`      | For detailed technical/debugging messages            | Cyan         |
+
+---
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install handsome_log
+```
+
+## Features
+Normal logging with colors
+
+Normal logging without colors
+
+For loop logging
+
+## Usage 
+To import and use the library you can use: 
+
+```bash
+#import
+from handsome_log import get_logger 
+
+#create logger object
+logger = get_logger(__name__)
+
+#testing different logging levels
+logger.startup("Startup Script")
+logger.info("General Info")
+logger.validation("Validation Logging")
+logger.dry_run("TEST RUN")
+logger.success("Success information")
+logger.warning("Warning")
+logger.error("Error")
+logger.critical("Critical Error")
+```
+
+![handsome_log_example_01](https://github.com/user-attachments/assets/dacbad77-5f89-410a-83bd-1e622f68e0ed)
+
+

handsome_log-0.1.0/handsome_log.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE.md
+README.md
+pyproject.toml
+setup.py
+handsome_log/__init__.py
+handsome_log/config.py
+handsome_log/levels.py
+handsome_log/logger.py
+handsome_log/loop.py
+handsome_log.egg-info/PKG-INFO
+handsome_log.egg-info/SOURCES.txt
+handsome_log.egg-info/dependency_links.txt
+handsome_log.egg-info/requires.txt
+handsome_log.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+colorlog>=6.7.0

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

@@ -0,0 +1 @@
+handsome_log

handsome_log-0.1.0/pyproject.toml

@@ -0,0 +1,4 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+

handsome_log-0.1.0/setup.cfg

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

handsome_log-0.1.0/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="handsome-log",
+    version="0.1.0",
+    author="Pedro Dellazzari",
+    description="Universal logger with custom levels for ETL and automation processes.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    install_requires=[
+        "colorlog>=6.7.0"
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.7',
+)