zstdlib 0.0.6__tar.gz → 0.0.9__tar.gz

{zstdlib-0.0.6 → zstdlib-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zstdlib
-Version: 0.0.6
+Version: 0.0.9
 Summary: A set of useful python utilities
 License: GPLv3
 Project-URL: Homepage, https://github.com/zwimer/zstdlib

{zstdlib-0.0.6 → zstdlib-0.0.9}/tests/log/test_cute.py

@@ -17,16 +17,25 @@ class TestCuteFormatter(LeftBase, unittest.TestCase):
         msg = self.messages[log][0].rsplit("|", 1)[-1]
         self.assertEqual(f" {color.code}test{Color.RESET}", msg)
 
-    def test_name_width(self) -> None:
-        width = 123
+    def test_width(self) -> None:
         color = Color.red
-        name = "TestCuteFormatter.name_width"
-        with self.hijack(name, fmt=CuteFormatter(colors={name: color}, name_width=width)) as log:
+        name = "TestCuteFormatter.test_width"
+        cw = {
+            "cute_levelname": 300,
+            "cute_asctime": 200,
+            "cute_name": 100,
+            "cute_message": 400,
+        }
+        fmt = CuteFormatter(fmt="|".join(f"%({i})s" for i in cw), colors={name: color}, cute_widths=cw)
+        with self.hijack(name, fmt=fmt) as log:
             log.debug("test")
-        lvl, _, nam, msg = self.messages[log][0].split("|")
-        self.assertEqual("DEBUG", lvl.strip())
-        self.assertEqual(f" {color(name.ljust(width))} ", nam)
-        self.assertEqual(f" {color('test')}", msg)
+        lvl, date, nam, msg = self.messages[log][0].split("|")
+        self.assertEqual("DEBUG".ljust(cw["cute_levelname"]), lvl)
+        self.assertEqual(cw["cute_asctime"], len(date))
+        self.assertEqual(f"{color(name.ljust(cw['cute_name']))}", nam)
+        self.assertEqual(f"{color('test'.ljust(cw['cute_message']))}", msg)
+        with self.assertRaises(ValueError):
+            CuteFormatter(cute_widths={"name": 123})
 
     def test_no_color(self) -> None:
         name = "TestCuteFormatter.test_no_color"
@@ -69,6 +78,28 @@ class TestCuteFormatter(LeftBase, unittest.TestCase):
         self.assertEqual(Color.bright_red_bg_yellow("CRITICAL".ljust(8)), l_name(5))
         self.assertEqual(Color.bright_red_bg_yellow("Level 60".ljust(8)), l_name(6))
 
+    def test_custom_dim_level(self) -> None:
+        name = "TestCuteFormatter.test_dim_level"
+        msg = "test"
+        with self.hijack(name, fmt=CuteFormatter(dim_level=5)) as log:
+            log.log(4, msg)
+            log.log(5, msg)
+        self.assertEqual(2, len(self.messages[log]))
+        l_name = lambda idx: self.messages[log][idx].split("|")[0].strip()
+        self.assertEqual(Color.dim("Level 4".ljust(8)), l_name(0))
+        self.assertEqual("Level 5", l_name(1))
+
+    def test_custom_level_color(self) -> None:
+        name = "TestCuteFormatter.test_custom_level_color"
+        msg = "test"
+        with self.hijack(name, fmt=CuteFormatter(level_colors={15: Color.bright_red_bg_yellow})) as log:
+            log.log(14, msg)
+            log.log(15, msg)
+        self.assertEqual(2, len(self.messages[log]))
+        l_name = lambda idx: self.messages[log][idx].split("|")[0].strip()
+        self.assertEqual("Level 14".ljust(8), l_name(0))
+        self.assertEqual(Color.bright_red_bg_yellow("Level 15".ljust(8)), l_name(1))
+
     def test_exception(self) -> None:
         name = "TestCuteFormatter.test_exception"
         with self.hijack(name, fmt=CuteFormatter()) as log:

{zstdlib-0.0.6 → zstdlib-0.0.9}/zstdlib/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.6"
+__version__ = "0.0.9"
 
 from .not_set import NotSetType, NotSet
 from .frozen import Freezable, frozen

{zstdlib-0.0.6 → zstdlib-0.0.9}/zstdlib/ansi.py

@@ -107,6 +107,12 @@ class Color(metaclass=_ColorMeta):
             raise TypeError("Cannot add non-Color to Color")
         return type(self)(code=f"{self.code[:-1]};{other.code[len(_PREFIX):]}")
 
+    def __eq__(self, other: object) -> bool:
+        """
+        :return: Whether the two colors are equal
+        """
+        return isinstance(other, type(self)) and self.code == other.code
+
     def __repr__(self) -> str:
         """
         :return: The ansi color code this object represents

zstdlib-0.0.9/zstdlib/log/cute.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+from logging import CRITICAL, ERROR, WARNING, INFO, DEBUG, Formatter
+from collections import defaultdict
+from typing import TYPE_CHECKING
+from zlib import adler32
+from copy import copy
+
+from ..ansi import PureColor, RawColor, Color
+
+if TYPE_CHECKING:
+    from logging import LogRecord
+
+
+class CuteFormatter(Formatter):
+    """
+    A log formatter that can print log messages with colors.
+    """
+
+    __slots__ = ("colored", "_color", "_cmap", "_lvl_cmap", "_dim_level", "_name_width")
+    DEFAULT_CUTE_WIDTHS: dict[str, int] = {"cute_levelname": 8, "cute_time": 23, "cute_name": 12}
+    DEFAULT_LEVEL_COLORS: dict[int, Color] = {
+        INFO: Color.blue,
+        WARNING: Color.yellow,
+        ERROR: Color.red,
+        CRITICAL: Color.bright_red_bg_yellow,
+    }
+
+    # pylint: disable=dangerous-default-value,keyword-arg-before-vararg,too-many-arguments
+    def __init__(
+        self,
+        fmt="%(cute_levelname)s | %(cute_asctime)s | %(cute_name)s | %(cute_message)s",
+        *args,
+        colored: bool = True,
+        dim_level: int = DEBUG,
+        colors: dict[str, Color] = {},
+        level_colors: dict[int, Color] = {},
+        cute_widths: dict[str, int] = {},
+        **kwargs,
+    ):
+        """
+        log_colors may be overridden, for example, trace logs are printed dimly
+        Do not modify cute_ parameters in the fmt string; they might have special formatting that is not visible
+        Ex. %(cute_name)-8s should be done via cute_widths["cute_name"] = 8
+        This is because cute_widths takes into account 0-width color codes when padding
+        Level colors used are: DEFAULT_LEVEL_COLORS | level_colors
+        Dimming of log messages is done for levels < dim_level
+        :param fmt: The format string to use for the log message; do not modify cute_ parameters
+        :param args: Passed to logging.Formatter
+        :param colored: If False, no colors will be used regardless of the colors parameter
+        :param colors: The colors to use for the given loggers, automatic for non-specified loggers
+        :param level_colors: The colors to use >= the given levels, automatic for non-specified loggers
+        :param cute_widths: The widths of the cute_ columns in the log message
+        :param kwargs: Passed to logging.Formatter
+        """
+        super().__init__(fmt, *args, **kwargs)
+        self._dim_level: int = dim_level
+        self._cmap: dict[str, Color] = dict(colors)
+        self._lvl_cmap: dict[int, Color] = self.DEFAULT_LEVEL_COLORS | level_colors
+        self._widths = defaultdict(int, self.DEFAULT_CUTE_WIDTHS | cute_widths)
+        if any(not i.startswith("cute_") for i in self._widths):
+            raise ValueError("cute_widths must only contain cute_ parameters")
+        self.colored: bool = colored
+
+    def update(self, colors: dict[str, Color]):
+        """
+        Set the colors for all loggers; enables colors if disabled
+        """
+        self._cmap |= colors
+
+    def format(self, record: LogRecord) -> str:
+        levelname: str = record.levelname.ljust(self._widths["cute_levelname"])
+        asctime = self.formatTime(record, self.datefmt).ljust(self._widths["cute_asctime"])
+        name: str = record.name.ljust(self._widths["cute_name"])
+        message: str = record.getMessage().ljust(self._widths["cute_message"])
+        if self.colored:
+            # Color level
+            opts = tuple(i for i in self._lvl_cmap if i <= record.levelno)
+            col: Color | None = self._lvl_cmap[max(opts)] if opts else None
+            if record.levelno < self._dim_level:
+                col = Color.dim if col is None else (col + Color.dim)
+            if col is not None:
+                levelname = col(levelname)
+            # Color text
+            if (col := self._cmap.get(record.name, None)) is None:
+                c: int = adler32(record.name.encode()) % 7
+                col = Color(RawColor(PureColor.black.value + c)) if c != 0 else Color.default
+            if record.levelno < self._dim_level:
+                col += Color.dim
+            message = col(message)
+            name = col(name)
+            # Color timestamp
+            if record.levelno < self._dim_level:
+                asctime = Color.dim(asctime)
+        # Create an updated record then format that
+        new = copy(record)
+        new.__dict__.update(
+            {
+                "cute_levelname": levelname,
+                "cute_asctime": asctime,
+                "cute_name": name,
+                "cute_message": message,
+            }
+        )
+        return super().format(new)

{zstdlib-0.0.6 → zstdlib-0.0.9}/zstdlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zstdlib
-Version: 0.0.6
+Version: 0.0.9
 Summary: A set of useful python utilities
 License: GPLv3
 Project-URL: Homepage, https://github.com/zwimer/zstdlib

zstdlib-0.0.6/zstdlib/log/cute.py

@@ -1,92 +0,0 @@
-from __future__ import annotations
-from logging import CRITICAL, ERROR, WARNING, INFO, DEBUG, Formatter
-from traceback import format_exception
-from typing import TYPE_CHECKING
-from zlib import adler32
-from copy import copy
-
-from ..ansi import PureColor, RawColor, Color
-
-if TYPE_CHECKING:
-    from logging import LogRecord
-
-
-class CuteFormatter(Formatter):
-    """
-    A log formatter that can print log messages with colors.
-    """
-
-    __slots__ = ("colored", "_color", "_cmap", "_name_width")
-
-    def __init__(
-        self,
-        colors: dict[str, Color] | None = None,
-        *,
-        colored: bool = True,
-        name_width: int = 12,
-        fmt="%(cute_levelname)s | %(cute_time)s | %(cute_name)s | %(cute_message)s%(cute_exc)s",
-        **kwargs,
-    ):
-        """
-        log_colors may be overridden, for example, trace logs are printed dimly
-        Do not modify cute_ parameters in the fmt string; they might have special formatting that is not visible
-        Ex. %(cute_name)-8s should be done via name_width, that takes into account 0-width color codes
-        :param colors: The colors to use for the given loggers, automatic for non-specified loggers
-        :param colored: If False, no colors will be used regardless of the colors parameter
-        :param fmt: The format string to use for the log message; do not modify cute_ parameters
-        :param name_width: How wide the column containing the logger name should be (minus padding)
-        :param kwargs: Passed to logging.Formatter
-        """
-        super().__init__(fmt=fmt, **kwargs)
-        self._cmap: dict[str, Color] = {}
-        if colors is not None:
-            self.update(colors)
-        self._name_width = name_width
-        self.colored: bool = colored
-
-    def update(self, colors: dict[str, Color]):
-        """
-        Set the colors for all loggers; enables colors if disabled
-        """
-        self._cmap.update(colors)
-
-    def format(self, record: LogRecord) -> str:
-        level: str = record.levelname.ljust(8)
-        when = self.formatTime(record, self.datefmt).ljust(23)
-        name: str = record.name.ljust(self._name_width)
-        message: str = record.getMessage()
-        if self.colored:
-            # Color level
-            if record.levelno >= CRITICAL:
-                level = Color.bright_red_bg_yellow(level)
-            elif record.levelno >= ERROR:
-                level = Color.red(level)
-            elif record.levelno >= WARNING:
-                level = Color.yellow(level)
-            elif record.levelno >= INFO:
-                level = Color.blue(level)
-            elif record.levelno < DEBUG:
-                level = Color.dim(level)
-            # Color text
-            if (col := self._cmap.get(record.name, None)) is None:
-                c: int = adler32(record.name.encode()) % 7
-                col = Color(RawColor(PureColor.black.value + c)) if c != 0 else Color.default
-            if record.levelno < DEBUG:
-                col += Color.dim
-            message = col(message)
-            name = col(name)
-            # Color timestamp
-            if record.levelno < DEBUG:
-                when = Color.dim(when)
-        # Create an updated record then format that
-        new = copy(record)
-        new.__dict__.update(
-            {
-                "cute_levelname": level,
-                "cute_time": when,
-                "cute_name": name,
-                "cute_message": message,
-                "cute_exc": ("\n" + "".join(format_exception(*new.exc_info))[:-1]) if new.exc_info else "",
-            }
-        )
-        return super().format(new)