bear-utils 0.0.1__py3-none-any.whl

bear_utils/gui/gui_tools/qt_file_handler.py

@@ -0,0 +1,130 @@
+"""A module for file handling dialogs using PyQt6."""
+
+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: str = "Select File", directory: str = "", fil: str = "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, fil)
+        return file_path
+
+    def select_files(self, caption: str = "Select Files", directory: str = "", fil: str = "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, fil)
+        return file_paths
+
+    def select_directory(self, caption: str = "Select Directory", directory: str = ""):
+        """Shows a directory selection dialog.
+
+        Returns:
+            str: Selected directory path or empty string if canceled
+        """
+        return QFileDialog.getExistingDirectory(None, caption, directory)
+
+    def save_file_dialog(self, caption: str = "Save File", directory: str = "", fil: str = "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, fil)
+        return file_path
+
+
+def select_file(caption: str = "Select File", directory: str = "", fil: str = "All Files (*)"):
+    """Select a file using the QTApplication singleton instance.
+
+    Args:
+        caption (str): The dialog window title
+        directory (str): The starting directory
+        fil (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, fil)
+
+
+def select_files(caption: str = "Select Files", directory: str = "", fil: str = "All Files (*)"):
+    """Select multiple files using the QTApplication singleton instance.
+
+    Args:
+        caption (str): The dialog window title
+        directory (str): The starting directory
+        fil (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, fil)
+
+
+def select_directory(caption: str = "Select Directory", directory: str = ""):
+    """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: str = "Save File", directory: str = "", fil: str = "All Files (*)"):
+    """Show a save file dialog using the QTApplication singleton instance.
+
+    Args:
+        caption (str): The dialog window title
+        directory (str): The starting directory
+        fil (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, fil)
+
+
+__all__ = [
+    "QTFileHandler",
+    "save_file_dialog",
+    "select_directory",
+    "select_file",
+    "select_files",
+]
+
+
+# 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,303 @@
+"""A module for input dialogs using PyQt6."""
+
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import QInputDialog, QLineEdit
+
+from .qt_app import QTApplication
+
+
+class InputDialog(QTApplication):
+    """A class for displaying various input dialogs using PyQt6."""
+
+    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/logger_manager/__init__.py

@@ -0,0 +1,109 @@
+"""Logging utilities for Bear Utils."""
+
+from typing import Any
+
+from bear_utils.logger_manager._common import VERBOSE_CONSOLE_FORMAT
+from bear_utils.logger_manager._log_level import DEBUG, ERROR, FAILURE, INFO, SUCCESS, VERBOSE, WARNING, LogLevel
+from bear_utils.logger_manager._styles import DEFAULT_THEME
+from bear_utils.logger_manager.logger_protocol import AsyncLoggerProtocol, LoggerProtocol
+from bear_utils.logger_manager.loggers._console import LogConsole
+from bear_utils.logger_manager.loggers.base_logger import BaseLogger
+from bear_utils.logger_manager.loggers.buffer_logger import BufferLogger
+from bear_utils.logger_manager.loggers.console_logger import ConsoleLogger
+from bear_utils.logger_manager.loggers.fastapi_logger import LoggingClient, LoggingServer
+from bear_utils.logger_manager.loggers.file_logger import FileLogger
+from bear_utils.logger_manager.loggers.simple_logger import SimpleLogger
+from bear_utils.logger_manager.loggers.sub_logger import SubConsoleLogger
+
+
+def get_logger(
+    console: bool = True,
+    file: bool = False,
+    queue_handler: bool = False,
+    buffering: bool = False,
+    **kwargs,
+) -> BaseLogger | ConsoleLogger | BufferError | FileLogger:
+    """Get a logger instance based on the specified parameters.
+
+    Args:
+        name (str): The name of the logger.
+        level (int): The logging level.
+        console (bool): Whether to enable console logging.
+        file (bool): Whether to enable file logging.
+        queue_handler (bool): Whether to use a queue handler.
+        buffering (bool): Whether to enable buffering.
+        style_disabled (bool): Whether to disable styling.
+        logger_mode (bool): Whether the logger is in logger mode.
+        **kwargs: Additional keyword arguments for customization.
+
+    Returns:
+        BaseLogger | ConsoleLogger | BufferLogger| FileLogger: An instance of the appropriate logger.
+    """
+    if (not console and not file) and buffering:
+        return BufferLogger(queue_handler=queue_handler, **kwargs)
+    if (console and file) or (console and buffering):
+        return ConsoleLogger(queue_handler=queue_handler, buffering=buffering, **kwargs)
+    if not console and not buffering and file:
+        return FileLogger(queue_handler=queue_handler, **kwargs)
+    return BaseLogger(**kwargs)
+
+
+def get_console(namespace: str) -> tuple[BaseLogger, SubConsoleLogger]:
+    """Get a console logger and a sub-logger for a specific namespace.
+
+    Args:
+        namespace (str): The namespace for the sub-logger.
+
+    Returns:
+        tuple[BaseLogger, SubConsoleLogger]: A tuple containing the base logger and the sub-logger.
+    """
+    base_logger = BaseLogger.get_instance(init=True)
+    sub_logger = SubConsoleLogger(logger=base_logger, namespace=namespace)
+    return base_logger, sub_logger
+
+
+def get_sub_logger(
+    logger: BaseLogger | ConsoleLogger | Any,
+    namespace: str,
+) -> SubConsoleLogger[BaseLogger | ConsoleLogger]:
+    """Get a sub-logger for a specific namespace.
+
+    Args:
+        logger (BaseLogger): The parent logger.
+        namespace (str): The namespace for the sub-logger.
+
+    Returns:
+        SubConsoleLogger: A sub-logger instance.
+    """
+    if not isinstance(logger, (BaseLogger | ConsoleLogger)):
+        raise TypeError("Expected logger to be an instance of BaseLogger or ConsoleLogger")
+
+    return SubConsoleLogger(logger=logger, namespace=namespace)
+
+
+__all__ = [
+    "DEBUG",
+    "DEFAULT_THEME",
+    "ERROR",
+    "FAILURE",
+    "INFO",
+    "SUCCESS",
+    "VERBOSE",
+    "VERBOSE_CONSOLE_FORMAT",
+    "WARNING",
+    "AsyncLoggerProtocol",
+    "BaseLogger",
+    "BufferLogger",
+    "ConsoleLogger",
+    "FileLogger",
+    "LogConsole",
+    "LogLevel",
+    "LoggerProtocol",
+    "LoggingClient",
+    "LoggingServer",
+    "SimpleLogger",
+    "SubConsoleLogger",
+    "get_console",
+    "get_logger",
+    "get_sub_logger",
+]

bear_utils/logger_manager/_common.py

@@ -0,0 +1,63 @@
+import inspect
+from types import TracebackType
+from typing import Literal, Required, TypedDict
+
+
+class ExecValues(TypedDict, total=True):
+    exc_type: Required[type[BaseException]]
+    exc_value: Required[BaseException]
+    exc_traceback: Required[TracebackType]
+
+
+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)
+
+
+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
+
+VERBOSE: Literal[5] = 5
+SUCCESS: Literal[15] = 15
+FAILURE: Literal[45] = 45
+
+
+__all__ = [
+    "FAILURE",
+    "FIVE_MEGABYTES",
+    "SIMPLE_FORMAT",
+    "SUCCESS",
+    "VERBOSE",
+    "VERBOSE_CONSOLE_FORMAT",
+    "VERBOSE_FORMAT",
+    "ExecValues",
+    "StackLevelTracker",
+]