bear-utils 0.7.11__py3-none-any.whl

bear_utils/files/ignore_parser.py

@@ -0,0 +1,298 @@
+import os
+from pathlib import Path
+
+from pathspec import PathSpec
+
+from ..cli.prompt_helpers import ask_yes_no
+from ..logging import ConsoleLogger
+
+logger: ConsoleLogger = ConsoleLogger.get_instance(init=True)
+
+IGNORE_PATTERNS: list[str] = [
+    "__pycache__",
+    ".git",
+    ".venv",
+    ".env",
+    ".vscode",
+    ".idea",
+    "*.DS_Store*",
+    "__pypackages__",
+    ".pytest_cache",
+    ".coverage",
+    ".*.swp",
+    ".*.swo",
+    "*.lock",
+    "dist/",
+]
+
+
+class IgnoreHandler:
+    """Basic ignore handler for manually checking if a file should be ignored based on set patterns."""
+
+    def __init__(self, ignore_file: Path | None = None, combine: bool = False):
+        self.ignore_file = ignore_file
+        self.patterns: list[str] = self.load_patterns(ignore_file, combine) if ignore_file else IGNORE_PATTERNS
+        self.spec: PathSpec = self._create_spec(self.patterns)
+
+    @staticmethod
+    def _create_spec(patterns: list[str]) -> PathSpec:
+        """
+        Create a pathspec from the given patterns.
+
+        Args:
+            patterns: List of ignore patterns
+
+        Returns:
+            A pathspec object
+        """
+        return PathSpec.from_lines("gitwildmatch", patterns)
+
+    @staticmethod
+    def load_patterns(ignore_file: Path, combine: bool) -> list[str]:
+        """
+        Load patterns from a specific ignore file.
+
+        Args:
+            ignore_file: Path to the ignore file
+        """
+        if not ignore_file.exists():
+            logger.warning(f"Ignore file {ignore_file} does not exist")
+            return []
+        try:
+            lines = ignore_file.read_text().splitlines()
+            patterns: list[str] = [
+                l.strip()
+                for l in lines
+                if l.strip() and not l.strip().startswith("#") and not l.strip().startswith("!")
+            ]
+            if patterns:
+                logger.verbose(f"Loaded {len(patterns)} patterns from {ignore_file}")
+            if combine:
+                patterns.extend(IGNORE_PATTERNS)  # Combine with default patterns
+            return patterns
+        except Exception as e:
+            logger.error(f"Error loading ignore file {ignore_file}: {e}")
+        return []
+
+    def should_ignore(self, path: Path | str) -> bool:
+        """
+        Check if a given path should be ignored based on the ignore patterns.
+
+        Args:
+            path (Path): The path to check
+        Returns:
+            bool: True if the path should be ignored, False otherwise
+        """
+        path = Path(path).expanduser()
+        if path.is_dir() and not str(path).endswith("/"):
+            return self.spec.match_file(str(path) + "/")
+        return self.spec.match_file(str(path))
+
+    def ignore_print(self, path: Path | str, rel: bool = True) -> bool:
+        """
+        Print whether a given path is ignored based on the ignore patterns.
+        Will print the path as relative to the current working directory if rel is True,
+        which it is by default.
+
+        Args:
+            path (Path): The path to check
+            rel (bool): Whether to print the path as relative to the current working directory
+
+        Returns:
+            bool: True if the path is ignored, False otherwise
+        """
+        path = Path(path).expanduser()
+        if rel:
+            path = path.relative_to(Path.cwd())
+
+        should_ignore = self.should_ignore(path)
+        msg_ignore = f"[red]{path}[/] is ignored"
+        msg_not_ignore = f"[green]{path}[/] is not ignored"
+        (logger.print(msg_ignore) if should_ignore else logger.print(msg_not_ignore))
+        return should_ignore
+
+    def add_patterns(self, patterns: list[str]) -> None:
+        """
+        Add additional ignore patterns to the existing spec.
+
+        Args:
+            patterns: List of additional patterns to add
+        """
+        new_patterns = []
+        default_patterns = IGNORE_PATTERNS.copy()
+        if self.spec:
+            for pattern in patterns:
+                if pattern not in default_patterns:
+                    new_patterns.append(pattern)
+            self.spec = PathSpec(new_patterns + default_patterns)
+        logger.verbose(f"Added {len(patterns)} ignore patterns")
+
+
+class IgnoreDirectoryHandler(IgnoreHandler):
+    """Handles the logic for ignoring files and directories based on .gitignore-style rules."""
+
+    def __init__(self, directory_to_search: Path | str, ignore_file: Path | None = None, rel: bool = True):
+        super().__init__(ignore_file)
+        self.directory_to_search = Path(directory_to_search).resolve()
+        self.ignored_files: list[Path] = []
+        self.non_ignored_files: list[Path] = []
+        self.rel = rel
+
+    def _scan_directory(self, directory: Path | str) -> tuple[list[str], list[str]]:
+        """
+        Scan a directory and separate files and directories into ignored and non-ignored lists.
+
+        Args:
+            directory: The directory to scan
+
+        Returns:
+            Tuple of (non_ignored_files, ignored_files) as relative path strings
+        """
+        directory = Path(directory)
+        all_paths = []
+
+        for root, _, files in os.walk(directory):
+            root_path = Path(root)
+            rel_root = root_path.relative_to(directory)
+
+            if str(rel_root) == ".":
+                rel_root = Path("")
+            else:
+                dir_path = str(rel_root) + "/"
+                all_paths.append(dir_path)
+
+            for file in files:
+                rel_path = rel_root / file
+                all_paths.append(str(rel_path))
+
+        ignored_status = [self.spec.match_file(f) for f in all_paths]
+        non_ignored_paths = [f for f, ignored in zip(all_paths, ignored_status) if not ignored]
+        ignored_paths = [f for f, ignored in zip(all_paths, ignored_status) if ignored]
+        return non_ignored_paths, ignored_paths
+
+    @property
+    def ignored_files_count(self) -> int:
+        """
+        Get the count of ignored files.
+
+        Returns:
+            int: The number of ignored files
+        """
+        return len(self.ignored_files)
+
+    @property
+    def non_ignored_files_count(self) -> int:
+        """
+        Get the count of non-ignored files.
+
+        Returns:
+            int: The number of non-ignored files
+        """
+        return len(self.non_ignored_files)
+
+    def ignore_report_full_codebase(self):
+        """
+        Generate a report of ignored and non-ignored files in the directory.
+
+        Returns:
+            Tuple of (non_ignored_files, ignored_files) as Path objects
+        """
+        non_ignored_paths, ignored_paths = self._scan_directory(self.directory_to_search)
+        self.non_ignored_files = [self.directory_to_search / p for p in non_ignored_paths]
+        self.ignored_files = [self.directory_to_search / p for p in ignored_paths]
+
+    @staticmethod
+    def _print(data_structure_to_print: list[Path], rel: bool = True, color: str = "green"):
+        """
+        Print the contents of a data structure (list of paths) to the console.
+
+        Args:
+            data_structure_to_print: The data structure to print
+            rel: Whether to print the paths as relative to the current working directory
+        """
+        try:
+            for path in data_structure_to_print:
+                if rel:
+                    path = path.relative_to(Path.cwd())
+                logger.print(str(f"[{color}]{path}[/]"))
+        except KeyboardInterrupt:
+            logger.warning("Printing interrupted by user.")
+
+    def _print_ignored_files(self):
+        """Print the ignored files in the directory."""
+        if self.ignored_files_count == 0:
+            logger.print("No ignored files found.")
+        else:
+            if self.ignored_files_count > 100:
+                if ask_yes_no(
+                    "There are a lot of ignored files. Do you want to print them all? (y/n)",
+                    default="n",
+                ):
+                    self._print(self.ignored_files, self.rel, "red")
+            else:
+                self._print(self.ignored_files, self.rel, "red")
+
+    def _print_non_ignored_files(self):
+        """Print the non-ignored files in the directory."""
+        if self.non_ignored_files_count == 0:
+            logger.print("No non-ignored files found.")
+        else:
+            if self.non_ignored_files_count > 100:
+                if ask_yes_no(
+                    "There are a lot of non-ignored files. Do you want to print them all? (y/n)",
+                    default="n",
+                ):
+                    self._print(self.non_ignored_files, self.rel)
+            else:
+                self._print(self.non_ignored_files, self.rel)
+
+    def print_report(self, what_to_print: str):
+        """
+        Print the report of ignored or non-ignored files or both
+
+        Args:
+            what_to_print: "ignored", "non_ignored", or "both"
+        """
+        match what_to_print:
+            case "ignored":
+                self._print_ignored_files()
+            case "non_ignored":
+                self._print_non_ignored_files()
+            case "both":
+                self._print_ignored_files()
+                self._print_non_ignored_files()
+            case _:
+                logger.error("Invalid option. Use 'ignored', 'non_ignored', or 'both'.")
+
+
+# if __name__ == "__main__":
+#     # Example usage
+#     ignore_handler = IgnoreHandler()
+#     files_to_check = [
+#         Path.cwd() / "src/bear_utils/__pycache__",
+#         Path.cwd() / "src/bear_utils/.git",
+#         Path.cwd() / "src/bear_utils/.venv",
+#         Path.cwd() / "src/bear_utils/uv.lock",
+#         Path.cwd() / "src/bear_utils/ignore_parser.py",
+#         Path.cwd() / "src/bear_utils/extras/wrappers/add_methods.py",
+#         Path.cwd() / "src/bear_utils/chronobear/_time_class.py",
+#     ]
+#     for file in files_to_check:
+#         ignore_handler.ignore_print(file)
+#     logger.set_verbose(True)
+#     directory_handler = IgnoreDirectoryHandler(".")
+#     directory_handler.ignore_print(Path.cwd() / "src/bear_utils/__pycache__")
+#     directory_handler.ignore_report_full_codebase()
+#     logger.print(f"Ignored files: {directory_handler.ignored_files_count}")
+#     logger.print(f"Non-ignored files: {directory_handler.non_ignored_files_count}")
+#     answer = ask_question(
+#         "Do you want to print the ignored or non-ignored files? (ignored/non_ignored/both)",
+#         expected_type="str",
+#         default="both",
+#     )
+#     if answer == "both":
+#         directory_handler.print_report("both")
+#     elif answer == "non_ignored":
+#         directory_handler.print_report("non_ignored")
+#     else:
+#         directory_handler.print_report("ignored")

