bear-utils 0.7.21__py3-none-any.whl → 0.7.22__py3-none-any.whl

bear_utils/files/ignore_parser.py

@@ -1,10 +1,12 @@
+"""A module for handling file ignore patterns and directories in Bear Utils."""
+
 import os
 from pathlib import Path
 
 from pathspec import PathSpec
 
-from ..cli.prompt_helpers import ask_yes_no
-from ..logging import ConsoleLogger
+from bear_utils.cli.prompt_helpers import ask_yes_no
+from bear_utils.logging import ConsoleLogger
 
 logger: ConsoleLogger = ConsoleLogger.get_instance(init=True)
 
@@ -25,19 +27,21 @@ IGNORE_PATTERNS: list[str] = [
     "dist/",
 ]
 
+IGNORE_COUNT = 100
+
 
 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):
+    def __init__(self, ignore_file: Path | None = None, combine: bool = False) -> None:
+        """Initialize the IgnoreHandler with an optional ignore file."""
         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.
+        """Create a pathspec from the given patterns.
 
         Args:
             patterns: List of ignore patterns
@@ -49,8 +53,7 @@ class IgnoreHandler:
 
     @staticmethod
     def load_patterns(ignore_file: Path, combine: bool) -> list[str]:
-        """
-        Load patterns from a specific ignore file.
+        """Load patterns from a specific ignore file.
 
         Args:
             ignore_file: Path to the ignore file
@@ -61,9 +64,9 @@ class IgnoreHandler:
         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("!")
+                line.strip()
+                for line in lines
+                if line.strip() and not line.strip().startswith("#") and not line.strip().startswith("!")
             ]
             if patterns:
                 logger.verbose(f"Loaded {len(patterns)} patterns from {ignore_file}")
@@ -75,8 +78,7 @@ class IgnoreHandler:
         return []
 
     def should_ignore(self, path: Path | str) -> bool:
-        """
-        Check if a given path should be ignored based on the ignore patterns.
+        """Check if a given path should be ignored based on the ignore patterns.
 
         Args:
             path (Path): The path to check
@@ -89,8 +91,8 @@ class IgnoreHandler:
         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.
+        """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.
 
@@ -112,8 +114,7 @@ class IgnoreHandler:
         return should_ignore
 
     def add_patterns(self, patterns: list[str]) -> None:
-        """
-        Add additional ignore patterns to the existing spec.
+        """Add additional ignore patterns to the existing spec.
 
         Args:
             patterns: List of additional patterns to add
@@ -131,16 +132,16 @@ class IgnoreHandler:
 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):
+    def __init__(self, directory_to_search: Path | str, ignore_file: Path | None = None, rel: bool = True) -> None:
+        """Initialize the IgnoreDirectoryHandler with a directory to search and an optional ignore file."""
         super().__init__(ignore_file)
-        self.directory_to_search = Path(directory_to_search).resolve()
+        self.directory_to_search: Path = Path(directory_to_search).resolve()
         self.ignored_files: list[Path] = []
         self.non_ignored_files: list[Path] = []
-        self.rel = rel
+        self.rel: bool = 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.
+        """Scan a directory and separate files and directories into ignored and non-ignored lists.
 
         Args:
             directory: The directory to scan
@@ -153,7 +154,7 @@ class IgnoreDirectoryHandler(IgnoreHandler):
 
         for root, _, files in os.walk(directory):
             root_path = Path(root)
-            rel_root = root_path.relative_to(directory)
+            rel_root: Path = root_path.relative_to(directory)
 
             if str(rel_root) == ".":
                 rel_root = Path("")
@@ -162,18 +163,17 @@ class IgnoreDirectoryHandler(IgnoreHandler):
                 all_paths.append(dir_path)
 
             for file in files:
-                rel_path = rel_root / file
+                rel_path: 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]
+        ignored_status: list[bool] = [self.spec.match_file(f) for f in all_paths]
+        non_ignored_paths = [f for f, ignored in zip(all_paths, ignored_status, strict=False) if not ignored]
+        ignored_paths = [f for f, ignored in zip(all_paths, ignored_status, strict=False) if ignored]
         return non_ignored_paths, ignored_paths
 
     @property
     def ignored_files_count(self) -> int:
-        """
-        Get the count of ignored files.
+        """Get the count of ignored files.
 
         Returns:
             int: The number of ignored files
@@ -182,8 +182,7 @@ class IgnoreDirectoryHandler(IgnoreHandler):
 
     @property
     def non_ignored_files_count(self) -> int:
-        """
-        Get the count of non-ignored files.
+        """Get the count of non-ignored files.
 
         Returns:
             int: The number of non-ignored files
@@ -191,8 +190,7 @@ class IgnoreDirectoryHandler(IgnoreHandler):
         return len(self.non_ignored_files)
 
     def ignore_report_full_codebase(self):
-        """
-        Generate a report of ignored and non-ignored files in the directory.
+        """Generate a report of ignored and non-ignored files in the directory.
 
         Returns:
             Tuple of (non_ignored_files, ignored_files) as Path objects
@@ -202,9 +200,8 @@ class IgnoreDirectoryHandler(IgnoreHandler):
         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.
+    def _print(data_structure_to_print: list[Path], rel: bool = True, color: str = "green") -> None:
+        """Print the contents of a data structure (list of paths) to the console.
 
         Args:
             data_structure_to_print: The data structure to print
