bear-utils 0.9.4__tar.gz → 0.9.6__tar.gz

{bear_utils-0.9.4 → bear_utils-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.9.4
+Version: 0.9.6
 Summary: Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things.
 Author-email: chaz <bright.lid5647@fastmail.com>
 Requires-Python: >=3.12

{bear_utils-0.9.4 → bear_utils-0.9.6}/pyproject.toml

@@ -103,5 +103,5 @@ format = "{base}"
 [tool.hatch.build.hooks.version]
 path = "src/bear_utils/_internal/_version.py"
 template = '''
-version = "{version}"
+__version__ = "{version}"
 '''

bear_utils-0.9.6/src/bear_utils/_internal/_version.py

@@ -0,0 +1 @@
+__version__ = "0.9.6"

{bear_utils-0.9.4 → bear_utils-0.9.6}/src/bear_utils/_internal/cli.py

@@ -15,9 +15,9 @@ import sys
 from typing import Any
 
 from bear_utils._internal import debug
-from bear_utils._internal._version import version as _version
+from bear_utils._internal._version import __version__
 from bear_utils.cli._get_version import VALID_BUMP_TYPES, cli_bump
-from bear_utils.constants import ExitCode
+from bear_utils.constants import STDERR, ExitCode
 
 
 class _DebugInfo(Action):
@@ -50,7 +50,7 @@ class _Version(Action):
 
 def get_version() -> ExitCode:
     """CLI command to get the version of the package."""
-    print(_version)
+    print(__version__)
     return ExitCode.SUCCESS
 
 
@@ -64,7 +64,7 @@ def bump_version(args: list[str] | None = None) -> ExitCode:
         help=f"Type of version bump: {', '.join(VALID_BUMP_TYPES)}",
     )
     _args: Namespace = parser.parse_args(args or sys.argv[1:])
-    return cli_bump([_args.bump_type, debug.__PACKAGE_NAME__, _version])
+    return cli_bump([_args.bump_type, debug.__PACKAGE_NAME__, __version__])
 
 
 def get_parser() -> ArgumentParser:
@@ -97,7 +97,7 @@ def main(args: list[str] | None = None) -> ExitCode:
     try:
         parser: ArgumentParser = get_parser()
         opts: Namespace = parser.parse_args(args)
-        command = opts.command
+        command: str | None = opts.command
         if command is None:
             parser.print_help()
             return ExitCode.SUCCESS
@@ -105,12 +105,12 @@ def main(args: list[str] | None = None) -> ExitCode:
             return get_version()
         if command == "bump-version":
             if not hasattr(opts, "bump_type"):
-                print("Error: 'bump-version' command requires a 'bump_type' argument.", file=sys.stderr)
+                print("Error: 'bump-version' command requires a 'bump_type' argument.", STDERR)
                 return ExitCode.FAILURE
-            bump_type = opts.bump_type
+            bump_type: str = opts.bump_type
             return bump_version([bump_type])
     except Exception as e:
-        print(f"Error initializing CLI: {e}", file=sys.stderr)
+        print(f"Error initializing CLI: {e}", STDERR)
         return ExitCode.FAILURE
     return ExitCode.SUCCESS
 

{bear_utils-0.9.4 → bear_utils-0.9.6}/src/bear_utils/_internal/debug.py

@@ -7,7 +7,7 @@ import os
 import platform
 import sys
 
-from bear_utils._internal._version import version as _version
+from bear_utils._internal._version import __version__
 from bear_utils.cli._get_version import Version
 
 __PACKAGE_NAME__ = "bear-utils"
@@ -19,9 +19,9 @@ class _Package:
 
     name: str = __PACKAGE_NAME__
     """Package name."""
-    version: str = _version
+    version: str = __version__
     """Package version."""
-    _version: Version = field(default_factory=lambda: Version.from_string(_version))
+    _version: Version = field(default_factory=lambda: Version.from_string(__version__))
     description: str = "No description available."
     """Package description."""
 
@@ -83,7 +83,7 @@ def _get_package_info(dist: str = __PACKAGE_NAME__) -> _Package:
     try:
         return _Package(
             name=dist,
-            version=_version or version(dist),
+            version=__version__ or version(dist),
             description=metadata(dist)["Summary"],
         )
     except PackageNotFoundError:

{bear_utils-0.9.4 → bear_utils-0.9.6}/src/bear_utils/graphics/font/__init__.py