bear_utils/graphics/__init__.py

@@ -0,0 +1,4 @@
+from .bear_gradient import ColorGradient, DefaultColors
+from .image_helpers import encode_image_to_jpeg, encode_image_to_png
+
+__all__ = ["DefaultColors", "ColorGradient", "encode_image_to_jpeg", "encode_image_to_png"]

bear_utils/graphics/bear_gradient.py

@@ -0,0 +1,140 @@
+from dataclasses import dataclass, field
+
+from pyglm.glm import clamp, lerp, quat
+from rich.color import Color as RichColor
+from rich.color_triplet import ColorTriplet
+
+RED: RichColor = RichColor.from_rgb(255, 0, 0)
+YELLOW: RichColor = RichColor.from_rgb(255, 255, 0)
+GREEN: RichColor = RichColor.from_rgb(0, 255, 0)
+
+
+def inv_lerp(a: float, b: float, t: float) -> float:
+    """Inverse linear interpolation."""
+    return clamp((t - a) / (b - a), 0.0, 1.0)
+
+
+def rgb_int(v: float | quat) -> int:
+    """Convert a float to an int, clamping to 0-255."""
+    return int(clamp(v, 0.0, 255.0))
+
+
+@dataclass
+class DefaultColors:
+    """The default colors for the gradient."""
+
+    start: RichColor = RED  # Default Threshold: 0.0
+    mid: RichColor = YELLOW  # Default Threshold: 0.7
+    end: RichColor = GREEN  # Default Threshold: 1.0
+
+    def output_rgb(self) -> tuple[ColorTriplet, ColorTriplet, ColorTriplet]:
+        return self.start.get_truecolor(), self.mid.get_truecolor(), self.end.get_truecolor()
+
+
+@dataclass
+class DefaultThresholds:
+    """The default thresholds for the gradient."""
+
+    start: float = 0.0  # Default Color: RED
+    mid: float = 0.7  # Default Color: YELLOW
+    end: float = 1.0  # Default Color: GREEN
+
+    def __post_init__(self) -> None:
+        if not (0.0 <= self.start < self.mid < self.end <= 1.0):
+            raise ValueError("thresholds must be strictly increasing and between 0 and 1.")
+
+    def unpack(self) -> tuple[float, float, float]:
+        return self.start, self.mid, self.end
+
+
+@dataclass
+class DefaultColorConfig:
+    colors: DefaultColors = field(default_factory=DefaultColors)
+    thresholds: DefaultThresholds = field(default_factory=DefaultThresholds)
+
+
+class ColorGradient:
+    """
+    Simple 3-color gradient interpolator.
+
+    Args:
+        colors (DefaultColors): Default colors for the gradient.
+        thresholds (Thresholds): Thresholds for the gradient.
+        reverse (bool): If True, reverses the gradient direction.
+    """
+
+    def __init__(self, config=DefaultColorConfig(), reverse: bool = False) -> None:
+        self.config: DefaultColorConfig = config
+        self.colors: DefaultColors = config.colors
+        self.thresholds: DefaultThresholds = config.thresholds
+        self.reverse: bool = reverse
+        self.c0, self.c1, self.c2 = self.colors.output_rgb()
+        self.p0, self.p1, self.p2 = self.thresholds.unpack()
+
+        if not (0.0 <= self.p0 < self.p1 < self.p2 <= 1.0):
+            raise ValueError("thresholds must be strictly increasing and between 0 and 1.")
+
+    def flip(self) -> None:
+        """Toggle the reverse flag."""
+        self.reverse = not self.reverse
+
+    def map_to_rgb(self, _min: float, _max: float, v: float, reverse=None) -> str:
+        """
+        Get rgb color for a value by linear interpolation.
+
+        Args:
+            _min (float): Minimum of input range.
+            _max (float): Maximum of input range.
+            v (float): Value to map.
+
+        Returns:
+            str: RGB color string.
+        """
+        return self.map_to_color(_min, _max, v, reverse).rgb
+
+    def map_to_color(self, _min: float, _max: float, v: float, reverse=None) -> ColorTriplet:
+        """
+        Get rgb color for a value by linear interpolation.
+
+        Args:
+            _min (float): Minimum of input range.
+            _max (float): Maximum of input range.
+            v (float): Value to map.
+
+        Returns:
+            ColorTriplet: RGB color triplet.
+        """
+        reverse = reverse if reverse is not None else self.reverse
+
+        t: float = inv_lerp(_min, _max, v) if not reverse else 1.0 - inv_lerp(_min, _max, v)
+        src, dst = (self.c0, self.c1) if t <= self.p1 else (self.c1, self.c2)
+        seg: float = inv_lerp(self.p0, self.p1, t) if t <= self.p1 else inv_lerp(self.p1, self.p2, t)
+
+        r = rgb_int(lerp(src.red, dst.red, seg))
+        g = rgb_int(lerp(src.green, dst.green, seg))
+        b = rgb_int(lerp(src.blue, dst.blue, seg))
+
+        return ColorTriplet(red=r, green=g, blue=b)
+
+
+# if __name__ == "__main__":
+#     # example usage
+#     from rich.console import Console
+
+#     console = Console()
+#     gradient = ColorGradient()
+
+#     console.print(f"RED: {RED.get_truecolor().rgb}")
+#     console.print(f"YELLOW: {YELLOW.get_truecolor().rgb}")
+#     console.print(f"GREEN: {GREEN.get_truecolor().rgb}")
+
+#     # RED -> YELLOW -> GREEN
+#     for i in range(0, 101, 10):
+#         color: ColorTriplet = gradient.map_to_color(0, 100, i)
+#         console.print(f"Value: {i} => Color: {color.rgb}", style=color.rgb)
+
+#     # GREEN -> YELLOW -> RED
+#     gradient.reverse = True
+#     for i in range(0, 101, 10):
+#         color: ColorTriplet = gradient.map_to_color(0, 100, i)
+#         console.print(f"Value: {i} => Color: {color.rgb}", style=color.rgb)