@@ -212,43 +209,41 @@ class IgnoreDirectoryHandler(IgnoreHandler):
         """
         try:
             for path in data_structure_to_print:
+                p = Path(path)
                 if rel:
-                    path = path.relative_to(Path.cwd())
-                logger.print(str(f"[{color}]{path}[/]"))
+                    p = p.relative_to(Path.cwd())
+                logger.print(str(f"[{color}]{p}[/]"))
         except KeyboardInterrupt:
             logger.warning("Printing interrupted by user.")
 
-    def _print_ignored_files(self):
+    def _print_ignored_files(self) -> None:
         """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:
+        elif self.ignored_files_count > IGNORE_COUNT:
+            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):
+    def _print_non_ignored_files(self) -> None:
         """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:
+        elif self.non_ignored_files_count > IGNORE_COUNT:
+            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
+        """Print the report of ignored or non-ignored files or both
 
         Args:
             what_to_print: "ignored", "non_ignored", or "both"

bear_utils/graphics/__init__.py

@@ -1,4 +1,6 @@
+"""Graphics related utilities for Bear Utils."""
+
 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"]
+__all__ = ["ColorGradient", "DefaultColors", "encode_image_to_jpeg", "encode_image_to_png"]

bear_utils/graphics/bear_gradient.py

@@ -1,3 +1,5 @@
+"""A color gradient utility for generating RGB colors based on thresholds."""
+
 from dataclasses import dataclass, field
 
 from pyglm.glm import clamp, lerp, quat
@@ -28,6 +30,7 @@ class DefaultColors:
     end: RichColor = GREEN  # Default Threshold: 1.0
 
     def output_rgb(self) -> tuple[ColorTriplet, ColorTriplet, ColorTriplet]:
+        """Get the RGB values of the default colors."""
         return self.start.get_truecolor(), self.mid.get_truecolor(), self.end.get_truecolor()
 
 
@@ -44,18 +47,20 @@ class DefaultThresholds:
             raise ValueError("thresholds must be strictly increasing and between 0 and 1.")
 
     def unpack(self) -> tuple[float, float, float]:
+        """Unpack the thresholds into a tuple."""
         return self.start, self.mid, self.end
 
 
 @dataclass
 class DefaultColorConfig:
+    """Configuration for the default color gradient."""
+
     colors: DefaultColors = field(default_factory=DefaultColors)
     thresholds: DefaultThresholds = field(default_factory=DefaultThresholds)
 
 
 class ColorGradient:
-    """
-    Simple 3-color gradient interpolator.
+    """Simple 3-color gradient interpolator.
 
     Args:
         colors (DefaultColors): Default colors for the gradient.
@@ -63,10 +68,11 @@ class ColorGradient:
         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
+    def __init__(self, config: DefaultColorConfig | None = None, reverse: bool = False) -> None:
+        """Initialize the ColorGradient with a configuration and optional reverse flag."""
+        self.config: DefaultColorConfig = config or DefaultColorConfig()
+        self.colors: DefaultColors = self.config.colors
+        self.thresholds: DefaultThresholds = self.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()
@@ -78,23 +84,22 @@ class ColorGradient:
         """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.
+    def map_to_rgb(self, _min: float, _max: float, v: float, reverse: bool | None = 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.
+            reverse (bool | None): If True, reverses the gradient direction.
 
         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.
+    def map_to_color(self, _min: float, _max: float, v: float, reverse: bool | None = None) -> ColorTriplet:
+        """Get rgb color for a value by linear interpolation.
 
         Args:
             _min (float): Minimum of input range.

