bear-utils 0.7.11__py3-none-any.whl

bear_utils/gui/gui_tools/qt_color_picker.py

@@ -0,0 +1,119 @@
+from dataclasses import dataclass
+
+from PyQt6.QtGui import QColor
+from PyQt6.QtWidgets import QColorDialog
+from rich.color_triplet import ColorTriplet
+
+from .qt_app import QTApplication
+
+
+@dataclass
+class ColorInfo:
+    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=None, title="Select Color", options=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()
+
+            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) >= 3:
+                    r, g, b = initial_color[:3]
+                    a = initial_color[3] if len(initial_color) > 3 else 255
+                    dialog.setCurrentColor(QColor(r, g, b, 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()),
+                )
+            else:
+                return None
+        except Exception as e:
+            self.console.error(f"Error in color selection dialog: {e}")
+            return None
+
+
+def select_color(initial_color=None, title="Select Color", options=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.")

bear_utils/gui/gui_tools/qt_file_handler.py

@@ -0,0 +1,138 @@
+from PyQt6.QtWidgets import QFileDialog
+
+from .qt_app import QTApplication
+
+
+class QTFileHandler(QTApplication):
+    """A singleton class to handle file selection dialogs using PyQt6."""
+
+    def select_file(self, caption="Select File", directory="", filter="All Files (*)"):
+        """
+        Shows a file selection dialog and returns the selected file path.
+
+        Args:
+            caption (str): The dialog window title
+            directory (str): The starting directory
+            filter (str): File filter pattern (e.g., "Images (*.png *.jpg);;Text files (*.txt)")
+
+        Returns:
+            str: Selected file path or empty string if canceled
+        """
+        file_path, _ = QFileDialog.getOpenFileName(None, caption, directory, filter)
+        return file_path
+
+    def select_files(self, caption="Select Files", directory="", filter="All Files (*)"):
+        """
+        Shows a file selection dialog that allows multiple selections.
+
+        Returns:
+            list: List of selected file paths
+        """
+        file_paths, _ = QFileDialog.getOpenFileNames(None, caption, directory, filter)
+        return file_paths
+
+    def select_directory(self, caption="Select Directory", directory=""):
+        """
+        Shows a directory selection dialog.
+
+        Returns:
+            str: Selected directory path or empty string if canceled
+        """
+        dir_path = QFileDialog.getExistingDirectory(None, caption, directory)
+        return dir_path
+
+    def save_file_dialog(self, caption="Save File", directory="", filter="All Files (*)"):
+        """
+        Shows a save file dialog.
+
+        Returns:
+            str: Selected save file path or empty string if canceled
+        """
+
+        file_path, _ = QFileDialog.getSaveFileName(None, caption, directory, filter)
+        return file_path
+
+
+def select_file(caption="Select File", directory="", filter="All Files (*)"):
+    """
+    Select a file using the QTApplication singleton instance.
+
+    Args:
+        caption (str): The dialog window title
+        directory (str): The starting directory
+        filter (str): File filter pattern (e.g., "Images (*.png *.jpg);;Text files (*.txt)")
+
+    Returns:
+        str: Selected file path or empty string if canceled
+    """
+    qt_app = QTFileHandler()
+    return qt_app.select_file(caption, directory, filter)
+
+
+def select_files(caption="Select Files", directory="", filter="All Files (*)"):
+    """
+    Select multiple files using the QTApplication singleton instance.
+
+    Args:
+        caption (str): The dialog window title
+        directory (str): The starting directory
+        filter (str): File filter pattern (e.g., "Images (*.png *.jpg);;Text files (*.txt)")
+
+    Returns:
+        list: List of selected file paths
+    """
+    qt_app = QTFileHandler()
+    return qt_app.select_files(caption, directory, filter)
+
+
+def select_directory(caption="Select Directory", directory=""):
+    """
+    Select a directory using the QTApplication singleton instance.
+
+    Args:
+        caption (str): The dialog window title
+        directory (str): The starting directory
+
+    Returns:
+        str: Selected directory path or empty string if canceled
+    """
+    qt_app = QTFileHandler()
+    return qt_app.select_directory(caption, directory)
+
+
+def save_file_dialog(caption="Save File", directory="", filter="All Files (*)"):
+    """
+    Show a save file dialog using the QTApplication singleton instance.
+
+    Args:
+        caption (str): The dialog window title
+        directory (str): The starting directory
+        filter (str): File filter pattern (e.g., "Images (*.png *.jpg);;Text files (*.txt)")
+
+    Returns:
+        str: Selected save file path or empty string if canceled
+    """
+    qt_app = QTFileHandler()
+    return qt_app.save_file_dialog(caption, directory, filter)
+
+
+__all__ = [
+    "QTFileHandler",
+    "select_file",
+    "select_files",
+    "select_directory",
+    "save_file_dialog",
+]
+
+
+# if __name__ == "__main__":
+#     # Example usage
+#     selected_file = select_file(
+#         "Select a file", filter="Python files (*.py);;All files (*)"
+#     )
+#     print(f"Selected file: {selected_file}")
+
+#     selected_files = select_files(
+#         "Select multiple files", filter="Images (*.png *.jpg);;All files (*)"
+#     )
+#     print(f"Selected files: {selected_files}")

bear_utils/gui/gui_tools/qt_input_dialog.py

@@ -0,0 +1,306 @@
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QInputDialog, QLineEdit
+
+from .qt_app import QTApplication
+
+
+class InputDialog(QTApplication):
+    def get_text(
+        self,
+        title: str = "Input",
+        label: str = "Enter text:",
+        default: str = "",
+        echo_mode: QLineEdit.EchoMode = QLineEdit.EchoMode.Normal,
+    ) -> str | None:
+        """
+        Shows a text input dialog.
+
+        Args:
+            title: Dialog window title
+            label: Text label above the input field
+            default: Default text in the input field
+            echo_mode: How text is displayed (Normal, Password, etc.)
+            input_mode: Type of text input (TextInput, IntInput, etc.)
+
+        Returns:
+            str: Entered text or None if canceled
+        """
+        try:
+            text, ok = QInputDialog.getText(
+                None,
+                title,
+                label,
+                echo_mode,
+                default,
+                Qt.WindowType.Dialog | Qt.WindowType.WindowCloseButtonHint,
+            )
+            return text if ok else None
+        except Exception as e:
+            self.console.error(f"Error in text input dialog: {e}")
+            return None
+
+    def get_password(
+        self,
+        title: str = "Password",
+        label: str = "Enter password:",
+        default: str = "",
+    ) -> str | None:
+        """
+        Shows a password input dialog with masked text.
+
+        Args:
+            title: Dialog window title
+            label: Text label above the input field
+            default: Default text in the input field
+
+        Returns:
+            str: Entered password or None if canceled
+        """
+        return self.get_text(
+            title=title,
+            label=label,
+            default=default,
+            echo_mode=QLineEdit.EchoMode.Password,
+        )
+
+    def get_int(
+        self,
+        title: str = "Input",
+        label: str = "Enter number:",
+        default: int = 0,
+        min_value: int = -2147483647,
+        max_value: int = 2147483647,
+        step: int = 1,
+    ) -> int | None:
+        """
+        Shows an integer input dialog with spinner.
+
+        Args:
+            title: Dialog window title
+            label: Text label above the input field
+            default: Default value
+            min_value: Minimum allowed value
+            max_value: Maximum allowed value
+            step: Step size for spinner buttons
+
+        Returns:
+            int: Entered integer or None if canceled
+        """
+        try:
+            value, ok = QInputDialog.getInt(
+                None,
+                title,
+                label,
+                default,
+                min_value,
+                max_value,
+                step,
+                Qt.WindowType.Dialog | Qt.WindowType.WindowCloseButtonHint,
+            )
+            return value if ok else None
+        except Exception as e:
+            self.console.error(f"Error in integer input dialog: {e}")
+            return None
+
+    def get_double(
+        self,
+        title: str = "Input",
+        label: str = "Enter number:",
+        default: float = 0.0,
+        min_value: float = -2147483647.0,
+        max_value: float = 2147483647.0,
+        decimals: int = 2,
+    ) -> float | None:
+        """
+        Shows a floating-point input dialog with spinner.
+
+        Args:
+            title: Dialog window title
+            label: Text label above the input field
+            default: Default value
+            min_value: Minimum allowed value
+            max_value: Maximum allowed value
+            decimals: Number of decimal places to show
+
+        Returns:
+            float: Entered value or None if canceled
+        """
+        try:
+            value, ok = QInputDialog.getDouble(
+                None,
+                title,
+                label,
+                default,
+                min_value,
+                max_value,
+                decimals,
+                Qt.WindowType.Dialog | Qt.WindowType.WindowCloseButtonHint,
+            )
+            return value if ok else None
+        except Exception as e:
+            self.console.error(f"Error in double input dialog: {e}")
+            return None
+
+    def get_item(
+        self,
+        title: str = "Select",
+        label: str = "Select an item:",
+        items: list[str] | None = None,
+        current: int = 0,
+        editable: bool = False,
+    ) -> str | None:
+        """
+        Shows a dropdown selection dialog.
+
+        Args:
+            title: Dialog window title
+            label: Text label above the dropdown
+            items: List of items to choose from
+            current: Index of the initially selected item
+            editable: Whether the text can be edited
+
+        Returns:
+            str: Selected or entered text, or None if canceled
+        """
+        if items is None:
+            items = ["Item 1", "Item 2", "Item 3"]
+
+        try:
+            item, ok = QInputDialog.getItem(
+                None,
+                title,
+                label,
+                items,
+                current,
+                editable,
+                Qt.WindowType.Dialog | Qt.WindowType.WindowCloseButtonHint,
+            )
+            return item if ok else None
+        except Exception as e:
+            self.console.error(f"Error in item selection dialog: {e}")
+            return None
+
+    def get_multiline_text(self, title: str = "Input", label: str = "Enter text:", default: str = "") -> str | None:
+        """
+        Shows a multi-line text input dialog.
+
+        Args:
+            title: Dialog window title
+            label: Text label above the input field
+            default: Default text in the input field
+
+        Returns:
+            str: Entered text or None if canceled
+        """
+        try:
+            text, ok = QInputDialog.getMultiLineText(
+                None,
+                title,
+                label,
+                default,
+                Qt.WindowType.Dialog | Qt.WindowType.WindowCloseButtonHint,
+            )
+            return text if ok else None
+        except Exception as e:
+            self.console.error(f"Error in multiline text input dialog: {e}")
+            return None
+
+
+def get_text(
+    title: str = "Input",
+    label: str = "Enter text:",
+    default: str = "",
+    echo_mode: QLineEdit.EchoMode = QLineEdit.EchoMode.Normal,
+) -> str | None:
+    """Displays a text input dialog and returns the text entered by the user."""
+    qt_app = InputDialog()
+    return qt_app.get_text(title, label, default, echo_mode)
+
+
+def get_password(title: str = "Password", label: str = "Enter password:", default: str = "") -> str | None:
+    """Displays a password input dialog with masked text."""
+    qt_app = InputDialog()
+    return qt_app.get_password(title, label, default)
+
+
+def get_api_key(
+    title: str = "API Key Required",
+    label: str = "Enter API key:",
+    default: str = "",
+    service_name: str = "",
+) -> str | None:
+    """
+    Shows a secure input dialog optimized for entering API keys.
+
+    Args:
+        title: Dialog window title
+        label: Text label above the input field
+        default: Default API key (rarely used, but available)
+        service_name: Name of the service requiring the API key
+
+    Returns:
+        str: Entered API key or None if canceled
+    """
+    qt_app = InputDialog()
+
+    # Customize the label if service name is provided
+    if service_name:
+        label = f"Enter API key for {service_name}:"
+        title = f"{service_name} API Key"
+
+    return qt_app.get_text(title=title, label=label, default=default, echo_mode=QLineEdit.EchoMode.Password)
+
+
+def get_int(
+    title: str = "Input",
+    label: str = "Enter number:",
+    default: int = 0,
+    min_value: int = -2147483647,
+    max_value: int = 2147483647,
+    step: int = 1,
+) -> int | None:
+    """Displays an integer input dialog with spinner buttons."""
+    qt_app = InputDialog()
+    return qt_app.get_int(title, label, default, min_value, max_value, step)
+
+
+def get_double(
+    title: str = "Input",
+    label: str = "Enter number:",
+    default: float = 0.0,
+    min_value: float = -2147483647.0,
+    max_value: float = 2147483647.0,
+    decimals: int = 2,
+) -> float | None:
+    """Displays a floating-point input dialog with spinner buttons."""
+    qt_app = InputDialog()
+    return qt_app.get_double(title, label, default, min_value, max_value, decimals)
+
+
+def get_item(
+    title: str = "Select",
+    label: str = "Select an item:",
+    items: list[str] | None = None,
+    current: int = 0,
+    editable: bool = False,
+) -> str | None:
+    """Displays a dropdown selection dialog."""
+    qt_app = InputDialog()
+    return qt_app.get_item(title, label, items, current, editable)
+
+
+def get_multiline_text(title: str = "Input", label: str = "Enter text:", default: str = "") -> str | None:
+    """Displays a multi-line text input dialog."""
+    qt_app = InputDialog()
+    return qt_app.get_multiline_text(title, label, default)
+
+
+if __name__ == "__main__":
+    # Example usage
+    api_key = get_api_key(
+        title="API Key Required",
+        label="Enter your API key:",
+        default="",
+        service_name="MyService",
+    )
+    print(f"API Key: {api_key}")

bear_utils/logging/__init__.py

@@ -0,0 +1,25 @@
+from .logger_manager._common import VERBOSE_CONSOLE_FORMAT
+from .logger_manager._styles import VERBOSE
+from .loggers import (
+    BaseLogger,
+    BufferLogger,
+    ConsoleLogger,
+    FileLogger,
+    SubConsoleLogger,
+    get_console,
+    get_logger,
+    get_sub_logger,
+)
+
+__all__ = [
+    "BaseLogger",
+    "ConsoleLogger",
+    "BufferLogger",
+    "SubConsoleLogger",
+    "FileLogger",
+    "get_console",
+    "get_logger",
+    "get_sub_logger",
+    "VERBOSE",
+    "VERBOSE_CONSOLE_FORMAT",
+]

bear_utils/logging/logger_manager/_common.py

@@ -0,0 +1,47 @@
+import inspect
+from types import TracebackType
+from typing import Required, TypedDict
+
+
+class ExecValues(TypedDict, total=True):
+
+    exc_type: Required[type[BaseException]]
+    exc_value: Required[BaseException]
+    exc_traceback: Required[TracebackType]
+
+
+VERBOSE_FORMAT = "%(asctime)s |%(levelname)s| {%(module)s|%(funcName)s|%(lineno)d} %(message)s"
+VERBOSE_CONSOLE_FORMAT = "%(asctime)s <[{}]{}[/{}]> %(message)s"
+SIMPLE_FORMAT = "%(message)s"
+FIVE_MEGABYTES = 1024 * 1024 * 5
+
+
+class StackLevelTracker:
+    STACK_LEVEL_OFFSET = 1
+
+    def __init__(self) -> None:
+        self.start_depth: int | None = None
+        self.end_depth: int | None = None
+
+    @property
+    def not_set(self) -> bool:
+        """Check if the start depth is not set."""
+        return self.start_depth is None
+
+    def record_start(self) -> None:
+        """Record the current stack depth as the start depth."""
+        self.start_depth = len(inspect.stack())
+
+    def record_end(self) -> int:
+        """Record the current stack depth as the end depth and then return the calculated stack level.
+
+        Returns:
+            int: The calculated stack level based on the difference between start and end depths.
+        """
+        self.end_depth = len(inspect.stack())
+        return self.calculate_stacklevel()
+
+    def calculate_stacklevel(self) -> int:
+        if self.start_depth is None or self.end_depth is None:
+            raise ValueError("Start and end depths must be recorded before calculating stack level.")
+        return self.end_depth - (self.start_depth + self.STACK_LEVEL_OFFSET)