bear-utils 0.0.1__py3-none-any.whl

bear_utils/graphics/font/block_font.py

@@ -0,0 +1,192 @@
+"""A dictionary containing ASCII art representations of letters and symbols in a block font style."""
+
+from rich.align import Align
+from rich.console import Console
+
+from bear_utils.graphics.font import FontStyle
+from bear_utils.graphics.font._raw_block_letters import (
+    ASTERISK,
+    AT,
+    BACKWARD_SLASH,
+    COMMA,
+    DASH,
+    DOLLAR,
+    DOT,
+    EIGHT,
+    EQUALS,
+    EXCLAMATION,
+    FIVE,
+    FORWARD_SLASH,
+    FOUR,
+    HASH,
+    NINE,
+    ONE,
+    PLUS,
+    QUESTION,
+    SEVEN,
+    SIX,
+    SPACE,
+    THREE,
+    TWO,
+    UNDERSCORE,
+    ZERO,
+    A,
+    B,
+    C,
+    D,
+    E,
+    F,
+    G,
+    H,
+    I,
+    J,
+    K,
+    L,
+    M,
+    N,
+    O,
+    P,
+    Q,
+    R,
+    S,
+    T,
+    U,
+    V,
+    W,
+    X,
+    Y,
+    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,
+    "B": B,
+    "C": C,
+    "D": D,
+    "E": E,
+    "F": F,
+    "G": G,
+    "H": H,
+    "I": I,
+    "J": J,
+    "K": K,
+    "L": L,
+    "M": M,
+    "N": N,
+    "O": O,
+    "P": P,
+    "Q": Q,
+    "R": R,
+    "S": S,
+    "T": T,
+    "U": U,
+    "V": V,
+    "W": W,
+    "X": X,
+    "Y": Y,
+    "Z": Z,
+    "0": ZERO,
+    "1": ONE,
+    "2": TWO,
+    "3": THREE,
+    "4": FOUR,
+    "5": FIVE,
+    "6": SIX,
+    "7": SEVEN,
+    "8": EIGHT,
+    "9": NINE,
+    " ": SPACE,
+    "!": EXCLAMATION,
+    "?": QUESTION,
+    ".": DOT,
+    ",": COMMA,
+    "-": DASH,
+    "_": UNDERSCORE,
+    "=": EQUALS,
+    "+": PLUS,
+    "*": ASTERISK,
+    "/": FORWARD_SLASH,
+    "\\": BACKWARD_SLASH,
+    "@": AT,
+    "#": HASH,
+    "$": DOLLAR,
+}
+
+console = Console()
+
+
+def apply_block_style(block_rows: list[str], style: str = "solid") -> list[str]:
+    """Replace block characters with different symbols."""
+    try:
+        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(FontStyle.keys())
+        raise ValueError(f"Invalid style: {style}. Available styles: {available}") from e
+
+
+def char_to_block(char: str) -> list[str]:
+    """Convert a single character to its block font representation."""
+    return BLOCK_LETTERS.get(char.upper(), ["        "] * 5)
+
+
+def _word_to_block(word: str) -> list[str]:
+    """Convert a word to its block font representation."""
+    clean_text: str = "".join(char for char in word.upper() if char in BLOCK_LETTERS)
+
+    if not clean_text:
+        return ["No valid characters to block-ify! 🧱"]
+
+    rows = ["", "", "", "", ""]
+    for char in clean_text:
+        block_char = char_to_block(char)
+        for i in range(5):
+            rows[i] += block_char[i]
+    return rows
+
+
+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)
+    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:
+    """Print block font text with cyberpunk styling."""
+    block_rows = _word_to_block(text)
+
+    for row in block_rows:
+        console.print(Align.center(f"[{color}]{row}[/{color}]"))
+
+
+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 FontStyle:
+        styled_word = word_to_block(word, font=symbol)
+        style = random_style()
+
+        console.print()
+        console.print(Align.center(f"[{Theme.system}]{symbol.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 = "CLAIRE"
+    show_off_styles(WORD)

bear_utils/graphics/font/glitch_font.py

@@ -0,0 +1,63 @@
+"""Ascii art glitch font generator for cyberpunk vibes!"""
+
+from io import StringIO
+import random
+
+GLITCH_CHARS: list[str] = ["█", "▓", "░", "▒", "■", "□", "▪", "▫"]
+
+
+def dice_roll(chance: float) -> bool:
+    """Roll a dice with a given chance."""
+    return random.random() < chance  # noqa: S311, we aren't doing crypto bro
+
+
+def dice_roll_choice(choices: list[str], chance: float = 0.5) -> str:
+    """Roll a dice to choose from a list of choices with a given chance."""
+    if dice_roll(chance):
+        return random.choice(choices)  # noqa: S311, we aren't doing crypto bro
+    return ""
+
+
+def glitch_font_generator(text: str, glitch_intensity: float = 0.3) -> str:
+    """Generate beautifully corrupted glitch text with MIXED characters."""
+    output = StringIO()
+
+    for char in text.upper():
+        if char == " ":
+            output.write(" ")
+            continue
+
+        output.write(char)
+        symbol: str = dice_roll_choice(GLITCH_CHARS, glitch_intensity)
+        output.write(symbol)
+        symbol2: str = dice_roll_choice(GLITCH_CHARS, glitch_intensity * 0.4)
+        output.write(symbol2)
+
+    result: str = output.getvalue()
+    output.close()
+    return result
+
+
+def multi_line_glitch(*lines: str, base_intensity: float = 0.3) -> str:
+    """Generate glitch effects for multiple lines with StringIO magic."""
+    output = StringIO()
+
+    for i, line in enumerate(lines):
+        intensity: float = base_intensity + (i * 0.1)
+        glitched_line: str = glitch_font_generator(line, intensity)
+        output.write(glitched_line)
+
+        if i < len(lines) - 1:
+            output.write("\n")
+
+    result = output.getvalue()
+    output.close()
+    return result
+
+
+def cyberpunk_glitch_font(*text: str, style: str = "heavy") -> str:
+    """Different glitch styles for maximum chaos."""
+    styles = {"light": 0.2, "medium": 0.4, "heavy": 0.6, "corrupted": 0.8}
+
+    intensity: float = styles.get(style, 0.4)
+    return multi_line_glitch(*text, base_intensity=intensity)

bear_utils/graphics/image_helpers.py

@@ -0,0 +1,45 @@
+"""A module for image processing utilities, including encoding images to JPEG and PNG formats, and converting WebP images to JPEG."""
+
+import base64
+from io import BytesIO
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from PIL import Image
+
+if TYPE_CHECKING:
+    from PIL.Image import Image as PILImage
+
+
+def encode_image_to_jpeg(image_path: Path, max_size: int = 1024, jpeg_quality: int = 75) -> str:
+    """Resize image to optimize for token usage"""
+    image = Image.open(image_path)
+    if max(image.size) > max_size:
+        image.thumbnail((max_size, max_size))
+    buffered = BytesIO()
+    if image.format != "JPEG":
+        image: PILImage = image.convert("RGB")
+    image.save(buffered, format="JPEG", quality=jpeg_quality)
+    return base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+
+def encode_image_to_png(image_path: Path, max_size: int = 1024) -> str:
+    """Resize image to optimize for token usage"""
+    image = Image.open(image_path)
+    if max(image.size) > max_size:
+        image.thumbnail((max_size, max_size))
+    buffered = BytesIO()
+    if image.format != "PNG":
+        image: PILImage = image.convert("RGBA")
+    image.save(buffered, format="PNG")
+    return base64.b64encode(buffered.getvalue()).decode("utf-8")
+
+
+def convert_webp_to_jpeg(image_path: Path, jpeg_quality: int = 95) -> str:
+    """Convert a WebP image to JPEG format."""
+    image = Image.open(image_path)
+    buffered = BytesIO()
+    if image.format != "JPEG":
+        image: PILImage = image.convert("RGB")
+    image.save(buffered, format="JPEG", quality=jpeg_quality)
+    return base64.b64encode(buffered.getvalue()).decode("utf-8")

bear_utils/gui/__init__.py

@@ -0,0 +1,8 @@
+"""A module for GUI-related utilities using PyQt6. Optional Module."""
+
+try:
+    from .gui_tools import QTApplication, get_text, select_color
+
+    __all__ = ["QTApplication", "get_text", "select_color"]
+except ImportError as e:
+    raise ImportError("PyQt6 is required for GUI functionality. Install it with: uv pip install bear-utils[gui]") from e

bear_utils/gui/gui_tools/__init__.py

@@ -0,0 +1,10 @@
+"""A module for managing a PyQt6 application instance and providing utility methods for dialogs and menus."""
+
+try:
+    from .qt_app import QTApplication
+    from .qt_color_picker import select_color
+    from .qt_input_dialog import get_text
+
+    __all__ = ["QTApplication", "get_text", "select_color"]
+except ImportError as e:
+    raise ImportError("PyQt6 is required for GUI functionality. Install it with: pip install bear-utils[gui]") from e

bear_utils/gui/gui_tools/_settings.py

@@ -0,0 +1,36 @@
+from typing import Any
+
+from PyQt6.QtCore import QSettings
+
+from .qt_app import QTApplication
+
+
+class Settings(QTApplication):
+    """Settings class that inherits from QTApplication for standalone use."""
+
+    def __init__(self, app_name: str = "Settings App", org_name: str = "YourOrg", org_domain: str = "org.domain"):
+        super().__init__(app_name, org_name, org_domain)
+
+        self._settings = QSettings(org_name, app_name)
+
+    def get(self, key: str, default: Any = None, value_type: type | None = None) -> Any:
+        """Get a setting value with optional type conversion."""
+        if value_type:
+            return self._settings.value(key, default, type=value_type)
+        return self._settings.value(key, default)
+
+    def set(self, key: str, value: Any) -> None:
+        """Set a setting value."""
+        self._settings.setValue(key, value)
+
+    def has(self, key: str) -> bool:
+        """Check if a setting exists."""
+        return self._settings.contains(key)
+
+    def remove_key(self, key: str) -> None:
+        """Remove a setting."""
+        self._settings.remove(key)
+
+    def clear_settings(self) -> None:
+        """Clear all settings."""
+        self._settings.clear()

bear_utils/gui/gui_tools/_types.py

@@ -0,0 +1,12 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+
+
+@dataclass
+class ActionHolder:
+    """A class to hold the action and its arguments."""
+
+    # text, shortcut, callback)
+    text: str
+    shortcut: str
+    callback: Callable

bear_utils/gui/gui_tools/qt_app.py

@@ -0,0 +1,150 @@
+"""A module for managing a PyQt6 application instance and providing utility methods for dialogs and menus."""
+
+import atexit
+from collections.abc import Callable
+from pathlib import Path
+import sys
+
+from PyQt6.QtCore import QCoreApplication, QObject, Qt
+from PyQt6.QtGui import QAction, QIcon, QKeySequence, QShortcut
+from PyQt6.QtWidgets import QApplication, QDialog, QLabel, QMenu, QMenuBar, QMessageBox, QVBoxLayout
+
+from bear_utils.logger_manager import VERBOSE, ConsoleLogger
+
+from ._types import ActionHolder
+
+
+class QTApplication(QObject):
+    """Singleton class to manage the QApplication instance.
+
+    This ensures that only one instance of QApplication is created.
+    """
+
+    def __init__(
+        self,
+        app_name: str = "Qt Application",
+        org_name: str = "Organization",
+        org_domain: str = "org.domain",
+    ) -> None:
+        """Initialize the QTApplication instance."""
+        super().__init__()
+        if not QApplication.instance():
+            self.app: QCoreApplication | None = QApplication(sys.argv)
+            if self.app:
+                self.app.setApplicationName(app_name)
+                self.app.setOrganizationName(org_name)
+                self.app.setOrganizationDomain(org_domain)
+        else:
+            self.app = QApplication.instance()
+        self.console: ConsoleLogger = ConsoleLogger.get_instance(init=True, name=app_name, level=VERBOSE)
+        atexit.register(self.cleanup)
+
+    def _default_exit_shortcuts(self) -> None:
+        """Set up default exit shortcuts for the application."""
+        self._add_shortcut(QKeySequence("Escape"), self.cleanup)
+
+    def _add_shortcut(self, shortcut: QKeySequence | QKeySequence.StandardKey, callback: Callable) -> None:
+        """Add a shortcut to the application."""
+        q_shortcut = QShortcut(shortcut, self.dialog)
+        q_shortcut.activated.connect(callback)
+
+    def _add_to_menu(self, menu_name: str, actions: list[ActionHolder]) -> QMenu:
+        """Add an action to the menu."""
+        menu = QMenu(menu_name, self.dialog)
+        for a in actions:
+            action: QAction = self._add_action(text=a.text, shortcut=a.shortcut, callback=a.callback)
+            menu.addAction(action)
+        return menu
+
+    def _add_action(self, text: str, shortcut: str, callback: Callable) -> QAction:
+        """Create and return an action for the menu."""
+        action = QAction(text, self.dialog)
+        action.setShortcut(shortcut)
+        action.triggered.connect(callback)
+        return action
+
+    def _start_menu_bar(self) -> None:
+        """Create and setup the menu bar."""
+        self.menu_bar = QMenuBar(self.dialog)
+
+    def _end_menu_bar(self, menus_to_add: list[QMenu]) -> None:
+        for menu in menus_to_add:
+            self.menu_bar.addMenu(menu)
+        self.main_layout.setMenuBar(self.menu_bar)
+
+    def _setup_initial_window(self, title: str, icon_path: Path, width: int, height: int) -> None:
+        """Create and show the initial window with loading indicator."""
+        self.dialog = QDialog(None)
+        self.dialog.setWindowTitle(title)
+        self.dialog.setMinimumSize(width, height)
+
+        if icon_path.exists():
+            self.dialog.setWindowIcon(QIcon(str(icon_path)))
+
+        self.main_layout = QVBoxLayout(self.dialog)
+        self.loading_label = QLabel("Loading...")
+        self.main_layout.addWidget(self.loading_label)
+
+    def get_app(self) -> QApplication | QCoreApplication | None:
+        """Get the current QApplication instance."""
+        if not self.app and not QApplication.instance():
+            self.app = QApplication(sys.argv)
+        elif not self.app:
+            self.app: QCoreApplication | None = QApplication.instance()
+        return self.app
+
+    def show_message(
+        self,
+        message: str,
+        title: str = "Message",
+        icon: QMessageBox.Icon = QMessageBox.Icon.Information,
+        on_ok_action: Callable[[], None] | None = None,
+    ) -> None:
+        """Show a message dialog with configurable icon and action.
+
+        Args:
+            message: The message to display
+            title: Dialog title
+            icon: Message box icon (Information, Warning, Critical, Question)
+            on_ok_action: Function to call when OK is clicked
+        """
+        msg_box = QMessageBox()
+        msg_box.setIcon(icon)
+        msg_box.setWindowTitle(title)
+        msg_box.setText(message)
+        msg_box.setStandardButtons(QMessageBox.StandardButton.Ok)
+        msg_box.setWindowModality(Qt.WindowModality.ApplicationModal)
+
+        result = msg_box.exec()
+
+        if result == QMessageBox.StandardButton.Ok and on_ok_action:
+            on_ok_action()
+
+    def show_warning(
+        self, message: str, on_ok_action: Callable[[], None] | None = None, title: str = "Warning"
+    ) -> None:
+        """Show a warning dialog."""
+        self.show_message(message, title=title, icon=QMessageBox.Icon.Warning, on_ok_action=on_ok_action)
+
+    def show_error(self, message: str, on_ok_action: Callable[[], None] | None = None, title: str = "Error") -> None:
+        """Show an error dialog."""
+        self.show_message(message, title=title, icon=QMessageBox.Icon.Critical, on_ok_action=on_ok_action)
+
+    def show_info(self, message: str, title: str = "Information") -> None:
+        """Show an information dialog."""
+        self.show_message(message, title=title, icon=QMessageBox.Icon.Information)
+
+    def cleanup(self) -> None:
+        """Clean up the QTApplication instance."""
+        if self.app:
+            self.console.verbose("Cleaning up QTApplication instance.")
+            self.app.quit()
+            self.app = None
+
+
+if __name__ == "__main__":
+    qt_app = QTApplication()
+    qt_app.show_info("This is an info message.")
+    qt_app.show_warning("This is a warning message.")
+    qt_app.show_error("This is an error message.")
+    qt_app.cleanup()

bear_utils/gui/gui_tools/qt_color_picker.py

@@ -0,0 +1,130 @@
+"""A module for a color picker dialog using PyQt6."""
+
+from dataclasses import dataclass
+from typing import Any
+
+from PyQt6.QtGui import QColor
+from PyQt6.QtWidgets import QColorDialog
+from rich.color_triplet import ColorTriplet
+
+from .qt_app import QTApplication
+
+
+@dataclass
+class ColorInfo:
+    """Data class to hold color information."""
+
+    qcolor: QColor
+    hex: str
+    rgb: ColorTriplet
+    rgba: tuple[int, int, int, int]
+    hsv: tuple[int, int, int]
+
+
+class QTColorPicker(QTApplication):
+    """Singleton class to manage the color picker dialog."""
+
+    def select_color(
+        self,
+        initial_color: str | None = None,
+        title: str = "Select Color",
+        options: Any | None = None,
+    ) -> ColorInfo | None:
+        """Shows a color selection dialog and returns the selected color.
+
+        Args:
+            initial_color: Initial color to show in the dialog. Can be:
+                           - QColor object
+                           - Hex string (e.g., "#FF5733")
+                           - RGB tuple (e.g., (255, 87, 51))
+            title (str): The dialog window title
+            options: QColorDialog options (optional)
+
+        Returns:
+            dict: Color information with keys:
+                  - 'qcolor': QColor object
+                  - 'hex': Hex string (e.g., "#FF5733")
+                  - 'rgb': RGB tuple (e.g., (255, 87, 51))
+                  - 'rgba': RGBA tuple (e.g., (255, 87, 51, 255))
+                  - 'hsv': HSV tuple (e.g., (16, 80, 100))
+                  Or None if dialog was canceled
+        """
+        try:
+            dialog = QColorDialog()
+            channels_num = 3
+            if title:
+                dialog.setWindowTitle(title)
+
+            if options:
+                dialog.setOptions(options)
+
+            if initial_color:
+                if isinstance(initial_color, QColor):
+                    dialog.setCurrentColor(initial_color)
+                elif isinstance(initial_color, str) and initial_color.startswith("#"):
+                    dialog.setCurrentColor(QColor(initial_color))
+                elif isinstance(initial_color, tuple) and len(initial_color) >= channels_num:
+                    r, g, b = initial_color[:channels_num]
+                    a = initial_color[channels_num] if len(initial_color) > channels_num else 255
+                    dialog.setCurrentColor(QColor(int(r), int(g), int(b), int(a)))
+
+            if dialog.exec() == QColorDialog.DialogCode.Accepted:
+                selected_color = dialog.selectedColor()
+
+                if not selected_color.isValid():
+                    return None
+
+                return ColorInfo(
+                    qcolor=selected_color,
+                    hex=selected_color.name(),
+                    rgb=ColorTriplet(selected_color.red(), selected_color.green(), selected_color.blue()),
+                    rgba=(
+                        selected_color.red(),
+                        selected_color.green(),
+                        selected_color.blue(),
+                        selected_color.alpha(),
+                    ),
+                    hsv=(selected_color.hue(), selected_color.saturation(), selected_color.value()),
+                )
+            return None
+        except Exception as e:
+            self.console.error(f"Error in color selection dialog: {e}")
+            return None
+
+
+def select_color(
+    initial_color: str | None = None,
+    title: str = "Select Color",
+    options: Any | None = None,
+) -> ColorInfo | None:
+    """Select a color using the QTColorPicker singleton instance.
+
+    Args:
+        initial_color: Initial color to show in the dialog. Can be:
+                       - QColor object
+                       - Hex string (e.g., "#FF5733")
+                       - RGB tuple (e.g., (255, 87, 51))
+        title (str): The dialog window title
+        options: QColorDialog options (optional)
+
+    Returns:
+        dict: Color information with keys:
+              - 'qcolor': QColor object
+              - 'hex': Hex string (e.g., "#FF5733")
+              - 'rgb': RGB tuple (e.g., (255, 87, 51))
+              - 'rgba': RGBA tuple (e.g., (255, 87, 51, 255))
+              - 'hsv': HSV tuple (e.g., (16, 80, 100))
+              Or None if dialog was canceled
+    """
+    qt_color_picker = QTColorPicker()
+    return qt_color_picker.select_color(initial_color, title, options)
+
+
+if __name__ == "__main__":
+    # Example usage
+    color_picker = QTColorPicker()
+    selected_color: ColorInfo | None = color_picker.select_color(initial_color="#FF5733", title="Choose a Color")
+    if selected_color:
+        color_picker.console.info(f"Selected Color: {selected_color}")
+    else:
+        color_picker.console.warning("No color selected.")