bear_utils/graphics/image_helpers.py

@@ -1,18 +1,24 @@
+"""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=75) -> str:
+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 = image.convert("RGB")
+        image: PILImage = image.convert("RGB")
     image.save(buffered, format="JPEG", quality=jpeg_quality)
     return base64.b64encode(buffered.getvalue()).decode("utf-8")
 
@@ -24,16 +30,16 @@ def encode_image_to_png(image_path: Path, max_size: int = 1024) -> str:
         image.thumbnail((max_size, max_size))
     buffered = BytesIO()
     if image.format != "PNG":
-        image = image.convert("RGBA")
+        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=95) -> str:
+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 = image.convert("RGB")
+        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

@@ -1,6 +1,8 @@
+"""A module for GUI-related utilities using PyQt6. Optional Module."""
+
 try:
     from .gui_tools import QTApplication, get_text, select_color
 
-    __all__ = ["QTApplication", "select_color", "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/__init__.py

@@ -1,8 +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", "select_color", "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

@@ -9,7 +9,6 @@ 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)

bear_utils/gui/gui_tools/qt_app.py

@@ -1,19 +1,22 @@
+"""A module for managing a PyQt6 application instance and providing utility methods for dialogs and menus."""
+
 import atexit
-import sys
 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 ...logging import VERBOSE, ConsoleLogger
+from bear_utils.logging import VERBOSE, ConsoleLogger
+
 from ._types import ActionHolder
 
 
 class QTApplication(QObject):
-    """
-    Singleton class to manage the QApplication instance.
+    """Singleton class to manage the QApplication instance.
+
     This ensures that only one instance of QApplication is created.
     """
 
@@ -22,7 +25,8 @@ class QTApplication(QObject):
         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)
@@ -35,7 +39,7 @@ class QTApplication(QObject):
         self.console = ConsoleLogger.get_instance(init=True, name=app_name, level=VERBOSE)
         atexit.register(self.cleanup)
 
-    def _default_exit_shortcuts(self):
+    def _default_exit_shortcuts(self) -> None:
         """Set up default exit shortcuts for the application."""
         self._add_shortcut(QKeySequence("Escape"), self.cleanup)
 
@@ -68,7 +72,7 @@ class QTApplication(QObject):
             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):
+    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)
@@ -81,7 +85,8 @@ class QTApplication(QObject):
         self.loading_label = QLabel("Loading...")
         self.main_layout.addWidget(self.loading_label)
 
-    def get_app(self):
+    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:
@@ -95,8 +100,7 @@ class QTApplication(QObject):
         icon: QMessageBox.Icon = QMessageBox.Icon.Information,
         on_ok_action: Callable[[], None] | None = None,
     ) -> None:
-        """
-        Show a message dialog with configurable icon and action.
+        """Show a message dialog with configurable icon and action.
 
         Args:
             message: The message to display
@@ -130,7 +134,8 @@ class QTApplication(QObject):
         """Show an information dialog."""
         self.show_message(message, title=title, icon=QMessageBox.Icon.Information)
 
-    def cleanup(self):
+    def cleanup(self) -> None:
+        """Clean up the QTApplication instance."""
         if self.app:
             self.console.verbose("Cleaning up QTApplication instance.")
             self.app.quit()

bear_utils/gui/gui_tools/qt_color_picker.py

@@ -1,4 +1,7 @@
+"""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
@@ -9,6 +12,8 @@ from .qt_app import QTApplication
 
 @dataclass
 class ColorInfo:
+    """Data class to hold color information."""
+
     qcolor: QColor
     hex: str
     rgb: ColorTriplet
@@ -19,9 +24,13 @@ class ColorInfo:
 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.
+    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:
@@ -42,7 +51,7 @@ class QTColorPicker(QTApplication):
         """
         try:
             dialog = QColorDialog()
-
+            channels_num = 3
             if title:
                 dialog.setWindowTitle(title)
 
@@ -54,10 +63,10 @@ class QTColorPicker(QTApplication):
                     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))
+                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()
@@ -77,16 +86,18 @@ class QTColorPicker(QTApplication):
                     ),
                     hsv=(selected_color.hue(), selected_color.saturation(), selected_color.value()),
                 )
-            else:
-                return None
+            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.
+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: