hexlogger 2.0.2__tar.gz → 2.0.3__tar.gz

{hexlogger-2.0.2 → hexlogger-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexlogger
-Version: 2.0.2
+Version: 2.0.3
 Summary: Premium console logging library with themes, gradients, panels, tables, progress bars, and spinners.
 Author: Itz Montage
 License: MIT

{hexlogger-2.0.2 → hexlogger-2.0.3}/hexlogger/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.0.2"
+__version__ = "2.0.3"
 __author__ = "Montage"
 
 from .colors import Colors, rgb, bgrgb, hexclr, bghex

{hexlogger-2.0.2 → hexlogger-2.0.3}/hexlogger/core.py

@@ -14,16 +14,6 @@ def _get_time():
         return ""
 
 
-def _write_to_file(message):
-    cfg = get_config()
-    if cfg._file_handle:
-        try:
-            cfg._file_handle.write(strip_ansi(message) + "\n")
-            cfg._file_handle.flush()
-        except Exception:
-            pass
-
-
 def _log(level, message, level_enum):
     try:
         cfg = get_config()
@@ -31,13 +21,16 @@ def _log(level, message, level_enum):
             return
         t = cfg.theme
         now = _get_time()
-        level_color = t.get(level)
-        level_label = t.get(f"label_{level}")
         style_fn = STYLES.get(cfg.style, STYLES["default"])
-        line = style_fn(now, level, level_color, level_label, str(message), t, cfg.show_time)
+        line = style_fn(now, level, t.get(level), t.get(f"label_{level}"), str(message), t, cfg.show_time)
         with cfg._lock:
             print(line)
-            _write_to_file(line)
+            if cfg._file_handle:
+                try:
+                    cfg._file_handle.write(strip_ansi(line) + "\n")
+                    cfg._file_handle.flush()
+                except Exception:
+                    pass
     except Exception:
         try:
             print(f"[{level.upper()}] {message}")

{hexlogger-2.0.2 → hexlogger-2.0.3}/hexlogger/formatting.py

@@ -1,12 +1,11 @@
 from .colors import Colors
 from .config import get_config
-from .utils import strip_ansi
+from .utils import strip_ansi, get_terminal_width, wrap_lines
 
 __all__ = ["divider", "section", "blank", "rule", "banner", "pair"]
 
 
-def _write(message):
-    cfg = get_config()
+def _write(cfg, message):
     if cfg._file_handle:
         try:
             cfg._file_handle.write(strip_ansi(message) + "\n")
@@ -19,11 +18,11 @@ def divider(char="─", length=60, color=None):
     try:
         cfg = get_config()
         c = color or cfg.theme.get("divider")
-        length = max(1, int(length))
+        length = min(max(1, int(length)), get_terminal_width())
         line = f"{c}{str(char)[0] * length}{Colors.RESET}"
         with cfg._lock:
             print(line)
-            _write(line)
+            _write(cfg, line)
     except Exception:
         print(str(char) * max(1, int(length)))
 
@@ -33,8 +32,9 @@ def section(title="", char="═", length=60):
         cfg = get_config()
         t = cfg.theme
         title = str(title)
-        length = max(len(title) + 4, int(length))
-        pad = length - len(title) - 2
+        title_len = len(strip_ansi(title))
+        length = min(max(title_len + 4, int(length)), get_terminal_width())
+        pad = length - title_len - 2
         left = pad // 2
         right = pad - left
         line = (
@@ -44,14 +44,20 @@ def section(title="", char="═", length=60):
         )
         with cfg._lock:
             print(line)
-            _write(line)
+            _write(cfg, line)
     except Exception:
         print(f"== {title} ==")
 
 
 def blank(count=1):
-    for _ in range(max(1, int(count))):
-        print()
+    try:
+        cfg = get_config()
+        with cfg._lock:
+            for _ in range(max(1, int(count))):
+                print()
+    except Exception:
+        for _ in range(max(1, int(count))):
+            print()
 
 
 def rule(text="", char="─", length=60):
@@ -66,16 +72,23 @@ def banner(text="", char="═", padding=2):
         cfg = get_config()
         text = str(text)
         padding = max(0, int(padding))
-        lines = text.split("\n")
-        max_len = max((len(l) for l in lines), default=0)
-        width = max_len + (padding * 2) + 2
+        term_w = get_terminal_width()
+        max_inner = max(term_w - 2, 1)
+        lines = wrap_lines(text.split("\n"), max_inner - (padding * 2))
+        max_len = max((len(strip_ansi(l)) for l in lines), default=0)
+        width = min(max_len + (padding * 2) + 2, term_w)
         t = cfg.theme
         bc, tc, R = t.get("info"), t.get("success"), Colors.RESET
         ch = str(char)[0] if char else "═"
         with cfg._lock:
             print(f"{bc}╔{ch * (width - 2)}╗{R}")
             for l in lines:
-                print(f"{bc}║{R}{' ' * padding}{tc}{l.center(max_len)}{R}{' ' * padding}{bc}║{R}")
+                s_len = len(strip_ansi(l))
+                space = max(max_len - s_len, 0)
+                lp = space // 2
+                rp = space - lp
+                padded = f"{' ' * lp}{l}{' ' * rp}"
+                print(f"{bc}║{R}{' ' * padding}{tc}{padded}{R}{' ' * padding}{bc}║{R}")
             print(f"{bc}╚{ch * (width - 2)}╝{R}")
     except Exception:
         print(text)
@@ -89,6 +102,6 @@ def pair(k, v, k_clr=None, v_clr=None):
         k, v = str(k), str(v)
         with cfg._lock:
             print(f"  {kc}{Colors.BOLD}{k}{Colors.RESET}: {vc}{v}{Colors.RESET}")
-            _write(f"  {k}: {v}")
+            _write(cfg, f"  {k}: {v}")
     except Exception:
         print(f"  {k}: {v}")

{hexlogger-2.0.2 → hexlogger-2.0.3}/hexlogger/progress.py

@@ -4,6 +4,7 @@ import threading
 
 from .colors import Colors
 from .config import get_config
+from .utils import get_terminal_width
 
 __all__ = ["Progress", "Spinner", "Timer"]
 
@@ -28,18 +29,25 @@ class Progress:
 
     def _render(self):
         try:
+            term_w = get_terminal_width()
             pct = self.current / self.total
-            filled = int(self.width * pct)
-            bar = self.fill * filled + self.empty * (self.width - filled)
+            stats = f" ({self.current}/{self.total}) [{time.time() - self._start:.1f}s]"
+            label_part = f"{self.color}{self.label}{Colors.RESET} │"
+            bar_end = f"│ {Colors.BOLD}{pct * 100:5.1f}%{Colors.RESET}{stats}"
+            overhead = len(self.label) + 3 + 10 + len(stats)
+            bar_w = min(self.width, max(5, term_w - overhead))
+            filled = int(bar_w * pct)
+            bar = self.fill * filled + self.empty * (bar_w - filled)
             elapsed = time.time() - self._start
             eta = (elapsed / pct - elapsed) if pct > 0 else 0
-            sys.stdout.write(
+            line = (
                 f"\r{self.color}{self.label}{Colors.RESET} "
                 f"│{self.color}{bar}{Colors.RESET}│ "
                 f"{Colors.BOLD}{pct * 100:5.1f}%{Colors.RESET} "
                 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()
@@ -64,18 +72,18 @@ class Spinner:
             self.color = color or get_config().theme.get("info")
         except Exception:
             self.color = ""
-        self._run = False
+        self._stop_event = threading.Event()
         self._thread = None
 
     def start(self):
-        self._run = True
+        self._stop_event.clear()
         self._thread = threading.Thread(target=self._spin, daemon=True)
         self._thread.start()
         return self
 
     def _spin(self):
         i = 0
-        while self._run:
+        while not self._stop_event.is_set():
             try:
                 frame = self.frames[i % len(self.frames)]
                 sys.stdout.write(f"\r{self.color}{frame}{Colors.RESET} {self.msg}")
@@ -83,17 +91,17 @@ class Spinner:
             except Exception:
                 pass
             i += 1
-            time.sleep(0.08)
+            self._stop_event.wait(0.08)
 
     def stop(self, final=""):
-        self._run = False
+        self._stop_event.set()
         if self._thread:
             try:
                 self._thread.join(timeout=2)
             except Exception:
                 pass
         try:
-            sys.stdout.write("\r" + " " * (len(self.msg) + 10) + "\r")
+            sys.stdout.write(f"\r\033[2K\r")
             sys.stdout.flush()
         except Exception:
             pass

hexlogger-2.0.3/hexlogger/utils.py

@@ -0,0 +1,74 @@
+import re
+import shutil
+
+from .colors import Colors
+
+__all__ = ["strip_ansi", "clr", "bold", "italic", "uline"]
+
+_ANSI_RE = re.compile(r'\033\[[0-9;]*m')
+
+
+def strip_ansi(text):
+    try:
+        return _ANSI_RE.sub('', str(text))
+    except Exception:
+        return str(text)
+
+
+def get_terminal_width():
+    try:
+        return shutil.get_terminal_size().columns
+    except Exception:
+        return 120
+
+
+def wrap_line(text, max_width):
+    if len(strip_ansi(text)) <= max_width:
+        return [text]
+    wrapped = []
+    current = ""
+    current_len = 0
+    i = 0
+    while i < len(text):
+        if text[i] == '\033' and i + 1 < len(text) and text[i + 1] == '[':
+            j = i + 2
+            while j < len(text) and text[j] not in 'mGHJK':
+                j += 1
+            if j < len(text):
+                j += 1
+            current += text[i:j]
+            i = j
+        else:
+            if current_len >= max_width:
+                wrapped.append(current)
+                current = ""
+                current_len = 0
+            current += text[i]
+            current_len += 1
+            i += 1
+    if current:
+        wrapped.append(current)
+    return wrapped if wrapped else [text]
+
+
+def wrap_lines(lines, max_width):
+    result = []
+    for line in lines:
+        result.extend(wrap_line(line, max_width))
+    return result
+
+
+def clr(text, color):
+    return f"{color}{text}{Colors.RESET}"
+
+
+def bold(text):
+    return f"{Colors.BOLD}{text}{Colors.RESET}"
+
+
+def italic(text):
+    return f"{Colors.ITALIC}{text}{Colors.RESET}"
+
+
+def uline(text):
+    return f"{Colors.UNDERLINE}{text}{Colors.RESET}"

{hexlogger-2.0.2 → hexlogger-2.0.3}/hexlogger/widgets.py

@@ -1,6 +1,6 @@
 from .colors import Colors
 from .config import get_config
-from .utils import strip_ansi
+from .utils import strip_ansi, get_terminal_width, wrap_lines
 
 __all__ = ["panel", "table", "box"]
 
@@ -34,12 +34,18 @@ def panel(content="", title="", width=50, color=None, style="rounded"):
         R = Colors.RESET
         tl, tr, bl, br, h, v = _PANEL_CHARS.get(style, _PANEL_CHARS["rounded"])
         content = str(content)
-        lines = content.split("\n")
-        width = max(width, 8)
+        term_w = get_terminal_width()
+        max_inner = max(term_w - 4, 8)
+        lines = wrap_lines(content.split("\n"), max_inner)
+        max_line_len = max((len(strip_ansi(l)) for l in lines), default=0)
+        width = max(width, max_line_len + 4, 8)
+        if title:
+            title = str(title)
+            width = max(width, len(strip_ansi(title)) + 6)
+        width = min(width, term_w)
         inner_w = width - 4
         with cfg._lock:
             if title:
-                title = str(title)
                 header_pad = max(width - len(strip_ansi(title)) - 5, 1)
                 print(f"{bc}{tl}{h} {Colors.BOLD}{title}{R}{bc} {h * header_pad}{tr}{R}")
             else:
@@ -64,13 +70,14 @@ def table(headers=None, rows=None, color=None, style="rounded"):
         hc = cfg.theme.get("success")
         R, B = Colors.RESET, Colors.BOLD
         tl, tr, bl, br, h, v, tm, bm, ml, mr, mm = _TABLE_CHARS.get(style, _TABLE_CHARS["rounded"])
-        col_w = [len(hdr) for hdr in headers]
+        col_w = [len(strip_ansi(hdr)) for hdr in headers]
         for r in rows:
             for i, c in enumerate(r):
+                vl = len(strip_ansi(c))
                 if i < len(col_w):
-                    col_w[i] = max(col_w[i], len(c))
+                    col_w[i] = max(col_w[i], vl)
                 else:
-                    col_w.append(len(c))
+                    col_w.append(vl)
 
         def _sep(left, mid, right, fill):
             return f"{bc}{left}{mid.join(fill * (w + 2) for w in col_w)}{right}{R}"
@@ -78,8 +85,9 @@ def table(headers=None, rows=None, color=None, style="rounded"):
         def _row(cells, c=""):
             padded = []
             for i, cell in enumerate(cells):
-                w = col_w[i] if i < len(col_w) else len(cell)
-                padded.append(f" {c}{cell.ljust(w)}{R} ")
+                w = col_w[i] if i < len(col_w) else len(strip_ansi(cell))
+                pad = max(w - len(strip_ansi(cell)), 0)
+                padded.append(f" {c}{cell}{' ' * pad}{R} ")
             return f"{bc}{v}{R}" + f"{bc}{v}{R}".join(padded) + f"{bc}{v}{R}"
 
         with cfg._lock:
@@ -105,10 +113,13 @@ def box(text="", width=None, style="rounded", color=None, text_clr=None, align="
         tl, tr, bl, br, h, v = _BOX_CHARS.get(style, _BOX_CHARS["rounded"])
         text = str(text)
         padding = max(0, int(padding))
-        lines = text.split("\n")
+        term_w = get_terminal_width()
+        max_inner = max(term_w - 4, 1)
+        lines = wrap_lines(text.split("\n"), max_inner)
         max_line = max((len(strip_ansi(l)) for l in lines), default=0)
         inner_w = (width - 4) if width else max_line + (padding * 2)
-        inner_w = max(inner_w, 1)
+        inner_w = max(inner_w, max_line, 1)
+        inner_w = min(inner_w, max_inner)
         total_w = inner_w + 4
         with cfg._lock:
             print(f"{bc}{tl}{h * (total_w - 2)}{tr}{R}")
@@ -116,9 +127,9 @@ def box(text="", width=None, style="rounded", color=None, text_clr=None, align="
                 s_len = len(strip_ansi(l))
                 space = max(inner_w - s_len, 0)
                 if align == "center":
-                    left_pad = space // 2
-                    right_pad = space - left_pad
-                    padded = f"{' ' * left_pad}{tc}{l}{R}{' ' * right_pad}"
+                    lp = space // 2
+                    rp = space - lp
+                    padded = f"{' ' * lp}{tc}{l}{R}{' ' * rp}"
                 elif align == "right":
                     padded = f"{' ' * space}{tc}{l}{R}"
                 else:
@@ -127,4 +138,3 @@ def box(text="", width=None, style="rounded", color=None, text_clr=None, align="
             print(f"{bc}{bl}{h * (total_w - 2)}{br}{R}")
     except Exception:
         print(text)
-

{hexlogger-2.0.2 → hexlogger-2.0.3}/hexlogger.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexlogger
-Version: 2.0.2
+Version: 2.0.3
 Summary: Premium console logging library with themes, gradients, panels, tables, progress bars, and spinners.
 Author: Itz Montage
 License: MIT

{hexlogger-2.0.2 → hexlogger-2.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hexlogger"
-version = "2.0.2"
+version = "2.0.3"
 description = "Premium console logging library with themes, gradients, panels, tables, progress bars, and spinners."
 readme = "README.md"
 license = {text = "MIT"}

hexlogger-2.0.2/hexlogger/utils.py

@@ -1,30 +0,0 @@
-import re
-
-from .colors import Colors
-
-__all__ = ["strip_ansi", "clr", "bold", "italic", "uline"]
-
-_ANSI_RE = re.compile(r'\033\[[0-9;]*m')
-
-
-def strip_ansi(text):
-    try:
-        return _ANSI_RE.sub('', str(text))
-    except Exception:
-        return str(text)
-
-
-def clr(text, color):
-    return f"{color}{text}{Colors.RESET}"
-
-
-def bold(text):
-    return f"{Colors.BOLD}{text}{Colors.RESET}"
-
-
-def italic(text):
-    return f"{Colors.ITALIC}{text}{Colors.RESET}"
-
-
-def uline(text):
-    return f"{Colors.UNDERLINE}{text}{Colors.RESET}"