logbar 0.2.0__tar.gz → 0.2.2__tar.gz

{logbar-0.2.0 → logbar-0.2.2}/LogBar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: LogBar
-Version: 0.2.0
+Version: 0.2.2
 Summary: A unified Logger and ProgressBar util with zero dependencies.
 Author-email: ModelCloud <qubitium@modelcloud.ai>
 License-Expression: Apache-2.0
@@ -84,6 +84,14 @@ log.error("cannot connect to database")
 log.critical.once("fuse blown, shutting down")
 ```
 
+Set a minimum output threshold per logger instance:
+
+```py
+log.setLevel("WARN")           # accepts DEBUG/INFO/WARN/ERROR/CRIT strings
+log.setLevel("ERROR")
+log.setLevel(LogBar.WARNING)   # alias to logging.WARNING
+```
+
 Typical mixed-level output (Note: Markdown cannot display ANSI colors):
 
 ```

{logbar-0.2.0 → logbar-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: LogBar
-Version: 0.2.0
+Version: 0.2.2
 Summary: A unified Logger and ProgressBar util with zero dependencies.
 Author-email: ModelCloud <qubitium@modelcloud.ai>
 License-Expression: Apache-2.0
@@ -84,6 +84,14 @@ log.error("cannot connect to database")
 log.critical.once("fuse blown, shutting down")
 ```
 
+Set a minimum output threshold per logger instance:
+
+```py
+log.setLevel("WARN")           # accepts DEBUG/INFO/WARN/ERROR/CRIT strings
+log.setLevel("ERROR")
+log.setLevel(LogBar.WARNING)   # alias to logging.WARNING
+```
+
 Typical mixed-level output (Note: Markdown cannot display ANSI colors):
 
 ```

{logbar-0.2.0 → logbar-0.2.2}/README.md

@@ -69,6 +69,14 @@ log.error("cannot connect to database")
 log.critical.once("fuse blown, shutting down")
 ```
 
+Set a minimum output threshold per logger instance:
+
+```py
+log.setLevel("WARN")           # accepts DEBUG/INFO/WARN/ERROR/CRIT strings
+log.setLevel("ERROR")
+log.setLevel(LogBar.WARNING)   # alias to logging.WARNING
+```
+
 Typical mixed-level output (Note: Markdown cannot display ANSI colors):
 
 ```

{logbar-0.2.0 → logbar-0.2.2}/logbar/logbar.py

@@ -482,7 +482,44 @@ class LEVEL(str, Enum):
 
 LEVEL_MAX_LENGTH = 5 # ERROR/DEBUG is longest at 5 chars
 
+LEVEL_TO_LOGGING = {
+    LEVEL.DEBUG: logging.DEBUG,
+    LEVEL.INFO: logging.INFO,
+    LEVEL.WARN: logging.WARNING,
+    LEVEL.ERROR: logging.ERROR,
+    LEVEL.CRITICAL: logging.CRITICAL,
+}
+
+LEVEL_NAME_TO_LOGGING = {
+    "DEBUG": logging.DEBUG,
+    "INFO": logging.INFO,
+    "WARN": logging.WARNING,
+    "WARNING": logging.WARNING,
+    "ERROR": logging.ERROR,
+    "CRIT": logging.CRITICAL,
+    "CRITICAL": logging.CRITICAL,
+    "FATAL": logging.CRITICAL,
+    "NOTSET": logging.NOTSET,
+}
+
+LOGGING_TO_LEVEL_LABEL = {
+    logging.DEBUG: LEVEL.DEBUG.value,
+    logging.INFO: LEVEL.INFO.value,
+    logging.WARNING: LEVEL.WARN.value,
+    logging.ERROR: LEVEL.ERROR.value,
+    logging.CRITICAL: LEVEL.CRITICAL.value,
+}
+
 class LogBar(logging.Logger):
+    NOTSET = logging.NOTSET
+    DEBUG = logging.DEBUG
+    INFO = logging.INFO
+    WARN = logging.WARNING
+    WARNING = logging.WARNING
+    ERROR = logging.ERROR
+    CRITICAL = logging.CRITICAL
+    FATAL = logging.CRITICAL
+
     history = set()
     history_limit = 1000
 
@@ -627,6 +664,57 @@ class LogBar(logging.Logger):
         self.history = set()
         self._history_lock = threading.Lock()
 
+    def _normalize_level(self, level: Union[LEVEL, int, str]) -> int:
+        if isinstance(level, LEVEL):
+            return LEVEL_TO_LOGGING[level]
+
+        if isinstance(level, int):
+            return level
+
+        if isinstance(level, str):
+            normalized = level.strip().upper()
+            if not normalized:
+                raise ValueError("Log level must not be empty.")
+
+            if normalized in LEVEL_NAME_TO_LOGGING:
+                return LEVEL_NAME_TO_LOGGING[normalized]
+
+            numeric = normalized
+            if normalized.startswith(("+", "-")):
+                numeric = normalized[1:]
+
+            if numeric.isdigit():
+                return int(normalized)
+
+            raise ValueError(f"Unknown log level: {level!r}")
+
+        raise TypeError(
+            "Log level must be a LEVEL enum, integer, or string name."
+        )
+
+    def _level_label(self, level: Union[LEVEL, int, str], normalized_level: int) -> str:
+        if isinstance(level, LEVEL):
+            return level.value
+
+        if isinstance(level, str):
+            normalized = level.strip().upper()
+            if normalized in ("WARNING", "WARN"):
+                return LEVEL.WARN.value
+            if normalized in ("CRITICAL", "FATAL", "CRIT"):
+                return LEVEL.CRITICAL.value
+            if normalized in ("DEBUG", "INFO", "ERROR"):
+                return normalized
+
+        return LOGGING_TO_LEVEL_LABEL.get(
+            normalized_level,
+            str(logging.getLevelName(normalized_level)),
+        )
+
+    def setLevel(self, level: Union[LEVEL, int, str]) -> None:
+        """Set the per-instance minimum output threshold for LogBar methods."""
+
+        super().setLevel(self._normalize_level(level))
+
     def columns(self, *headers, cols: Optional[Sequence] = None, width: Optional[Union[str, int, float]] = None, padding: int = 2):
         """Return a column-aware helper that keeps column widths aligned."""
 
@@ -707,9 +795,15 @@ class LogBar(logging.Logger):
 
         return " ".join(part for part in parts if part)
 
-    def _process(self, level: LEVEL, msg, *args, **kwargs):
+    def _process(self, level: Union[LEVEL, int, str], msg, *args, **kwargs):
         global last_rendered_length
 
+        normalized_level = self._normalize_level(level)
+        if not self.isEnabledFor(normalized_level):
+            return
+
+        level_label = self._level_label(level, normalized_level)
+        level_width = max(LEVEL_MAX_LENGTH, len(level_label))
         str_msg = self._format_message(msg, args)
 
         with _RENDER_LOCK:
@@ -718,10 +812,10 @@ class LogBar(logging.Logger):
             with _STATE_LOCK:
                 previous_render_length = last_rendered_length
 
-            line_length = len(level.value) + (LEVEL_MAX_LENGTH - len(level.value)) + 1 + len(str_msg)
+            line_length = level_width + 1 + len(str_msg)
 
             if columns > 0:
-                padding_needed = max(0, columns - LEVEL_MAX_LENGTH - 2 - len(str_msg))
+                padding_needed = max(0, columns - level_width - 2 - len(str_msg))
                 rendered_message = f"{str_msg}{' ' * padding_needed}"
                 printable_length = columns
             else:
@@ -732,10 +826,10 @@ class LogBar(logging.Logger):
             _clear_progress_stack_locked(for_log_output=True)
 
             reset = COLORS["RESET"]
-            color = COLORS.get(level.value, reset)
+            color = COLORS.get(level_label, reset)
 
-            level_padding = " " * (LEVEL_MAX_LENGTH - len(level.value)) # 5 is max enum string length
-            _print(f"\r{color}{level.value}{reset}{level_padding} {rendered_message}", end='\n', flush=True)
+            level_padding = " " * (level_width - len(level_label))
+            _print(f"\r{color}{level_label}{reset}{level_padding} {rendered_message}", end='\n', flush=True)
 
             with _STATE_LOCK:
                 last_rendered_length = printable_length

{logbar-0.2.0 → logbar-0.2.2}/logbar/progress.py

@@ -695,7 +695,10 @@ class ProgressBar:
     def calc_time(self, iteration):
         used_time = int(time.time() - self.time)
         formatted_time = str(datetime.timedelta(seconds=used_time))
-        remaining = str(datetime.timedelta(seconds=int((used_time / max(iteration, 1)) * len(self))))
+        completed = iteration
+        if self._render_mode == RenderMode.AUTO and iteration > 0:
+            completed = iteration - 1
+        remaining = str(datetime.timedelta(seconds=int((used_time / max(completed, 1)) * len(self))))
         return f"{formatted_time} / {remaining}"
 
     def _render_snapshot(self, columns: Optional[int] = None) -> str:

{logbar-0.2.0 → logbar-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "LogBar"
-version = "0.2.0"
+version = "0.2.2"
 description = "A unified Logger and ProgressBar util with zero dependencies."
 readme = "README.md"
 requires-python = ">=3"

{logbar-0.2.0 → logbar-0.2.2}/tests/test_columns.py

@@ -110,6 +110,8 @@ def test_columns_simulate_updates_width_without_output():
 
 def test_columns_support_other_levels(capsys):
     cols = log.columns(cols=("name", "age"))
+    previous_level = log.level
+    log.setLevel("DEBUG")
 
     buffer = io.StringIO()
 
@@ -123,17 +125,20 @@ def test_columns_support_other_levels(capsys):
             sys.__stdout__.flush()
             buffer.flush()
 
-    with mock.patch('logbar.logbar.terminal_size', return_value=(0, 0)):
-        with capsys.disabled():
-            with redirect_stdout(Tee()):
-                cols.debug.header()
-                cols.debug("debug", "10")
-                cols.warn.header()
-                cols.warn("warn", "20")
-                cols.error.header()
-                cols.error("error", "30")
-                cols.critical.header()
-                cols.critical("critical", "40")
+    try:
+        with mock.patch('logbar.logbar.terminal_size', return_value=(0, 0)):
+            with capsys.disabled():
+                with redirect_stdout(Tee()):
+                    cols.debug.header()
+                    cols.debug("debug", "10")
+                    cols.warn.header()
+                    cols.warn("warn", "20")
+                    cols.error.header()
+                    cols.error("error", "30")
+                    cols.critical.header()
+                    cols.critical("critical", "40")
+    finally:
+        log.setLevel(previous_level)
 
     captured = _clean(buffer.getvalue())
     lines = [line for line in captured.splitlines() if line.strip()]

{logbar-0.2.0 → logbar-0.2.2}/tests/test_log.py

@@ -4,6 +4,7 @@
 # Contact: qubitium@modelcloud.ai, x.com/qubitium
 
 import io
+import logging
 import sys
 import threading
 from contextlib import redirect_stdout
@@ -39,6 +40,50 @@ class TestProgressBar(unittest.TestCase):
         log.error("hello error")
         log.critical("hello critical")
 
+    def test_set_level_string_filters_custom_helpers(self):
+        local_log = LogBar("test_set_level_string_filters_custom_helpers")
+        local_log.setLevel("ERROR")
+
+        def emit():
+            local_log.debug("debug hidden token")
+            local_log.info("info hidden token")
+            local_log.error("error visible token")
+
+        output = self.capture_log(emit)
+        self.assertIn("error visible token", output)
+        self.assertNotIn("debug hidden token", output)
+        self.assertNotIn("info hidden token", output)
+
+    def test_set_level_filters_custom_helpers(self):
+        local_log = LogBar("test_set_level_filters_custom_helpers")
+        local_log.setLevel(logging.WARNING)
+
+        def emit():
+            local_log.info("info hidden by setLevel")
+            local_log.warn("warn visible by setLevel")
+
+        output = self.capture_log(emit)
+        self.assertIn("warn visible by setLevel", output)
+        self.assertNotIn("info hidden by setLevel", output)
+
+    def test_set_level_logbar_warning_alias_filters_custom_helpers(self):
+        local_log = LogBar("test_set_level_logbar_warning_alias_filters_custom_helpers")
+        self.assertEqual(LogBar.WARNING, logging.WARNING)
+        local_log.setLevel(LogBar.WARNING)
+
+        def emit():
+            local_log.info("info hidden by LogBar.WARNING")
+            local_log.warn("warn visible by LogBar.WARNING")
+
+        output = self.capture_log(emit)
+        self.assertIn("warn visible by LogBar.WARNING", output)
+        self.assertNotIn("info hidden by LogBar.WARNING", output)
+
+    def test_set_level_rejects_unknown_names(self):
+        local_log = LogBar("test_set_level_rejects_unknown_names")
+        with self.assertRaises(ValueError):
+            local_log.setLevel("TRACE")
+
     def test_log_without_terminal_state(self):
         """LogBar should operate even when the runtime lacks a terminal."""
 

{logbar-0.2.0 → logbar-0.2.2}/tests/test_progress.py

@@ -173,6 +173,31 @@ class TestProgress(unittest.TestCase):
         with redirect_stdout(StringIO()):
             pb.close()
 
+    def test_time_estimate_accounts_for_last_item(self):
+        pb = ProgressBar(range(3))
+        pb.current_iter_step = 3
+        pb.time = 0
+
+        with patch('logbar.progress.time.time', return_value=10):
+            estimate = pb.calc_time(pb.step())
+
+        elapsed_str, total_str = [part.strip() for part in estimate.split("/", 1)]
+
+        def to_seconds(value: str) -> int:
+            parts = [int(part) for part in value.split(":")]
+            if len(parts) == 3:
+                hours, minutes, seconds = parts
+            elif len(parts) == 2:
+                hours = 0
+                minutes, seconds = parts
+            else:
+                hours = 0
+                minutes = 0
+                seconds = parts[0]
+            return hours * 3600 + minutes * 60 + seconds
+
+        self.assertGreater(to_seconds(total_str), to_seconds(elapsed_str))
+
     def test_draw_without_terminal_state(self):
         pb = log.pb(10).manual()
         pb.current_iter_step = 5