hexlogger 1.0.0__py3-none-any.whl

hexlogger/__init__.py

@@ -0,0 +1,1069 @@
+"""
+╔═══════════════════════════════════════════╗
+║            HexLogger v1.0.0              ║
+║     Premium Console Logging Library       ║
+║          Created by Montage               ║
+╚═══════════════════════════════════════════╝
+"""
+
+__version__ = "1.0.0"
+__author__ = "Montage"
+
+import sys
+import os
+import re
+import time
+import threading
+from datetime import datetime
+from enum import Enum
+from typing import Optional, List, Dict, Any
+
+# ══════════════════════════════════════════
+#  ANSI Color Codes
+# ══════════════════════════════════════════
+
+class Colors:
+    RESET = "\033[0m"
+    BOLD = "\033[1m"
+    DIM = "\033[2m"
+    ITALIC = "\033[3m"
+    UNDERLINE = "\033[4m"
+    BLINK = "\033[5m"
+    REVERSE = "\033[7m"
+    STRIKE = "\033[9m"
+
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+    GRAY = "\033[90m"
+
+    BRIGHT_RED = "\033[91m"
+    BRIGHT_GREEN = "\033[92m"
+    BRIGHT_YELLOW = "\033[93m"
+    BRIGHT_BLUE = "\033[94m"
+    BRIGHT_MAGENTA = "\033[95m"
+    BRIGHT_CYAN = "\033[96m"
+    BRIGHT_WHITE = "\033[97m"
+
+    BG_BLACK = "\033[40m"
+    BG_RED = "\033[41m"
+    BG_GREEN = "\033[42m"
+    BG_YELLOW = "\033[43m"
+    BG_BLUE = "\033[44m"
+    BG_MAGENTA = "\033[45m"
+    BG_CYAN = "\033[46m"
+    BG_WHITE = "\033[47m"
+
+
+def rgb(r: int, g: int, b: int) -> str:
+    return f"\033[38;2;{r};{g};{b}m"
+
+def bg_rgb(r: int, g: int, b: int) -> str:
+    return f"\033[48;2;{r};{g};{b}m"
+
+def hex_color(hex_code: str) -> str:
+    hex_code = hex_code.lstrip("#")
+    r, g, b = int(hex_code[0:2], 16), int(hex_code[2:4], 16), int(hex_code[4:6], 16)
+    return rgb(r, g, b)
+
+def bg_hex(hex_code: str) -> str:
+    hex_code = hex_code.lstrip("#")
+    r, g, b = int(hex_code[0:2], 16), int(hex_code[2:4], 16), int(hex_code[4:6], 16)
+    return bg_rgb(r, g, b)
+
+
+# ══════════════════════════════════════════
+#  Themes
+# ══════════════════════════════════════════
+
+class Theme:
+    def __init__(self, name: str, colors: Dict[str, str]):
+        self.name = name
+        self.colors = colors
+
+    def get(self, key: str) -> str:
+        return self.colors.get(key, Colors.RESET)
+
+
+THEMES = {
+    "default": Theme("default", {
+        "timestamp": rgb(100, 100, 100),
+        "bracket": rgb(70, 70, 70),
+        "dot": rgb(255, 255, 255),
+        "separator": rgb(100, 100, 100),
+        "debug": rgb(138, 180, 248),
+        "info": rgb(130, 170, 255),
+        "success": rgb(80, 230, 120),
+        "warning": rgb(255, 200, 60),
+        "error": rgb(255, 85, 85),
+        "critical": rgb(255, 50, 50),
+        "fatal": rgb(200, 0, 0),
+        "trace": rgb(160, 160, 160),
+        "divider": rgb(60, 60, 60),
+        "label_debug": "DEBUG",
+        "label_info": "INFO",
+        "label_success": "SUCCESS",
+        "label_warning": "WARNING",
+        "label_error": "ERROR",
+        "label_critical": "CRITICAL",
+        "label_fatal": "FATAL",
+        "label_trace": "TRACE",
+    }),
+    "neon": Theme("neon", {
+        "timestamp": rgb(0, 255, 200),
+        "bracket": rgb(0, 200, 150),
+        "dot": rgb(0, 255, 255),
+        "separator": rgb(0, 180, 180),
+        "debug": rgb(0, 200, 255),
+        "info": rgb(0, 255, 200),
+        "success": rgb(0, 255, 100),
+        "warning": rgb(255, 255, 0),
+        "error": rgb(255, 50, 80),
+        "critical": rgb(255, 0, 100),
+        "fatal": rgb(200, 0, 50),
+        "trace": rgb(100, 200, 200),
+        "divider": rgb(0, 100, 100),
+        "label_debug": "DEBUG",
+        "label_info": "INFO",
+        "label_success": "SUCCESS",
+        "label_warning": "WARNING",
+        "label_error": "ERROR",
+        "label_critical": "CRITICAL",
+        "label_fatal": "FATAL",
+        "label_trace": "TRACE",
+    }),
+    "minimal": Theme("minimal", {
+        "timestamp": rgb(120, 120, 120),
+        "bracket": rgb(80, 80, 80),
+        "dot": rgb(180, 180, 180),
+        "separator": rgb(100, 100, 100),
+        "debug": rgb(150, 150, 150),
+        "info": rgb(200, 200, 200),
+        "success": rgb(100, 200, 100),
+        "warning": rgb(200, 180, 80),
+        "error": rgb(200, 80, 80),
+        "critical": rgb(220, 50, 50),
+        "fatal": rgb(180, 0, 0),
+        "trace": rgb(120, 120, 120),
+        "divider": rgb(60, 60, 60),
+        "label_debug": "DBG",
+        "label_info": "INF",
+        "label_success": "OK",
+        "label_warning": "WRN",
+        "label_error": "ERR",
+        "label_critical": "CRT",
+        "label_fatal": "FTL",
+        "label_trace": "TRC",
+    }),
+    "hacker": Theme("hacker", {
+        "timestamp": rgb(0, 180, 0),
+        "bracket": rgb(0, 120, 0),
+        "dot": rgb(0, 255, 0),
+        "separator": rgb(0, 150, 0),
+        "debug": rgb(0, 200, 0),
+        "info": rgb(0, 255, 0),
+        "success": rgb(50, 255, 50),
+        "warning": rgb(200, 255, 0),
+        "error": rgb(255, 100, 0),
+        "critical": rgb(255, 50, 0),
+        "fatal": rgb(255, 0, 0),
+        "trace": rgb(0, 150, 0),
+        "divider": rgb(0, 80, 0),
+        "label_debug": "DEBUG",
+        "label_info": "INFO",
+        "label_success": "SUCCESS",
+        "label_warning": "WARNING",
+        "label_error": "ERROR",
+        "label_critical": "CRITICAL",
+        "label_fatal": "FATAL",
+        "label_trace": "TRACE",
+    }),
+    "sunset": Theme("sunset", {
+        "timestamp": rgb(255, 150, 50),
+        "bracket": rgb(200, 100, 50),
+        "dot": rgb(255, 200, 100),
+        "separator": rgb(200, 120, 60),
+        "debug": rgb(255, 180, 100),
+        "info": rgb(255, 160, 80),
+        "success": rgb(255, 220, 50),
+        "warning": rgb(255, 120, 30),
+        "error": rgb(255, 60, 60),
+        "critical": rgb(200, 30, 30),
+        "fatal": rgb(150, 0, 0),
+        "trace": rgb(200, 150, 100),
+        "divider": rgb(150, 80, 40),
+        "label_debug": "DEBUG",
+        "label_info": "INFO",
+        "label_success": "SUCCESS",
+        "label_warning": "WARNING",
+        "label_error": "ERROR",
+        "label_critical": "CRITICAL",
+        "label_fatal": "FATAL",
+        "label_trace": "TRACE",
+    }),
+    "ocean": Theme("ocean", {
+        "timestamp": rgb(0, 150, 200),
+        "bracket": rgb(0, 100, 160),
+        "dot": rgb(0, 200, 255),
+        "separator": rgb(0, 130, 180),
+        "debug": rgb(100, 180, 255),
+        "info": rgb(0, 200, 255),
+        "success": rgb(0, 255, 200),
+        "warning": rgb(255, 220, 80),
+        "error": rgb(255, 80, 100),
+        "critical": rgb(255, 40, 80),
+        "fatal": rgb(200, 0, 50),
+        "trace": rgb(80, 150, 200),
+        "divider": rgb(0, 80, 120),
+        "label_debug": "DEBUG",
+        "label_info": "INFO",
+        "label_success": "SUCCESS",
+        "label_warning": "WARNING",
+        "label_error": "ERROR",
+        "label_critical": "CRITICAL",
+        "label_fatal": "FATAL",
+        "label_trace": "TRACE",
+    }),
+}
+
+
+# ══════════════════════════════════════════
+#  Log Styles (different display formats)
+# ══════════════════════════════════════════
+
+LEVEL_ICONS = {
+    "debug": "●",
+    "info": "ℹ",
+    "success": "✓",
+    "warning": "⚠",
+    "error": "✗",
+    "critical": "☠",
+    "fatal": "💀",
+    "trace": "→",
+}
+
+def _style_default(now, level, level_color, level_label, message, t, show_time):
+    R = Colors.RESET
+    B = Colors.BOLD
+    br = t.get("bracket")
+    ts = t.get("timestamp")
+    dt = t.get("dot")
+    sep = t.get("separator")
+    if show_time:
+        return (
+            f"{br}[-({ts}{now}{R}{br})-]{R} "
+            f"{br}[{R} {dt}●{R} {br}]{R} "
+            f"{B}{level_color}{level_label}{R} "
+            f"{sep}»{R}  "
+            f"{level_color}{message}{R}"
+        )
+    return (
+        f"{br}[{R} {dt}●{R} {br}]{R} "
+        f"{B}{level_color}{level_label}{R} "
+        f"{sep}»{R}  "
+        f"{level_color}{message}{R}"
+    )
+
+def _style_box(now, level, level_color, level_label, message, t, show_time):
+    R = Colors.RESET
+    B = Colors.BOLD
+    br = t.get("bracket")
+    ts = t.get("timestamp")
+    icon = LEVEL_ICONS.get(level, "●")
+    if show_time:
+        return (
+            f"{br}┃{R} {ts}{now}{R} "
+            f"{br}│{R} {level_color}{icon}{R} "
+            f"{B}{level_color}{level_label.ljust(8)}{R} "
+            f"{br}│{R} {level_color}{message}{R}"
+        )
+    return (
+        f"{br}┃{R} {level_color}{icon}{R} "
+        f"{B}{level_color}{level_label.ljust(8)}{R} "
+        f"{br}│{R} {level_color}{message}{R}"
+    )
+
+def _style_modern(now, level, level_color, level_label, message, t, show_time):
+    R = Colors.RESET
+    B = Colors.BOLD
+    ts = t.get("timestamp")
+    icon = LEVEL_ICONS.get(level, "●")
+    if show_time:
+        return (
+            f"{ts}{now}{R}  "
+            f"{level_color}{icon} {B}{level_label}{R}  "
+            f"{level_color}{message}{R}"
+        )
+    return (
+        f"{level_color}{icon} {B}{level_label}{R}  "
+        f"{level_color}{message}{R}"
+    )
+
+def _style_bracket(now, level, level_color, level_label, message, t, show_time):
+    R = Colors.RESET
+    B = Colors.BOLD
+    br = t.get("bracket")
+    ts = t.get("timestamp")
+    if show_time:
+        return (
+            f"{br}[{ts}{now}{R}{br}]{R} "
+            f"{br}[{B}{level_color}{level_label}{R}{br}]{R} "
+            f"{level_color}{message}{R}"
+        )
+    return (
+        f"{br}[{B}{level_color}{level_label}{R}{br}]{R} "
+        f"{level_color}{message}{R}"
+    )
+
+def _style_arrow(now, level, level_color, level_label, message, t, show_time):
+    R = Colors.RESET
+    B = Colors.BOLD
+    ts = t.get("timestamp")
+    sep = t.get("separator")
+    if show_time:
+        return (
+            f"{ts}{now}{R} "
+            f"{sep}▸{R} "
+            f"{B}{level_color}{level_label}{R} "
+            f"{sep}▸{R} "
+            f"{level_color}{message}{R}"
+        )
+    return (
+        f"{sep}▸{R} "
+        f"{B}{level_color}{level_label}{R} "
+        f"{sep}▸{R} "
+        f"{level_color}{message}{R}"
+    )
+
+def _style_pipe(now, level, level_color, level_label, message, t, show_time):
+    R = Colors.RESET
+    B = Colors.BOLD
+    ts = t.get("timestamp")
+    br = t.get("bracket")
+    if show_time:
+        return (
+            f"{level_color}▌{R} {ts}{now}{R} "
+            f"{br}|{R} {B}{level_color}{level_label.ljust(8)}{R} "
+            f"{br}|{R} {level_color}{message}{R}"
+        )
+    return (
+        f"{level_color}▌{R} {B}{level_color}{level_label.ljust(8)}{R} "
+        f"{br}|{R} {level_color}{message}{R}"
+    )
+
+def _style_tag(now, level, level_color, level_label, message, t, show_time):
+    R = Colors.RESET
+    B = Colors.BOLD
+    ts = t.get("timestamp")
+    bg = {
+        "debug": bg_rgb(50, 80, 120),
+        "info": bg_rgb(40, 70, 130),
+        "success": bg_rgb(30, 100, 50),
+        "warning": bg_rgb(130, 100, 0),
+        "error": bg_rgb(130, 30, 30),
+        "critical": bg_rgb(150, 20, 20),
+        "fatal": bg_rgb(120, 0, 0),
+        "trace": bg_rgb(60, 60, 60),
+    }.get(level, "")
+    if show_time:
+        return (
+            f"{ts}{now}{R} "
+            f"{bg}{B} {level_label} {R} "
+            f"{level_color}{message}{R}"
+        )
+    return (
+        f"{bg}{B} {level_label} {R} "
+        f"{level_color}{message}{R}"
+    )
+
+def _style_dots(now, level, level_color, level_label, message, t, show_time):
+    R = Colors.RESET
+    B = Colors.BOLD
+    ts = t.get("timestamp")
+    sep = t.get("separator")
+    icon = LEVEL_ICONS.get(level, "●")
+    if show_time:
+        return (
+            f"{level_color}{icon}{R} "
+            f"{ts}{now}{R} "
+            f"{sep}·{R} "
+            f"{B}{level_color}{level_label}{R} "
+            f"{sep}·{R} "
+            f"{level_color}{message}{R}"
+        )
+    return (
+        f"{level_color}{icon}{R} "
+        f"{B}{level_color}{level_label}{R} "
+        f"{sep}·{R} "
+        f"{level_color}{message}{R}"
+    )
+
+def _style_clean(now, level, level_color, level_label, message, t, show_time):
+    R = Colors.RESET
+    B = Colors.BOLD
+    ts = t.get("timestamp")
+    if show_time:
+        return (
+            f"  {ts}{now}{R}  "
+            f"{B}{level_color}{level_label.ljust(8)}{R}  "
+            f"{level_color}{message}{R}"
+        )
+    return (
+        f"  {B}{level_color}{level_label.ljust(8)}{R}  "
+        f"{level_color}{message}{R}"
+    )
+
+STYLES = {
+    "default": _style_default,
+    "box": _style_box,
+    "modern": _style_modern,
+    "bracket": _style_bracket,
+    "arrow": _style_arrow,
+    "pipe": _style_pipe,
+    "tag": _style_tag,
+    "dots": _style_dots,
+    "clean": _style_clean,
+}
+
+
+# ══════════════════════════════════════════
+#  Logger Configuration
+# ══════════════════════════════════════════
+
+class LogLevel(Enum):
+    TRACE = 0
+    DEBUG = 1
+    INFO = 2
+    SUCCESS = 3
+    WARNING = 4
+    ERROR = 5
+    CRITICAL = 6
+    FATAL = 7
+
+
+class LoggerConfig:
+    def __init__(self):
+        self.theme: Theme = THEMES["default"]
+        self.style: str = "default"
+        self.time_format: str = "%H:%M:%S"
+        self.show_time: bool = True
+        self.log_file: Optional[str] = None
+        self.min_level: LogLevel = LogLevel.TRACE
+        self._file_handle = None
+        self._lock = threading.Lock()
+
+    def set_theme(self, theme_name: str):
+        if theme_name in THEMES:
+            self.theme = THEMES[theme_name]
+        else:
+            raise ValueError(f"Unknown theme: {theme_name}. Available: {list(THEMES.keys())}")
+
+    def set_style(self, style_name: str):
+        if style_name in STYLES:
+            self.style = style_name
+        else:
+            raise ValueError(f"Unknown style: {style_name}. Available: {list(STYLES.keys())}")
+
+    def add_theme(self, name: str, colors: Dict[str, str]):
+        theme = Theme(name, colors)
+        THEMES[name] = theme
+        return theme
+
+    def set_log_file(self, path: str):
+        self.log_file = path
+        if self._file_handle:
+            self._file_handle.close()
+        self._file_handle = open(path, "a", encoding="utf-8")
+
+    def close(self):
+        if self._file_handle:
+            self._file_handle.close()
+            self._file_handle = None
+
+
+# ══════════════════════════════════════════
+#  Global Config
+# ══════════════════════════════════════════
+
+_config = LoggerConfig()
+
+def _strip_ansi(text: str) -> str:
+    return re.sub(r'\033\[[0-9;]*m', '', text)
+
+def _get_time() -> str:
+    return datetime.now().strftime(_config.time_format)
+
+def _write_to_file(message: str):
+    if _config._file_handle:
+        try:
+            clean = _strip_ansi(message)
+            _config._file_handle.write(clean + "\n")
+            _config._file_handle.flush()
+        except:
+            pass
+
+
+# ══════════════════════════════════════════
+#  Core Log Function
+# ══════════════════════════════════════════
+
+def _log(level: str, message: str, level_enum: LogLevel):
+    if level_enum.value < _config.min_level.value:
+        return
+
+    t = _config.theme
+    now = _get_time()
+    level_color = t.get(level)
+    level_label = t.get(f"label_{level}")
+
+    style_fn = STYLES.get(_config.style, _style_default)
+    line = style_fn(now, level, level_color, level_label, message, t, _config.show_time)
+
+    with _config._lock:
+        print(line)
+        _write_to_file(line)
+
+
+# ══════════════════════════════════════════
+#  Log Functions
+# ══════════════════════════════════════════
+
+def debug(message: str):
+    _log("debug", message, LogLevel.DEBUG)
+
+def info(message: str):
+    _log("info", message, LogLevel.INFO)
+
+def success(message: str):
+    _log("success", message, LogLevel.SUCCESS)
+
+def warn(message: str):
+    _log("warning", message, LogLevel.WARNING)
+
+def warning(message: str):
+    _log("warning", message, LogLevel.WARNING)
+
+def error(message: str):
+    _log("error", message, LogLevel.ERROR)
+
+def critical(message: str):
+    _log("critical", message, LogLevel.CRITICAL)
+
+def fatal(message: str):
+    _log("fatal", message, LogLevel.FATAL)
+
+def trace(message: str):
+    _log("trace", message, LogLevel.TRACE)
+
+
+# ══════════════════════════════════════════
+#  Utility Functions
+# ══════════════════════════════════════════
+
+def divider(char: str = "─", length: int = 60, color: Optional[str] = None):
+    c = color or _config.theme.get("divider")
+    line = f"{c}{char * length}{Colors.RESET}"
+    with _config._lock:
+        print(line)
+        _write_to_file(line)
+
+def section(title: str, char: str = "═", length: int = 60):
+    t = _config.theme
+    title_color = t.get("info")
+    div_color = t.get("divider")
+    padding = (length - len(title) - 2) // 2
+    left = char * max(padding, 1)
+    right = char * max(length - len(title) - 2 - padding, 1)
+    line = f"{div_color}{left}{Colors.RESET} {Colors.BOLD}{title_color}{title}{Colors.RESET} {div_color}{right}{Colors.RESET}"
+    with _config._lock:
+        print(line)
+        _write_to_file(line)
+
+def blank(count: int = 1):
+    for _ in range(count):
+        print()
+
+def rule(text: str = "", char: str = "─", length: int = 60):
+    if text:
+        section(text, char, length)
+    else:
+        divider(char, length)
+
+def banner(text: str, border_char: str = "═", padding: int = 2):
+    lines = text.split("\n")
+    max_len = max(len(line) for line in lines)
+    width = max_len + (padding * 2) + 2
+    t = _config.theme
+    bc = t.get("info")
+    tc = t.get("success")
+    R = Colors.RESET
+
+    top = f"{bc}╔{border_char * (width - 2)}╗{R}"
+    bottom = f"{bc}╚{border_char * (width - 2)}╝{R}"
+
+    with _config._lock:
+        print(top)
+        for line in lines:
+            padded = line.center(max_len)
+            print(f"{bc}║{R}{' ' * padding}{tc}{padded}{R}{' ' * padding}{bc}║{R}")
+        print(bottom)
+
+
+# ══════════════════════════════════════════
+#  Gradient Text
+# ══════════════════════════════════════════
+
+def _interpolate(c1: tuple, c2: tuple, t: float) -> tuple:
+    return (
+        int(c1[0] + (c2[0] - c1[0]) * t),
+        int(c1[1] + (c2[1] - c1[1]) * t),
+        int(c1[2] + (c2[2] - c1[2]) * t),
+    )
+
+def gradient_text(text: str, start_color: tuple = (255, 0, 100), end_color: tuple = (100, 0, 255)) -> str:
+    result = []
+    length = max(len(text) - 1, 1)
+    for i, char in enumerate(text):
+        t = i / length
+        r, g, b = _interpolate(start_color, end_color, t)
+        result.append(f"{rgb(r, g, b)}{char}")
+    result.append(Colors.RESET)
+    return "".join(result)
+
+def gradient_print(text: str, start_color: tuple = (255, 0, 100), end_color: tuple = (100, 0, 255)):
+    print(gradient_text(text, start_color, end_color))
+
+def multi_gradient_text(text: str, colors: List[tuple]) -> str:
+    if len(colors) < 2:
+        return text
+    result = []
+    segments = len(colors) - 1
+    chars_per_seg = max(len(text) / segments, 1)
+    for i, char in enumerate(text):
+        seg = min(int(i / chars_per_seg), segments - 1)
+        t = (i - seg * chars_per_seg) / chars_per_seg
+        r, g, b = _interpolate(colors[seg], colors[seg + 1], t)
+        result.append(f"{rgb(r, g, b)}{char}")
+    result.append(Colors.RESET)
+    return "".join(result)
+
+def multi_gradient_print(text: str, colors: List[tuple]):
+    print(multi_gradient_text(text, colors))
+
+def rainbow_text(text: str) -> str:
+    colors = [
+        (255, 0, 0), (255, 127, 0), (255, 255, 0),
+        (0, 255, 0), (0, 127, 255), (75, 0, 130), (148, 0, 211)
+    ]
+    return multi_gradient_text(text, colors)
+
+def rainbow_print(text: str):
+    print(rainbow_text(text))
+
+
+# ══════════════════════════════════════════
+#  Panel
+# ══════════════════════════════════════════
+
+def panel(content: str, title: str = "", width: int = 50, border_color: Optional[str] = None,
+          style: str = "rounded"):
+    bc = border_color or _config.theme.get("info")
+    R = Colors.RESET
+
+    borders = {
+        "rounded": ("╭", "╮", "╰", "╯", "─", "│"),
+        "sharp":   ("┌", "┐", "└", "┘", "─", "│"),
+        "double":  ("╔", "╗", "╚", "╝", "═", "║"),
+        "heavy":   ("┏", "┓", "┗", "┛", "━", "┃"),
+        "ascii":   ("+", "+", "+", "+", "-", "|"),
+    }
+    tl, tr, bl, br_char, h, v = borders.get(style, borders["rounded"])
+
+    lines = content.split("\n")
+    inner_w = width - 4
+
+    if title:
+        title_stripped = _strip_ansi(title)
+        top = f"{bc}{tl}{h} {Colors.BOLD}{title}{R}{bc} {h * max(width - len(title_stripped) - 5, 1)}{tr}{R}"
+    else:
+        top = f"{bc}{tl}{h * (width - 2)}{tr}{R}"
+
+    bottom = f"{bc}{bl}{h * (width - 2)}{br_char}{R}"
+
+    with _config._lock:
+        print(top)
+        for line in lines:
+            stripped = _strip_ansi(line)
+            pad = inner_w - len(stripped)
+            print(f"{bc}{v}{R} {line}{' ' * max(pad, 0)} {bc}{v}{R}")
+        print(bottom)
+
+
+# ══════════════════════════════════════════
+#  Table
+# ══════════════════════════════════════════
+
+def table(headers: List[str], rows: List[List[str]], border_color: Optional[str] = None,
+          style: str = "rounded"):
+    bc = border_color or _config.theme.get("info")
+    hc = _config.theme.get("success")
+    R = Colors.RESET
+    B = Colors.BOLD
+
+    borders = {
+        "rounded": ("╭", "╮", "╰", "╯", "─", "│", "┬", "┴", "├", "┤", "┼"),
+        "sharp":   ("┌", "┐", "└", "┘", "─", "│", "┬", "┴", "├", "┤", "┼"),
+        "double":  ("╔", "╗", "╚", "╝", "═", "║", "╦", "╩", "╠", "╣", "╬"),
+        "heavy":   ("┏", "┓", "┗", "┛", "━", "┃", "┳", "┻", "┣", "┫", "╋"),
+        "ascii":   ("+", "+", "+", "+", "-", "|", "+", "+", "+", "+", "+"),
+    }
+    tl, tr, bl, br_char, h, v, tm, bm, ml, mr, mm = borders.get(style, borders["rounded"])
+
+    col_widths = [len(str(hdr)) for hdr in headers]
+    for row in rows:
+        for i, cell in enumerate(row):
+            if i < len(col_widths):
+                col_widths[i] = max(col_widths[i], len(str(cell)))
+
+    def make_sep(left, mid, right, fill):
+        parts = [fill * (w + 2) for w in col_widths]
+        return f"{bc}{left}{mid.join(parts)}{right}{R}"
+
+    def make_row(cells, cell_color=""):
+        parts = []
+        for i, cell in enumerate(cells):
+            w = col_widths[i] if i < len(col_widths) else 10
+            parts.append(f" {cell_color}{str(cell).ljust(w)}{R} ")
+        return f"{bc}{v}{R}{f'{bc}{v}{R}'.join(parts)}{bc}{v}{R}"
+
+    with _config._lock:
+        print(make_sep(tl, tm, tr, h))
+        print(make_row(headers, f"{B}{hc}"))
+        print(make_sep(ml, mm, mr, h))
+        for row in rows:
+            print(make_row(row))
+        print(make_sep(bl, bm, br_char, h))
+
+
+# ══════════════════════════════════════════
+#  Box (wraps text in a box)
+# ══════════════════════════════════════════
+
+def box(text: str, width: Optional[int] = None, style: str = "rounded",
+        color: Optional[str] = None, text_color: Optional[str] = None,
+        align: str = "left", padding: int = 1):
+    bc = color or _config.theme.get("info")
+    tc = text_color or Colors.RESET
+    R = Colors.RESET
+
+    borders = {
+        "rounded": ("╭", "╮", "╰", "╯", "─", "│"),
+        "sharp":   ("┌", "┐", "└", "┘", "─", "│"),
+        "double":  ("╔", "╗", "╚", "╝", "═", "║"),
+        "heavy":   ("┏", "┓", "┗", "┛", "━", "┃"),
+        "ascii":   ("+", "+", "+", "+", "-", "|"),
+        "stars":   ("*", "*", "*", "*", "*", "*"),
+        "dashes":  ("+", "+", "+", "+", "~", ":"),
+    }
+    tl, tr, bl, br_char, h, v = borders.get(style, borders["rounded"])
+
+    lines = text.split("\n")
+    max_line = max(len(_strip_ansi(l)) for l in lines)
+    inner_w = (width - 4) if width else max_line + (padding * 2)
+    total_w = inner_w + 4
+
+    top = f"{bc}{tl}{h * (total_w - 2)}{tr}{R}"
+    bottom = f"{bc}{bl}{h * (total_w - 2)}{br_char}{R}"
+
+    with _config._lock:
+        print(top)
+        for _ in range(padding - 1 if padding > 1 else 0):
+            print(f"{bc}{v}{R}{' ' * (total_w - 2)}{bc}{v}{R}")
+        for line in lines:
+            stripped = _strip_ansi(line)
+            if align == "center":
+                lpad = (inner_w - len(stripped)) // 2
+                rpad = inner_w - len(stripped) - lpad
+                padded = f"{' ' * lpad}{tc}{line}{R}{' ' * rpad}"
+            elif align == "right":
+                pad = inner_w - len(stripped)
+                padded = f"{' ' * pad}{tc}{line}{R}"
+            else:
+                pad = inner_w - len(stripped)
+                padded = f"{tc}{line}{R}{' ' * pad}"
+            print(f"{bc}{v}{R} {padded} {bc}{v}{R}")
+        for _ in range(padding - 1 if padding > 1 else 0):
+            print(f"{bc}{v}{R}{' ' * (total_w - 2)}{bc}{v}{R}")
+        print(bottom)
+
+
+# ══════════════════════════════════════════
+#  Progress Bar
+# ══════════════════════════════════════════
+
+class ProgressBar:
+    def __init__(self, total: int, width: int = 30, label: str = "Progress",
+                 fill_char: str = "█", empty_char: str = "░",
+                 color: Optional[str] = None):
+        self.total = total
+        self.width = width
+        self.label = label
+        self.fill_char = fill_char
+        self.empty_char = empty_char
+        self.color = color or _config.theme.get("success")
+        self.current = 0
+        self._start_time = time.time()
+
+    def update(self, amount: int = 1):
+        self.current = min(self.current + amount, self.total)
+        self._render()
+
+    def set(self, value: int):
+        self.current = min(value, self.total)
+        self._render()
+
+    def _render(self):
+        pct = self.current / self.total if self.total > 0 else 0
+        filled = int(self.width * pct)
+        bar = self.fill_char * filled + self.empty_char * (self.width - filled)
+        elapsed = time.time() - self._start_time
+        eta = (elapsed / pct - elapsed) if pct > 0 else 0
+
+        R = Colors.RESET
+        line = (
+            f"\r{self.color}{self.label}{R} "
+            f"│{self.color}{bar}{R}│ "
+            f"{Colors.BOLD}{pct * 100:5.1f}%{R} "
+            f"({self.current}/{self.total}) "
+            f"[{elapsed:.1f}s / ETA {eta:.1f}s]"
+        )
+        sys.stdout.write(line)
+        sys.stdout.flush()
+        if self.current >= self.total:
+            print()
+
+    def finish(self):
+        self.set(self.total)
+
+
+# ══════════════════════════════════════════
+#  Spinner
+# ══════════════════════════════════════════
+
+class Spinner:
+    STYLES = {
+        "dots": ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+        "line": ["-", "\\", "|", "/"],
+        "arrow": ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"],
+        "bounce": ["⠁", "⠂", "⠄", "⠂"],
+        "box": ["▖", "▘", "▝", "▗"],
+        "circle": ["◐", "◓", "◑", "◒"],
+        "pulse": ["○", "◎", "●", "◎"],
+        "star": ["✶", "✸", "✹", "✺", "✹", "✸"],
+        "moon": ["🌑", "🌒", "🌓", "🌔", "🌕", "🌖", "🌗", "🌘"],
+        "clock": ["🕐", "🕑", "🕒", "🕓", "🕔", "🕕", "🕖", "🕗", "🕘", "🕙", "🕚", "🕛"],
+    }
+
+    def __init__(self, message: str = "Loading", style: str = "dots", color: Optional[str] = None):
+        self.message = message
+        self.frames = self.STYLES.get(style, self.STYLES["dots"])
+        self.color = color or _config.theme.get("info")
+        self._running = False
+        self._thread = None
+        self._frame_idx = 0
+
+    def start(self):
+        self._running = True
+        self._thread = threading.Thread(target=self._spin, daemon=True)
+        self._thread.start()
+        return self
+
+    def _spin(self):
+        while self._running:
+            frame = self.frames[self._frame_idx % len(self.frames)]
+            sys.stdout.write(f"\r{self.color}{frame}{Colors.RESET} {self.message}")
+            sys.stdout.flush()
+            self._frame_idx += 1
+            time.sleep(0.08)
+
+    def stop(self, final_message: str = ""):
+        self._running = False
+        if self._thread:
+            self._thread.join()
+        sys.stdout.write("\r" + " " * (len(self.message) + 10) + "\r")
+        if final_message:
+            success(final_message)
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, *args):
+        self.stop()
+
+
+# ══════════════════════════════════════════
+#  Timer
+# ══════════════════════════════════════════
+
+class Timer:
+    def __init__(self, label: str = "Elapsed"):
+        self.label = label
+        self._start = None
+        self._end = None
+
+    def start(self):
+        self._start = time.time()
+        return self
+
+    def stop(self) -> float:
+        self._end = time.time()
+        elapsed = self._end - self._start
+        info(f"{self.label}: {elapsed:.3f}s")
+        return elapsed
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, *args):
+        self.stop()
+
+
+# ══════════════════════════════════════════
+#  Pair Logging (key-value)
+# ══════════════════════════════════════════
+
+def pair(key: str, value: str, key_color: Optional[str] = None, value_color: Optional[str] = None):
+    kc = key_color or _config.theme.get("info")
+    vc = value_color or Colors.RESET
+    line = f"  {kc}{Colors.BOLD}{key}{Colors.RESET}: {vc}{value}{Colors.RESET}"
+    with _config._lock:
+        print(line)
+        _write_to_file(line)
+
+
+# ══════════════════════════════════════════
+#  Preview: Show all styles
+# ══════════════════════════════════════════
+
+def preview_styles():
+    current_style = _config.style
+    for style_name in STYLES:
+        _config.style = style_name
+        section(f"Style: {style_name}")
+        debug("Debug message")
+        info("Info message")
+        success("Success message")
+        warn("Warning message")
+        error("Error message")
+        blank()
+    _config.style = current_style
+
+def preview_themes():
+    current_theme_name = _config.theme.name
+    for theme_name in THEMES:
+        _config.set_theme(theme_name)
+        section(f"Theme: {theme_name}")
+        debug("Debug message")
+        success("Success message")
+        error("Error message")
+        blank()
+    _config.set_theme(current_theme_name)
+
+
+# ══════════════════════════════════════════
+#  Configuration API
+# ══════════════════════════════════════════
+
+def set_theme(name: str):
+    _config.set_theme(name)
+
+def set_style(name: str):
+    _config.set_style(name)
+
+def add_theme(name: str, colors: Dict[str, str]):
+    _config.add_theme(name, colors)
+
+def set_time_format(fmt: str):
+    _config.time_format = fmt
+
+def show_time(show: bool = True):
+    _config.show_time = show
+
+def set_log_file(path: str):
+    _config.set_log_file(path)
+
+def set_min_level(level: str):
+    level_map = {
+        "trace": LogLevel.TRACE,
+        "debug": LogLevel.DEBUG,
+        "info": LogLevel.INFO,
+        "success": LogLevel.SUCCESS,
+        "warning": LogLevel.WARNING,
+        "error": LogLevel.ERROR,
+        "critical": LogLevel.CRITICAL,
+        "fatal": LogLevel.FATAL,
+    }
+    if level.lower() in level_map:
+        _config.min_level = level_map[level.lower()]
+
+def get_config() -> LoggerConfig:
+    return _config
+
+
+# ══════════════════════════════════════════
+#  Colorize Helpers
+# ══════════════════════════════════════════
+
+def colorize(text: str, color: str) -> str:
+    return f"{color}{text}{Colors.RESET}"
+
+def bold(text: str) -> str:
+    return f"{Colors.BOLD}{text}{Colors.RESET}"
+
+def italic(text: str) -> str:
+    return f"{Colors.ITALIC}{text}{Colors.RESET}"
+
+def underline(text: str) -> str:
+    return f"{Colors.UNDERLINE}{text}{Colors.RESET}"
+
+def dim(text: str) -> str:
+    return f"{Colors.DIM}{text}{Colors.RESET}"
+
+def strike(text: str) -> str:
+    return f"{Colors.STRIKE}{text}{Colors.RESET}"
+
+
+# ══════════════════════════════════════════
+#  Module Exports
+# ══════════════════════════════════════════
+
+__all__ = [
+    "debug", "info", "success", "warn", "warning", "error",
+    "critical", "fatal", "trace",
+    "divider", "section", "blank", "rule", "banner", "panel", "table", "box", "pair",
+    "gradient_text", "gradient_print", "multi_gradient_text", "multi_gradient_print",
+    "rainbow_text", "rainbow_print",
+    "colorize", "bold", "italic", "underline", "dim", "strike",
+    "rgb", "bg_rgb", "hex_color", "bg_hex",
+    "set_theme", "set_style", "add_theme", "set_time_format", "show_time",
+    "set_log_file", "set_min_level", "get_config",
+    "preview_styles", "preview_themes",
+    "ProgressBar", "Spinner", "Timer",
+    "Colors", "Theme", "LogLevel", "LoggerConfig",
+    "__version__", "__author__",
+]
+
+if os.name == "nt":
+    try:
+        import ctypes
+        kernel32 = ctypes.windll.kernel32
+        kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
+    except:
+        pass

