bear-utils 0.0.1__py3-none-any.whl

bear_utils/files/file_handlers/yaml_file_handler.py

@@ -0,0 +1,64 @@
+"""YamlFileHandler class for handling YAML files."""
+
+from pathlib import Path
+from typing import Any, ClassVar
+
+import yaml
+
+from ._base_file_handler import FileHandler
+
+
+class YamlFileHandler(FileHandler):
+    """Class for handling .yaml/.yml files with read, write, and present methods"""
+
+    valid_extensions: ClassVar[list[str]] = ["yaml", "yml"]
+    valid_types: ClassVar[tuple[type, ...]] = (dict, str)
+
+    @FileHandler.ValidateFileType
+    def unsafe_read_file(self, file_path: Path, **kwargs) -> dict[str, Any]:
+        """Read YAML file with potentially unsafe loader.
+
+        WARNING: This method can execute arbitrary code and should only be used
+        with trusted files.
+
+        Args:
+            file_path: Path to the YAML file
+            **kwargs: Additional arguments passed to yaml.load
+
+        Returns:
+            Dictionary containing the parsed YAML data
+        """
+        try:
+            super().read_file(file_path=file_path)
+            with open(file=file_path, encoding="utf-8") as file:
+                return yaml.load(stream=file, **kwargs)  # noqa: S506 # Using unsafe loader intentionally
+        except Exception as e:
+            raise ValueError(f"Error reading file: {e}") from e
+
+    @FileHandler.ValidateFileType
+    def read_file(self, file_path: Path) -> dict[str, Any]:
+        """Read YAML file safely."""
+        try:
+            super().read_file(file_path=file_path)
+            with open(file=file_path, encoding="utf-8") as file:
+                return yaml.safe_load(stream=file)
+        except Exception as e:
+            raise ValueError(f"Error reading file: {e}") from e
+
+    @FileHandler.ValidateFileType
+    def write_file(self, file_path: Path, data: dict[str, Any] | str, **kwargs) -> None:
+        """Write data to a YAML file."""
+        try:
+            super().write_file(file_path=file_path, data=data)
+            self.check_data_type(data=data, valid_types=self.valid_types)
+            with open(file=file_path, mode="w", encoding="utf-8") as file:
+                yaml.dump(data, stream=file, default_flow_style=False, sort_keys=False, **kwargs)
+        except Exception as e:
+            raise ValueError(f"Error writing file: {e}") from e
+
+    def present_file(self, data: dict[str, Any] | str, **kwargs) -> str:
+        """Present data as a YAML string."""
+        try:
+            return yaml.dump(data, default_flow_style=False, sort_keys=False, **kwargs)
+        except Exception as e:
+            raise ValueError(f"Error presenting file: {e}") from e

bear_utils/files/ignore_parser.py

@@ -0,0 +1,293 @@
+"""A module for handling file ignore patterns and directories in Bear Utils."""
+
+import os
+from pathlib import Path
+
+from pathspec import PathSpec
+
+from bear_utils.cli.prompt_helpers import ask_yes_no
+from bear_utils.logger_manager 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/",
+]
+
+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) -> 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.
+
+        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] = [
+                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}")
+            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) -> None:
+        """Initialize the IgnoreDirectoryHandler with a directory to search and an optional ignore file."""
+        super().__init__(ignore_file)
+        self.directory_to_search: Path = Path(directory_to_search).resolve()
+        self.ignored_files: list[Path] = []
+        self.non_ignored_files: list[Path] = []
+        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.
+
+        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: Path = 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: Path = rel_root / file
+                all_paths.append(str(rel_path))
+
+        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.
+
+        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") -> None:
+        """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:
+                p = Path(path)
+                if rel:
+                    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) -> None:
+        """Print the ignored files in the directory."""
+        if self.ignored_files_count == 0:
+            logger.print("No ignored files found.")
+        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) -> None:
+        """Print the non-ignored files in the directory."""
+        if self.non_ignored_files_count == 0:
+            logger.print("No non-ignored files found.")
+        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
+
+        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,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__ = ["ColorGradient", "DefaultColors", "encode_image_to_jpeg", "encode_image_to_png"]

bear_utils/graphics/bear_gradient.py

@@ -0,0 +1,145 @@
+"""A color gradient utility for generating RGB colors based on thresholds."""
+
+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]:
+        """Get the RGB values of the default colors."""
+        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]:
+        """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.
+
+    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 | 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()
+
+        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: 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: bool | None = 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/font/__init__.py

@@ -0,0 +1,13 @@
+"""A set of command-line interface (CLI) utilities for creating font outputs."""
+
+from ._theme import CyberTheme, FontStyle
+from .block_font import BLOCK_LETTERS, char_to_block, print_block_font, word_to_block
+
+__all__ = [
+    "BLOCK_LETTERS",
+    "CyberTheme",
+    "FontStyle",
+    "char_to_block",
+    "print_block_font",
+    "word_to_block",
+]