@@ -1,9 +1,12 @@
 """A set of command-line interface (CLI) utilities for creating font outputs."""
 
+from ._theme import CyberTheme, FontStyle
 from .block_font import BLOCK_LETTERS, char_to_block, print_block_font, word_to_block
 
 __all__ = [
     "BLOCK_LETTERS",
+    "CyberTheme",
+    "FontStyle",
     "char_to_block",
     "print_block_font",
     "word_to_block",

bear_utils-0.9.6/src/bear_utils/graphics/font/_theme.py

@@ -0,0 +1,31 @@
+from bear_utils.constants._meta import RichStrEnum, StrValue as Value
+
+
+class CyberTheme(RichStrEnum):
+    """Namespace for cyberpunk color theme constants."""
+
+    primary = Value("bright_magenta", "Primary color")
+    neon_green = Value("bright_green", "Neon green color")
+    neon_cyan = Value("bright_cyan", "Neon cyan color")
+    warning = Value("bright_yellow", "Warning color")
+    error = Value("bright_red", "Error color")
+    credits = Value("bright_yellow", "Credits color")
+    data = Value("bright_blue", "Data color")
+    system = Value("dim white", "System color")
+
+
+class FontStyle(RichStrEnum):
+    """Enumeration for block font styles."""
+
+    SOLID = Value("solid", "█")
+    HOLLOW = Value("hollow", "░")
+    PIPES = Value("pipes", "|")
+    OUTLINE = Value("outline", "■")
+    DASHED = Value("dashed", "─")
+    DOTTED = Value("dotted", "·")
+    ZIGZAG = Value("zigzag", "╱")  # noqa: RUF001
+    CROSSED = Value("crossed", "╳")  # noqa: RUF001
+    FANCY = Value("fancy", "◆")
+    RIGHT_ARROWS = Value("right_arrows", "▶")
+    LEFT_ARROWS = Value("left_arrows", "◀")
+    STARS = Value("stars", "★")

{bear_utils-0.9.4 → bear_utils-0.9.6}/src/bear_utils/graphics/font/_utils.py

@@ -2,16 +2,32 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from io import StringIO
+import os
 
+from pyfiglet import figlet_format
 from rich.align import Align
 from rich.panel import Panel
 from rich.text import Text
 
-from bear_utils.graphics.font._theme import CyberTheme
-from bear_utils.graphics.font.block_font import Style
+from bear_utils.constants._meta import RichStrEnum, StrValue as Value
+from bear_utils.graphics import ColorGradient
+from bear_utils.graphics.font.block_font import FontStyle
 from bear_utils.logger_manager import LogConsole as Console
 
 
+def random_num(rng: int = 100) -> int:
+    """Generate a random number between 0 and the specified range."""
+    random_bytes: bytes = os.urandom(1)
+    random_index: int = int.from_bytes(random_bytes, "big") % rng
+    return random_index
+
+
+def random_style() -> str:
+    rnd_index: int = random_num(100)
+    gradient = ColorGradient()
+    return gradient.map_to_rgb(0, 100, rnd_index)
+
+
 @dataclass
 class HeaderConfig:
     """Configuration for header styling."""
@@ -25,9 +41,10 @@ class HeaderConfig:
     border_style: str = "bold blue"  # s2 - top/bottom lines
     separator_style: str = "bold green"  # s3 - left/right separators
     overall_style: str = "bold yellow"  # s4
+    border_enabled: bool = True
     center_align: bool = True
     return_txt: bool = False
-    use_panel: bool = False  # New option!
+    use_panel: bool = False
 
 
 class TextHelper:
@@ -83,7 +100,7 @@ class TextHelper:
             **kwargs: Override any config values (top_sep, left_sep, etc.)
         """
         local_console = Console()
-        cfg = config or HeaderConfig()
+        cfg: HeaderConfig = config or HeaderConfig()
         for key, value in kwargs.items():
             if hasattr(cfg, key):
                 setattr(cfg, key, value)
@@ -95,7 +112,7 @@ class TextHelper:
             if not cfg.return_txt:
                 local_console.print(output, style=cfg.overall_style)
 
-            temp_console = Console(file=StringIO(), width=cfg.length)
+            temp_console: Console[StringIO] = Console(file=StringIO(), width=cfg.length)
             temp_console.print(output, style=cfg.overall_style)
             return temp_console.file.getvalue()
 
@@ -105,10 +122,8 @@ class TextHelper:
             header_lines = [Align.center(line) for line in header_lines]
 
         if not cfg.return_txt:
-            local_console.print()  # Leading newline
             for line in header_lines:
                 local_console.print(line, style=cfg.overall_style)
-            local_console.print()  # Trailing newline
         output_lines: list[str] = [str(line) for line in header_lines]
         return "\n" + "\n".join(output_lines) + "\n"
 
@@ -116,10 +131,10 @@ class TextHelper:
         """Quick header with predefined styles."""
         styles = {
             "cyberpunk": HeaderConfig(
-                top_sep=str(Style.SOLID),
-                left_sep=str(Style.RIGHT_ARROWS),
-                right_sep=str(Style.LEFT_ARROWS),
-                bottom_sep=str(Style.SOLID),
+                top_sep=str(FontStyle.SOLID),
+                left_sep=str(FontStyle.RIGHT_ARROWS),
+                right_sep=str(FontStyle.LEFT_ARROWS),
+                bottom_sep=str(FontStyle.SOLID),
                 title_style="bold bright_magenta",
                 border_style="bright_cyan",
                 separator_style="bright_green",
@@ -150,36 +165,56 @@ def ascii_header(title: str, print_out: bool = True, **kwargs) -> str:
 
 
 if __name__ == "__main__":
-    top = Style.SOLID.text
-    bottom = Style.SOLID.text
-    left = Style.RIGHT_ARROWS.text
-    right = Style.LEFT_ARROWS.text
+    top: str = ""
+    bottom: str = ""
+    left: str = FontStyle.HOLLOW.text
+    right: str = FontStyle.HOLLOW.text
     ascii_header(
-        "Welcome to Bear Utils",
+        "CYBERDYNE BANKING SYSTEM",
         top_sep=top,
         bottom_sep=bottom,
         left_sep=left,
         right_sep=right,
-        title_style=CyberTheme.primary,
-        separator_style=CyberTheme.system,
-        border_style=CyberTheme.neon_cyan,
+        title_style="red",
+        separator_style="black",
+        border_style="black",
         print_out=True,
     )
 
-    from pyfiglet import figlet_format
-
-    ANSI_SHADOW = "ansi_shadow"
-    BLOODY = "bloody"
-    BANNER_3_D = "banner3-D"
-    POISON = "poison"
-    ALPHA = "alpha"
-    DOOM = "doom"
-    DOT_MATRIX = "dotmatrix"
-    JAZMINE = "jazmine"
-    RAMMSTEIN = "rammstein"
-    REVERSE = "reverse"
-    DIAGONAL_3D = "3d_diagonal"
-    GHOST = "ghost"
-
-    text = figlet_format("BANKER", font="computer")
-    print(text)
+    class FigletFonts(RichStrEnum):
+        """Namespace for Figlet font constants."""
+
+        COMPUTER = Value("computer", "Computer font")
+        SLANT = Value("slant", "Slant font")
+        STANDARD = Value("standard", "Standard font")
+        SMALL = Value("small", "Small font")
+        BIG = Value("big", "Big font")
+        BLOCK = Value("block", "Block font")
+        STAR_WARS = Value("starwars", "Star Wars font")
+        CYBER_MEDIUM = Value("cybermedium", "Cyber Medium font")
+        CYBER_LARGE = Value("cyberlarge", "Cyber Large font")
+        CYBER_SMALL = Value("cybersmall", "Cyber Small font")
+        ANSI_SHADOW = Value("ansi_shadow", "ANSI Shadow font")
+        BLOODY = Value("bloody", "Bloody font")
+        BANNER_3_D = Value("banner3-D", "Banner 3-D font")
+        POISON = Value("poison", "Poison font")
+        ALPHA = Value("alpha", "Alpha font")
+        DOOM = Value("doom", "Doom font")
+        DOT_MATRIX = Value("dotmatrix", "Dot Matrix font")
+        JAZMINE = Value("jazmine", "Jazmine font")
+        RAMMSTEIN = Value("rammstein", "Rammstein font")
+        GHOST = Value("ghost", "Ghost font")
+        DIAGONAL_3D = Value("3d_diagonal", "Diagonal 3D font")
+
+    WORD = "BRAINS"
+    text = ""
+    console = Console()
+    for font in FigletFonts:
+        try:
+            text = figlet_format(WORD, font=font.value)
+        except Exception as e:
+            console.print(f"Error generating font '{font.value}': {e}")
+            continue
+        # console.print(f"\nFont: {font.value}", style="dim white")
+        # console.print(text, style=random_style())
+        # text = ""

{bear_utils-0.9.4 → bear_utils-0.9.6}/src/bear_utils/graphics/font/block_font.py

@@ -3,7 +3,7 @@
 from rich.align import Align
 from rich.console import Console
 
-from bear_utils.constants import RichStrEnum, StrValue
+from bear_utils.graphics.font import FontStyle
 from bear_utils.graphics.font._raw_block_letters import (
     ASTERISK,
     AT,
@@ -58,6 +58,7 @@ from bear_utils.graphics.font._raw_block_letters import (
     Z,
 )
 from bear_utils.graphics.font._theme import CyberTheme as Theme
+from bear_utils.graphics.font._utils import random_style
 
 BLOCK_LETTERS: dict[str, list[str]] = {
     "A": A,
@@ -113,40 +114,19 @@ BLOCK_LETTERS: dict[str, list[str]] = {
     "$": DOLLAR,
 }
 
-
-class Style(RichStrEnum):
-    """Enumeration for block font styles."""
-
-    SOLID = StrValue("solid", "█")
-    HOLLOW = StrValue("hollow", "░")
-    PIPES = StrValue("pipes", "|")
-    OUTLINE = StrValue("outline", "■")
-    DASHED = StrValue("dashed", "─")
-    DOTTED = StrValue("dotted", "·")
-    ZIGZAG = StrValue("zigzag", "╱")  # noqa: RUF001
-    CROSSED = StrValue("crossed", "╳")  # noqa: RUF001
-    FANCY = StrValue("fancy", "◆")
-    RIGHT_ARROWS = StrValue("right_arrows", "▶")
-    LEFT_ARROWS = StrValue("left_arrows", "◀")
-    STARS = StrValue("stars", "★")
-
-
-OG_CHAR = Style.SOLID
+console = Console()
 
 
 def apply_block_style(block_rows: list[str], style: str = "solid") -> list[str]:
     """Replace block characters with different symbols."""
     try:
-        new_char: Style = Style.get(value=style, default=OG_CHAR)
-        return [row.replace(OG_CHAR.text, new_char.text) for row in block_rows]
+        new_char: FontStyle = FontStyle.get(value=style, default=FontStyle.SOLID)
+        return [row.replace(FontStyle.SOLID.text, new_char.text) for row in block_rows]
     except (KeyError, AttributeError) as e:
-        available = ", ".join(Style._value2member_map_.keys())
+        available = ", ".join(FontStyle.keys())
         raise ValueError(f"Invalid style: {style}. Available styles: {available}") from e
 
 
-console = Console()
-
-
 def char_to_block(char: str) -> list[str]:
     """Convert a single character to its block font representation."""
     return BLOCK_LETTERS.get(char.upper(), ["        "] * 5)
@@ -190,15 +170,16 @@ def print_block_font(text: str, color: str = Theme.neon_green) -> None:
         console.print(Align.center(f"[{color}]{row}[/{color}]"))
 
 
-def show_off_styles(word: str, style: str = Theme.primary) -> None:
+def show_off_styles(word: str, style: str | None = None) -> None:
     """Display all block styles by using an example word"""
     console.print("Available block styles:")
 
-    for symbol in Style:
-        styled_word = word_to_block(word, font=symbol.name.lower())
+    for symbol in FontStyle:
+        styled_word = word_to_block(word, font=symbol)
+        style = random_style()
 
         console.print()
-        console.print(Align.center(f"[{Theme.system}]{symbol.name.title()} Style:[/]"))
+        console.print(Align.center(f"[{Theme.system}]{symbol.title()} Style:[/]"))
         console.print(Align.center(f"[{style}]{styled_word}[/]"))
         console.print()
 
@@ -207,5 +188,5 @@ __all__ = ["BLOCK_LETTERS", "char_to_block", "word_to_block"]
 # fmt: on
 
 if __name__ == "__main__":
-    WORD = "CLAUDE"
+    WORD = "CLAIRE"
     show_off_styles(WORD)

{bear_utils-0.9.4 → bear_utils-0.9.6}/src/bear_utils/logger_manager/loggers/_console.py

@@ -15,6 +15,8 @@ from rich.text import Text
 from rich.theme import Theme, ThemeStack
 from rich.themes import DEFAULT
 
+from bear_utils.logger_manager._log_level import LogLevel
+
 if TYPE_CHECKING:
     from rich.color import ColorSystem
     from rich.live import Live
@@ -62,6 +64,7 @@ class LogConsole[T: TextIO](Console):
         get_datetime: Callable[[], datetime] | None = None,
         get_time: Callable[[], float] | None = None,
         _environ: Mapping[str, str] | None = None,
+        level: str | int | LogLevel = LogLevel.INFO,
     ):
         # Copy of os.environ allows us to replace it for testing
         if _environ is not None:
@@ -144,6 +147,7 @@ class LogConsole[T: TextIO](Console):
         self._render_hooks: list[RenderHook] = []
         self._live: Live | None = None
         self._is_alt_screen = False
+        self.level: LogLevel = LogLevel.get(level, default=LogLevel.INFO)
 
     @property
     def file(self) -> T:
@@ -159,37 +163,52 @@ class LogConsole[T: TextIO](Console):
         """Set a new file object."""
         self._file = new_file
 
+    def _log(self, level: LogLevel, msg: object, *args, **kwargs) -> None:
+        """Log a message at the specified level.
+
+        Args:
+            level (LogLevel): The log level for the message. We aren't using this parameter in the current implementation,
+            msg (object): The message to log.
+            *args: Additional positional arguments.
+            **kwargs: Additional keyword arguments.
+        """
+        if level.value >= self.level.value:
+            """Log a message at the specified level."""
+            with self._lock:
+                if not self.quiet:
+                    self.log(msg, *args, **kwargs)
+
     def info(self, msg: object, *args, **kwargs) -> None:
         """Log an informational message to the console."""
-        self.log(msg, *args, **kwargs)
+        self._log(LogLevel.INFO, msg, *args, **kwargs)
 
     def warning(self, msg: object, *args, **kwargs) -> None:
         """Log a warning message to the console."""
-        self.log(msg, *args, **kwargs)
+        self._log(LogLevel.WARNING, msg, *args, **kwargs)
 
     def error(self, msg: object, *args, **kwargs) -> None:
         """Log an error message to the console."""
-        self.log(msg, *args, **kwargs)
+        self._log(LogLevel.ERROR, msg, *args, **kwargs)
 
     def debug(self, msg: object, *args, **kwargs) -> None:
         """Log a debug message to the console."""
-        self.log(msg, *args, **kwargs)
+        self._log(LogLevel.DEBUG, msg, *args, **kwargs)
 
     def verbose(self, msg: object, *args, **kwargs) -> None:
         """Log a verbose message to the console."""
-        self.log(msg, *args, **kwargs)
+        self._log(LogLevel.VERBOSE, msg, *args, **kwargs)
 
     def success(self, msg: object, *args, **kwargs) -> None:
         """Log a success message to the console."""
-        self.log(msg, *args, **kwargs)
+        self._log(LogLevel.SUCCESS, msg, *args, **kwargs)
 
     def failure(self, msg: object, *args, **kwargs) -> None:
         """Log a failure message to the console."""
-        self.log(msg, *args, **kwargs)
+        self._log(LogLevel.FAILURE, msg, *args, **kwargs)
 
     def exception(self, msg: object, *args, **kwargs) -> None:
         """Log an exception message to the console."""
-        self.log(msg, *args, **kwargs)
+        self._log(LogLevel.ERROR, msg, *args, **kwargs)
 
 
 if __name__ == "__main__":

bear_utils-0.9.4/src/bear_utils/_internal/_version.py

@@ -1 +0,0 @@
-version = "0.9.4"

bear_utils-0.9.4/src/bear_utils/graphics/font/_theme.py

@@ -1,11 +0,0 @@
-class CyberTheme:
-    """Namespace for cyberpunk color theme constants."""
-
-    primary: str = "bright_magenta"
-    neon_green: str = "bright_green"
-    neon_cyan: str = "bright_cyan"
-    warning: str = "bright_yellow"
-    error: str = "bright_red"
-    credits: str = "bright_yellow"
-    data: str = "bright_blue"
-    system: str = "dim white"