bear-utils 0.9.2__py3-none-any.whl → 0.9.3__py3-none-any.whl

bear_utils/extras/_zapper.py

@@ -0,0 +1,399 @@
+from collections.abc import Callable
+import re
+from typing import Any, Literal, Self
+
+
+class Zapper[T]:
+    """A class to remove specified symbols from a source string."""
+
+    def __init__(
+        self,
+        str_input: str | tuple[str, ...],
+        src: str,
+        replace: str = "",
+        expected_unpack: int = 0,
+        sep: str = ".",
+        atomic: bool = False,
+        unpack_strict: bool = True,
+        regex: bool = False,
+        filter_start: bool = False,  # Will filter out any separators at the start of the string
+        filter_end: bool = False,  # Will filter out any separators at the end of the string
+        sorting: Literal["length", "order"] = "length",
+        func: Callable[[str], T] = str,
+    ) -> None:
+        """Initialize the Zapper with symbols, source string, and optional parameters."""
+        self.src: str = src
+        self.replace: str = replace
+        self.expected_unpack: int = expected_unpack
+        self.sep: str = sep
+        self.func: Callable[[str], T] = func
+        self.atomic: bool = atomic
+        self.unpack_strict: bool = unpack_strict
+        self.regex_enabled: bool = regex
+        self.filter_start: bool = filter_start
+        self.filter_end: bool = filter_end
+        self.sorting: Literal["length", "order"] = sorting
+        self.input: list[str] = self._process_input(str_input)
+        self.dst: str = ""
+        self.result: tuple[Any, ...] | None = None
+
+    @staticmethod
+    def _get_chars(str_input: str) -> list[str]:
+        """Get a list of characters from the input string."""
+        return [char for char in str_input if char if char != ""]
+
+    @staticmethod
+    def _get_strs(str_input: tuple[str, ...]) -> list[str]:
+        """Get a list of strings from the input tuple."""
+        return [item for item in str_input if item if item != ""]
+
+    @staticmethod
+    def _de_dupe(strings: list[str], atomic: bool, sorting: Literal["length", "order"]) -> list[str]:
+        """Remove duplicates from the input list based on the sorting method."""
+        if atomic and sorting == "length":
+            return sorted(set(strings), key=lambda x: len(x), reverse=True)
+        seen = set()
+        ordered_result = []
+        for item in strings:
+            if item not in seen:
+                seen.add(item)
+                ordered_result.append(item)
+        return ordered_result
+
+    def _process_input(self, str_input: str | tuple[str, ...]) -> list[str]:
+        """Process the input symbols based on whether they are multi-input or single."""
+        is_tuple = isinstance(str_input, tuple)
+        is_string = isinstance(str_input, str)
+        if str_input == "":
+            return []
+        strings_to_replace = []
+        if is_string and not self.atomic:
+            # If a single string is passed, treat each char as a string to replace
+            chars: list[str] = self._get_chars(str_input)
+            strings_to_replace.extend(chars)
+        elif is_string and self.atomic:
+            # If a single string is passed and self.atomic is True, treat it as a single string to replace
+            strings_to_replace.append(str_input)
+        elif is_tuple and not self.atomic:
+            # If a tuple is passed while atomic is false, treat each char as a string to replace
+            for item in str_input:
+                chars = self._get_chars(item)
+                strings_to_replace.extend(chars)
+        elif is_tuple and self.atomic:
+            # If a tuple is passed and atomic is True, treat each string as a thing to replace
+            strings: list[str] = self._get_strs(str_input)
+            strings_to_replace.extend(strings)
+        return self._de_dupe(strings_to_replace, self.atomic, self.sorting)
+
+    # region Zap Related
+
+    @staticmethod
+    def _re_sub(src: str, pattern: str, replacement: str) -> str:
+        """Perform a regex substitution on the source string."""
+        return re.sub(pattern, replacement, src)
+
+    @property
+    def value(self) -> str:
+        """Return the modified source string."""
+        return self.dst
+
+    def _zap(self) -> str:
+        """Remove specified symbols from the source string."""
+        temp_str = self.src
+        for to_replace in self.input:
+            if self.regex_enabled:
+                temp_str = self._re_sub(temp_str, to_replace, self.replace)
+            else:
+                temp_str = temp_str.replace(to_replace, self.replace)
+        if self.filter_start and temp_str.startswith(self.sep):
+            temp_str = temp_str[len(self.sep) :]
+        if self.filter_end and temp_str.endswith(self.sep):
+            temp_str = temp_str[: -len(self.sep)]
+        if self.unpack_strict:
+            temp_str = temp_str.replace(self.sep * 2, self.sep)  # Remove double separators
+        self.dst = temp_str
+        return self.dst
+
+    def zap(self) -> Self:
+        """Remove specified symbols from the source string."""
+        self.dst = self._zap()
+        return self
+
+    # endregion
+    # region Zap Get Related
+
+    def _zap_get(self) -> tuple[str, ...]:
+        """Remove specified symbols and return a tuple of unpacked values."""
+        result: list[str] = self._zap().split(self.sep)[: self.expected_unpack]
+        if self.unpack_strict and len(result) != self.expected_unpack:
+            raise ValueError(f"Expected {self.expected_unpack} items, got {len(result)}: {result}")
+        self.result = tuple(result)
+        return self.result
+
+    def zap_get(self) -> Self:
+        """Remove specified symbols and return a tuple of unpacked values."""
+        self.result = self._zap_get()
+        if self.unpack_strict and len(self.result) != self.expected_unpack:
+            raise ValueError(f"Expected {self.expected_unpack} items, got {len(self.result)}: {self.result}")
+        return self
+
+    @property
+    def unpacked(self) -> tuple[Any, ...]:
+        """Return the unpacked values as a tuple."""
+        if isinstance(self.result, tuple):
+            return self.result
+        raise ValueError("Result is not unpacked yet. Call zap_get() first.")
+
+    # endregion
+    # region Zap As Related
+
+    def _zap_as(self) -> tuple[T, ...]:
+        """Convert the result in self.result to the specified type."""
+        temp_list: list[Any] = []
+        if self.result is None:
+            raise ValueError("No result to convert. Call zap_get() first.")
+        for item in self.result:
+            temp_list.append(self.func(item))
+        self.result = tuple(temp_list)
+        return self.result
+
+    def zap_as(self) -> Self:
+        """Convert the result in self.result to the specified type."""
+        if not self.result:
+            raise ValueError("No result to convert. Call zap_get() first.")
+        self._zap_as()
+        return self
+
+    # endregion
+
+
+def zap_multi(
+    *sym: str,
+    src: str,
+    replace: str = "",
+    atomic: bool = True,
+) -> str:
+    """Remove specified symbols from the source string.
+
+    Args:
+        *sym: A variable number of strings containing symbols to remove from src (e.g., "?!" or "!?")
+        src (str): The source string from which to remove the symbols
+        replace (str, optional): The string to replace the removed symbols with (default is an empty string).
+
+    Returns:
+        str: The modified source string with specified symbols removed.
+
+    Example:
+        >>> zap_multi("!?*", "Hello!? World! *", "")
+        'Hello World '
+        >>> zap_multi("!?*", "Hello!? World! *", "-")
+        'Hello- World- -'
+    """
+    zapper = Zapper(sym, src, replace, atomic=atomic)
+    return zapper.zap().value
+
+
+def zap(sym: str, src: str, replace: str = "") -> str:
+    """Remove specified symbols from the source string.
+
+    Args:
+        sym (str): A string containing symbols to remove from src (e.g., "?!" or "!?")
+        src (str): The source string from which to remove the symbols
+        replace (str, optional): The string to replace the removed symbols with (default is an empty string).
+
+    Returns:
+        str: The modified source string with specified symbols removed.
+
+    Example:
+        >>> zap("!?*", "Hello!? World! *", "")
+        'Hello World '
+        >>> zap("!?*", "Hello!? World! *", "-")
+        'Hello- World- -'
+    """
+    zapper = Zapper(sym, src, replace, unpack_strict=False)
+    return zapper.zap().value
+
+
+def zap_get_multi(
+    *sym: str,
+    src: str,
+    unpack_val: int,
+    replace: str = "",
+    sep: str = ".",
+) -> tuple[str, ...]:
+    """Remove specified symbols from the source string and return a tuple of unpacked values.
+
+    Args:
+        *sym: A variable number of strings containing symbols to remove from src (e.g., "?!" or "!?")
+        src (str): The source string from which to remove the symbols
+        unpack_val (int): The expected number of items to unpack from the result
+        replace (str, optional): The string to replace the removed symbols with (default is an empty string).
+        sep (str, optional): The separator used to split the modified source string (default is ".").
+
+    Returns:
+        tuple[str, ...]: A tuple of unpacked values from the modified source string.
+
+    Raises:
+        ValueError: If the number of items in the result does not match unpack_val.
+    """
+    zapper = Zapper(sym, src, replace, expected_unpack=unpack_val, sep=sep, unpack_strict=True)
+    try:
+        return zapper.zap_get().unpacked
+    except Exception as e:
+        raise ValueError(f"Error unpacking values: {e}") from e
+
+
+def zap_get(sym: str, src: str, unpack_val: int, replace: str = "", sep: str = ".") -> tuple[str, ...]:
+    """Remove specified symbols from the source string and return a tuple of unpacked values.
+
+    Args:
+        sym (str): A string containing symbols to remove from src (e.g., "?!" or "!?")
+        src (str): The source string from which to remove the symbols
+        unpack_val (int): The expected number of items to unpack from the result
+        replace (str, optional): The string to replace the removed symbols with (default is an empty string).
+        sep (str, optional): The separator used to split the modified source string (default is ".").
+
+    Returns:
+        tuple[str, ...]: A tuple of unpacked values from the modified source string.
+
+    Raises:
+        ValueError: If the number of items in the result does not match unpack_val.
+    """
+    zapper = Zapper(sym, src, replace, expected_unpack=unpack_val, sep=sep, unpack_strict=True)
+    try:
+        return zapper.zap_get().unpacked
+    except Exception as e:
+        raise ValueError(f"Error unpacking values: {e}") from e
+
+
+def zap_take(sym: str, src: str, unpack_val: int, replace: str = "", sep: str = ".") -> tuple[str, ...]:
+    """Remove specified symbols from the source string and return a tuple of unpacked values.
+
+    This function is similar to zap_get but does not raise an error if the number of items does not match unpack_val.
+    Instead, it returns as many items as possible.
+
+    Args:
+        sym (str): A string containing symbols to remove from src (e.g., "?!" or "!?")
+        src (str): The source string from which to remove the symbols
+        unpack_val (int): The expected number of items to unpack from the result
+        replace (str, optional): The string to replace the removed symbols with (default is an empty string).
+        sep (str, optional): The separator used to split the modified source string (default is ".").
+
+    Returns:
+        tuple[str, ...]: A tuple of unpacked values from the modified source string.
+    """
+    zapper = Zapper(sym, src, replace, expected_unpack=unpack_val, sep=sep, unpack_strict=False)
+    return zapper.zap_get().unpacked
+
+
+def zap_as_multi[T](
+    *sym,
+    src: str,
+    unpack_val: int,
+    replace: str = "",
+    sep: str | None = None,
+    func: Callable[[str], T] = str,
+    strict: bool = True,
+    regex: bool = False,
+    atomic: bool = True,
+    filter_start: bool = False,  # Will filter out any separators at the start of the string
+    filter_end: bool = False,  # Will filter out any separators at the end of the string
+    sorting: Literal["length", "order"] = "length",  # Will sort the input symbols by length in descending order
+) -> tuple[T, ...]:
+    """Remove specified symbols from the source string, unpack the result, and convert it to a specified type.
+
+    Args:
+        *sym: A variable number of strings containing symbols to remove from src (e.g., "?!" or "!?")
+        src (str): The source string from which to remove the symbols
+        unpack_val (int): The expected number of items to unpack from the result
+        replace (str, optional): The string to replace the removed symbols with (default is an empty string).
+        sep (str, optional): The separator used to split the modified source string (default is ".").
+        func (type, optional): The type of the result to cast/convert to (default is str).
+
+    Returns:
+        Zapper: An instance of the Zapper class configured with the provided parameters.
+    """
+    if sep is None:
+        sep = replace
+
+    zapper: Zapper[T] = Zapper(
+        str_input=sym,
+        src=src,
+        replace=replace,
+        expected_unpack=unpack_val,
+        sep=sep,
+        func=func,
+        unpack_strict=strict,
+        regex=regex,
+        atomic=atomic,
+        filter_start=filter_start,
+        filter_end=filter_end,
+        sorting=sorting,
+    )
+    try:
+        return zapper.zap_get().zap_as().unpacked
+    except Exception as e:
+        raise ValueError(f"Error converting values: {e}") from e
+
+
+def zap_as[T](
+    sym: str,
+    src: str,
+    unpack_val: int,
+    replace: str = "",
+    sep: str | None = None,
+    func: Callable[[str], T] = str,
+    strict: bool = True,
+    regex: bool = False,
+    filter_start: bool = False,  # Will filter out any separators at the start of the string
+    filter_end: bool = False,  # Will filter out any separators at the end of the string
+    atomic: bool = False,  # If True, treat the input symbols as a single string to replace
+    sorting: Literal["length", "order"] = "length",  # length ordering or by the order of input
+) -> tuple[T, ...]:
+    """Remove specified symbols from the source string, unpack the result, and convert it to a specified type.
+
+    Args:
+        sym (str): A string containing symbols to remove from src (e.g., "?!" or "!?")
+        src (str): The source string from which to remove the symbols
+        unpack_val (int): The expected number of items to unpack from the result
+        replace (str, optional): The string to replace the removed symbols with (default is an empty string).
+        sep (str, optional): The separator used to split the modified source string (default is ".").
+        func (type, optional): The type of the result to cast/convert to (default is str).
+
+    Returns:
+        Zapper: An instance of the Zapper class configured with the provided parameters.
+    """
+    if sep is None:
+        sep = replace
+
+    zapper: Zapper[T] = Zapper(
+        str_input=sym,
+        src=src,
+        replace=replace,
+        expected_unpack=unpack_val,
+        sep=sep,
+        func=func,
+        unpack_strict=strict,
+        regex=regex,
+        filter_start=filter_start,
+        filter_end=filter_end,
+        atomic=atomic,
+        sorting=sorting,
+    )
+    try:
+        return zapper.zap_get().zap_as().unpacked
+    except Exception as e:
+        raise ValueError(f"Error converting values: {e}") from e
+
+
+if __name__ == "__main__":
+    # # Example usage
+    # result = zap_as_multi("()", "(", ")", src="(a)(b)(c)", unpack_val=3, replace="|", atomic=False)
+    # print(result)
+    # assert result == ("a", "b", "c")
+
+    version_string = "v1.2.3-beta+build"
+    result = zap_as_multi(
+        "v", "-", "+", src=version_string, unpack_val=3, replace=".", func=int, strict=True, filter_start=True
+    )
+    print(result)