hexlogger-1.0.0.dist-info/METADATA

@@ -0,0 +1,266 @@
+Metadata-Version: 2.4
+Name: hexlogger
+Version: 1.0.0
+Summary: Premium console logging library with themes, gradients, panels, tables, progress bars, and spinners.
+Author: Itz Montage
+License: MIT
+Project-URL: Homepage, https://github.com/Montagexd/hexlogger
+Keywords: logging,console,terminal,colors,logger,hex,ansi
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System :: Logging
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# 🔮 HexLogger
+
+**Premium console logging library for Python**
+
+A feature-rich, zero-dependency logging library with beautiful colored output, multiple themes, gradient text, panels, tables, progress bars, and spinners.
+
+## Installation
+
+```bash
+pip install hexlogger
+```
+
+## Quick Start
+
+```python
+import hexlogger
+
+hexlogger.debug("Connecting to server...")
+hexlogger.success("Connected!")
+hexlogger.info("Processing 1000 items")
+hexlogger.warn("Rate limit approaching")
+hexlogger.error("Connection failed")
+hexlogger.critical("System overload!")
+```
+
+**Output:**
+```
+[-(14:30:00)-] [ ● ] DEBUG »  Connecting to server...
+[-(14:30:00)-] [ ● ] SUCCESS »  Connected!
+[-(14:30:00)-] [ ● ] INFO »  Processing 1000 items
+[-(14:30:00)-] [ ● ] WARNING »  Rate limit approaching
+[-(14:30:00)-] [ ● ] ERROR »  Connection failed
+[-(14:30:00)-] [ ● ] CRITICAL »  System overload!
+```
+
+## Themes
+
+```python
+import hexlogger
+
+# Available themes: default, neon, minimal, hacker
+hexlogger.set_theme("neon")
+hexlogger.success("Neon vibes!")
+
+hexlogger.set_theme("hacker")
+hexlogger.success("Matrix mode!")
+
+hexlogger.set_theme("minimal")
+hexlogger.success("Clean and simple")
+```
+
+### Custom Themes
+
+```python
+from hexlogger import add_theme, rgb
+
+add_theme("ocean", {
+    "timestamp": rgb(0, 100, 200),
+    "bracket": rgb(0, 80, 160),
+    "dot": rgb(0, 200, 255),
+    "separator": rgb(0, 150, 200),
+    "debug": rgb(100, 180, 255),
+    "info": rgb(0, 200, 255),
+    "success": rgb(0, 255, 200),
+    "warning": rgb(255, 200, 0),
+    "error": rgb(255, 80, 80),
+    "critical": rgb(255, 0, 50),
+    "fatal": rgb(200, 0, 0),
+    "trace": rgb(100, 150, 200),
+    "divider": rgb(0, 60, 100),
+    "label_debug": "DEBUG",
+    "label_info": "INFO",
+    "label_success": "SUCCESS",
+    "label_warning": "WARNING",
+    "label_error": "ERROR",
+    "label_critical": "CRITICAL",
+    "label_fatal": "FATAL",
+    "label_trace": "TRACE",
+})
+
+hexlogger.set_theme("ocean")
+```
+
+## Dividers & Sections
+
+```python
+hexlogger.divider()
+hexlogger.section("RESULTS")
+hexlogger.rule("Settings", char="═")
+hexlogger.blank(2)
+```
+
+## Banner
+
+```python
+hexlogger.banner("HexLogger\nv1.0.0")
+```
+
+```
+╔═══════════════════╗
+║    HexLogger      ║
+║     v1.0.0        ║
+╚═══════════════════╝
+```
+
+## Panel
+
+```python
+hexlogger.panel("Server: online\nPing: 42ms\nUptime: 99.9%", title="Status")
+```
+
+```
+╭─ Status ──────────────────────────────╮
+│ Server: online                        │
+│ Ping: 42ms                            │
+│ Uptime: 99.9%                         │
+╰───────────────────────────────────────╯
+```
+
+## Table
+
+```python
+hexlogger.table(
+    headers=["Name", "Status", "Ping"],
+    rows=[
+        ["Server 1", "Online", "12ms"],
+        ["Server 2", "Offline", "---"],
+        ["Server 3", "Online", "45ms"],
+    ]
+)
+```
+
+## Gradient Text
+
+```python
+hexlogger.gradient_print("Hello World!", (255, 0, 100), (100, 0, 255))
+hexlogger.rainbow_print("Rainbow text!")
+
+# Get gradient string without printing
+text = hexlogger.gradient_text("Custom gradient", (0, 255, 200), (255, 0, 100))
+```
+
+## Progress Bar
+
+```python
+import time
+
+bar = hexlogger.ProgressBar(total=100, label="Downloading")
+for i in range(100):
+    time.sleep(0.05)
+    bar.update()
+```
+
+## Spinner
+
+```python
+import time
+
+# As context manager
+with hexlogger.Spinner("Loading data...", style="dots"):
+    time.sleep(3)
+
+# Manual control
+spinner = hexlogger.Spinner("Processing...", style="circle")
+spinner.start()
+time.sleep(2)
+spinner.stop("Done!")
+
+# Available styles: dots, line, arrow, bounce, box, circle
+```
+
+## Timer
+
+```python
+# As context manager
+with hexlogger.Timer("Database query"):
+    time.sleep(1.5)
+# Output: [INFO] Database query: 1.500s
+
+# Manual control
+timer = hexlogger.Timer("API call")
+timer.start()
+# ... do work ...
+elapsed = timer.stop()
+```
+
+## Key-Value Pairs
+
+```python
+hexlogger.pair("Server", "production-01")
+hexlogger.pair("Status", "running")
+hexlogger.pair("Uptime", "99.97%")
+```
+
+## Text Styling
+
+```python
+from hexlogger import bold, italic, underline, dim, strike, colorize, Colors
+
+print(bold("Bold text"))
+print(italic("Italic text"))
+print(underline("Underlined"))
+print(colorize("Custom color", Colors.CYAN))
+```
+
+## Configuration
+
+```python
+# Set time format
+hexlogger.set_time_format("%Y-%m-%d %H:%M:%S")
+
+# Hide timestamps
+hexlogger.show_time(False)
+
+# Log to file
+hexlogger.set_log_file("app.log")
+
+# Set minimum log level
+hexlogger.set_min_level("warning")  # Only WARNING and above
+```
+
+## Features
+
+- ✅ Zero dependencies
+- ✅ Beautiful colored output
+- ✅ 4 built-in themes + custom themes
+- ✅ Gradient & rainbow text
+- ✅ Panels, tables, banners
+- ✅ Progress bars with ETA
+- ✅ Animated spinners (6 styles)
+- ✅ Timer utility
+- ✅ File logging
+- ✅ Thread-safe
+- ✅ Windows compatible
+- ✅ Python 3.7+
+
+## License
+
+MIT License - Created by Montage

hexlogger-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+hexlogger/__init__.py,sha256=-4T2w83pDdFjrNICsyAOEt6m4BIXfLNVpffOdY1Sl8c,37324
+hexlogger-1.0.0.dist-info/licenses/LICENSE,sha256=hgTnvuHSQdWzCM80d4P2xDIXBtRzmQkNpKxv0m-Y8qg,1085
+hexlogger-1.0.0.dist-info/METADATA,sha256=o67ioG7FhR_-P9Ko6zpeXQHoP10_GlCBkSSkuv-xzcg,6508
+hexlogger-1.0.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+hexlogger-1.0.0.dist-info/top_level.txt,sha256=REGVvv7vdZCvSAU2lT7I9_OEGNP7KufdFUYRiflfzow,10
+hexlogger-1.0.0.dist-info/RECORD,,

hexlogger-1.0.0.dist-info/WHEEL

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

hexlogger-1.0.0.dist-info/licenses/LICENSE

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

hexlogger-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+hexlogger