bear_utils/graphics/image_helpers.py

@@ -0,0 +1,39 @@
+import base64
+from io import BytesIO
+from pathlib import Path
+
+from PIL import Image
+
+
+def encode_image_to_jpeg(image_path: Path, max_size: int = 1024, jpeg_quality=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 = 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 = 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=95) -> str:
+    """Convert a WebP image to JPEG format."""
+    image = Image.open(image_path)
+    buffered = BytesIO()
+    if image.format != "JPEG":
+        image = 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,3 @@
+from .gui_tools import QTApplication, get_text, select_color
+
+__all__ = ["QTApplication", "select_color", "get_text"]

bear_utils/gui/gui_tools/__init__.py

@@ -0,0 +1,5 @@
+from .qt_app import QTApplication
+from .qt_color_picker import select_color
+from .qt_input_dialog import get_text
+
+__all__ = ["QTApplication", "select_color", "get_text"]

bear_utils/gui/gui_tools/_settings.py

@@ -0,0 +1,37 @@
+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,145 @@
+import atexit
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+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 ...logging 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",
+    ):
+        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.get_instance(init=True, name=app_name, level=VERBOSE)
+        atexit.register(self.cleanup)
+
+    def _default_exit_shortcuts(self):
+        """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):
+        """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):
+        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):
+        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()