bear_utils/graphics/font/_utils.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from io import StringIO
+import re
+from typing import Any, Self
+
+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.logger_manager import LogConsole as Console
+
+
+@dataclass
+class HeaderConfig:
+    """Configuration for header styling."""
+
+    top_sep: str = "#"
+    left_sep: str = ">"
+    right_sep: str = "<"
+    bottom_sep: str = "#"
+    length: int = 60
+    title_style: str = "bold red"  # s1
+    border_style: str = "bold blue"  # s2 - top/bottom lines
+    separator_style: str = "bold green"  # s3 - left/right separators
+    overall_style: str = "bold yellow"  # s4
+    center_align: bool = True
+    return_txt: bool = False
+    use_panel: bool = False  # New option!
+
+
+class TextHelper:
+    def _create_separator_line(self, char: str, length: int, style: str) -> Text:
+        """Create a styled separator line."""
+        return Text(char * length, style=style)
+
+    def _create_title_line_manual(self, title: str, cfg: HeaderConfig) -> Text:
+        """Create title line with manual separator padding."""
+        title_with_spaces = f" {title} "
+        title_length = len(title_with_spaces)
+        remaining_space = cfg.length - title_length
+        left_padding = remaining_space // 2
+        right_padding = remaining_space - left_padding
+        title_line = Text()
+        title_line.append(cfg.left_sep * left_padding, style=cfg.separator_style)
+        title_line.append(f" {title} ", style=cfg.title_style)
+        title_line.append(cfg.right_sep * right_padding, style=cfg.separator_style)
+        return title_line
+
+    def _create_title_line_rich(self, title: str, cfg: HeaderConfig) -> Text:
+        """Create title line using Rich's alignment."""
+        styled_title = Text(f" {title} ", style=cfg.title_style)
+        title_line = Text()
+        title_line.append(cfg.left_sep, style=cfg.separator_style)
+        title_line.append(styled_title)
+        title_line.append(cfg.right_sep, style=cfg.separator_style)
+        return Text.from_markup(str(Align.center(title_line, width=cfg.length)))
+
+    def _create_panel_header(self, title: str, cfg: HeaderConfig) -> Panel:
+        """Create header using Rich Panel."""
+        return Panel(
+            f"[{cfg.title_style}]{title}[/{cfg.title_style}]",
+            width=cfg.length,
+            border_style=cfg.border_style,
+            expand=False,
+        )
+
+    def _create_manual_header(self, title: str, cfg: HeaderConfig) -> list[Text]:
+        """Create header using manual separator lines."""
+        top_line = self._create_separator_line(cfg.top_sep, cfg.length, cfg.border_style)
+        bottom_line = self._create_separator_line(cfg.bottom_sep, cfg.length, cfg.border_style)
+        title_line = self._create_title_line_manual(title, cfg)
+
+        return [top_line, title_line, bottom_line]
+
+    def print_header(self, title: str, config: HeaderConfig | None = None, **kwargs) -> str:
+        """Generate a header string with customizable separators and styling.
+
+        Args:
+            title: The title text to display
+            config: HeaderConfig object, or None to use defaults
+            **kwargs: Override any config values (top_sep, left_sep, etc.)
+        """
+        local_console = Console()
+        cfg = config or HeaderConfig()
+        for key, value in kwargs.items():
+            if hasattr(cfg, key):
+                setattr(cfg, key, value)
+
+        if cfg.use_panel:
+            panel: Panel = self._create_panel_header(title, cfg)
+            output: Align | Panel = Align.center(panel) if cfg.center_align else panel
+
+            if not cfg.return_txt:
+                local_console.print(output, style=cfg.overall_style)
+
+            temp_console = Console(file=StringIO(), width=cfg.length)
+            temp_console.print(output, style=cfg.overall_style)
+            return temp_console.file.getvalue()
+
+        header_lines = self._create_manual_header(title, cfg)
+
+        if cfg.center_align:
+            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"
+
+    def quick_header(self, title: str, style: str = "cyberpunk") -> str:
+        """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),
+                title_style="bold bright_magenta",
+                border_style="bright_cyan",
+                separator_style="bright_green",
+                overall_style="",
+                use_panel=False,
+            ),
+            "panel": HeaderConfig(title_style="bold bright_magenta", border_style="bright_cyan", use_panel=True),
+            "classic": HeaderConfig(),  # Uses defaults
+            "minimal": HeaderConfig(top_sep="─", left_sep="", right_sep="", bottom_sep="─", separator_style="dim"),
+        }
+
+        config = styles.get(style, HeaderConfig())
+        return self.print_header(title, config)
+
+
+def ascii_header(title: str, print_out: bool = True, **kwargs) -> str:
+    """Generate a header string for visual tests.
+
+    Args:
+        title: The title to display
+        print_out: Whether to print or return the header
+        **kwargs: Any HeaderConfig parameters (top_sep, length, etc.)
+    """
+    config = HeaderConfig(return_txt=not print_out, **kwargs)
+    text_helper = TextHelper()
+    result = text_helper.print_header(title, config)
+    return "" if print_out else result
+
+
+if __name__ == "__main__":
+    top = Style.SOLID.text
+    bottom = Style.SOLID.text
+    left = Style.RIGHT_ARROWS.text
+    right = Style.LEFT_ARROWS.text
+    ascii_header(
+        "Welcome to Bear Utils",
+        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,
+        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)

bear_utils/graphics/font/block_font.py

@@ -3,6 +3,7 @@
 from rich.align import Align
 from rich.console import Console
 
+from bear_utils.constants import RichStrEnum, StrValue
 from bear_utils.graphics.font._raw_block_letters import (
     ASTERISK,
     AT,
@@ -112,6 +113,37 @@ 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
+
+
+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]
+    except (KeyError, AttributeError) as e:
+        available = ", ".join(Style._value2member_map_.keys())
+        raise ValueError(f"Invalid style: {style}. Available styles: {available}") from e
+
+
 console = Console()
 
 
@@ -135,10 +167,19 @@ def _word_to_block(word: str) -> list[str]:
     return rows
 
 
-def word_to_block(word: str) -> str:
-    """Convert a word to its block font representation as a single string."""
+def word_to_block(word: str, font: str = "solid") -> str:
+    """Convert a word to its block font representation as a single string.
+
+    Args:
+        word (str): The word to convert.
+        font (str): The style of the block font. Defaults to "solid".
+
+    Returns:
+        str: The block font representation of the word.
+    """
     block_rows = _word_to_block(word)
-    return "\n".join(block_rows)
+    styled_rows = apply_block_style(block_rows, font)
+    return "\n".join(styled_rows)
 
 
 def print_block_font(text: str, color: str = Theme.neon_green) -> None:
@@ -149,11 +190,22 @@ 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:
+    """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())
+
+        console.print()
+        console.print(Align.center(f"[{Theme.system}]{symbol.name.title()} Style:[/]"))
+        console.print(Align.center(f"[{style}]{styled_word}[/]"))
+        console.print()
+
+
 __all__ = ["BLOCK_LETTERS", "char_to_block", "word_to_block"]
 # fmt: on
 
 if __name__ == "__main__":
-    WORD = "BANKER"
-    BANKER = word_to_block(WORD)
-
-    console.print(Align.center(f"[{Theme.error}]{BANKER}[/{Theme.error}]"))
+    WORD = "CLAUDE"
+    show_off_styles(WORD)