bear-utils 0.8.24__tar.gz → 0.8.25__tar.gz

{bear_utils-0.8.24 → bear_utils-0.8.25}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.8.24
+current_version = 0.8.25
 
 [bumpversion:file:pyproject.toml]
 

{bear_utils-0.8.24 → bear_utils-0.8.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.8.24
+Version: 0.8.25
 Summary: Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things.
 Author-email: chaz <bright.lid5647@fastmail.com>
 Requires-Python: >=3.12
@@ -25,7 +25,7 @@ Provides-Extra: gui
 Requires-Dist: pyqt6>=6.9.0; extra == 'gui'
 Description-Content-Type: text/markdown
 
-# Bear Utils v# Bear Utils v0.8.24
+# Bear Utils v# Bear Utils v0.8.25
 
 Personal set of tools and utilities for Python projects, focusing on modularity and ease of use. This library includes components for caching, database management, logging, time handling, file operations, CLI prompts, image processing, clipboard interaction, gradient utilities, event systems, and async helpers.
 

{bear_utils-0.8.24 → bear_utils-0.8.25}/README.md

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.8.24
+# Bear Utils v# Bear Utils v0.8.25
 
 Personal set of tools and utilities for Python projects, focusing on modularity and ease of use. This library includes components for caching, database management, logging, time handling, file operations, CLI prompts, image processing, clipboard interaction, gradient utilities, event systems, and async helpers.
 

{bear_utils-0.8.24 → bear_utils-0.8.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.8.24"
+version = "0.8.25"
 description = "Various utilities for Bear programmers, including a rich logging utility, a disk cache, and a SQLite database wrapper amongst other things."
 authors = [{ name = "chaz", email = "bright.lid5647@fastmail.com" }]
 readme = "README.md"

{bear_utils-0.8.24 → bear_utils-0.8.25}/src/bear_utils/cli/prompt_helpers.py

@@ -107,26 +107,25 @@ def ask_yes_no(question: str, default: bool | None = None) -> bool | None:
     Returns:
         True for yes, False for no, or None if user exits
     """
-    console, sub = get_console("prompt_helpers.py")
+    console, _ = get_console("prompt_helpers.py")
 
-    try:
-        while True:
-            console.print(question)
-            response: str = prompt("> ").strip().lower()
+    while True:
+        try:
+            response: str = prompt(f"{question}\n> ").strip().lower()
             if not response:
                 if default is not None:
                     return default
-                sub.error("Please enter 'yes', 'no', or 'exit'.")
+                console.print("Please enter 'yes', 'no', or 'exit'.")
                 continue
             if _parse_exit(response):
                 return None
             try:
                 return _parse_bool(response)
             except ValueError:
-                sub.error("Invalid input. Please enter 'yes', 'no', or 'exit'.")
-    except KeyboardInterrupt:
-        sub.warning("KeyboardInterrupt: Exiting the prompt.")
-        return None
+                console.print("Invalid input. Please enter 'yes', 'no', or 'exit'.", style="red")
+        except KeyboardInterrupt:
+            console.print("KeyboardInterrupt: Exiting the prompt.", style="yellow")
+            return None
 
 
 def restricted_prompt(
@@ -165,16 +164,15 @@ def restricted_prompt(
 
     try:
         while True:
-            console.print(question)
             response: str = prompt(
-                "> ",
+                f"{question}\n> ",
                 completer=completer,
                 validator=OptionValidator(),
                 complete_while_typing=True,
             ).strip()
             comparison_response: str = response if case_sensitive else response.lower()
             if not response:
-                console.error("Please enter a valid option or 'exit'.")
+                console.print("Please enter a valid option or 'exit'.", style="red")
                 continue
             if comparison_response == comparison_exit:
                 return None
@@ -184,5 +182,5 @@ def restricted_prompt(
                     return valid_options[idx]
                 return response
     except KeyboardInterrupt:
-        console.warning("KeyboardInterrupt: Exiting the prompt.")
+        console.print("KeyboardInterrupt: Exiting the prompt.", style="yellow")
         return None

{bear_utils-0.8.24 → bear_utils-0.8.25}/src/bear_utils/cli/shell/_base_command.py

@@ -1,8 +1,5 @@
 from subprocess import CompletedProcess
-from typing import TYPE_CHECKING, Any, ClassVar, Self
-
-if TYPE_CHECKING:
-    from subprocess import CompletedProcess
+from typing import Any, ClassVar, Self
 
 
 class BaseShellCommand[T: str]:

{bear_utils-0.8.24 → bear_utils-0.8.25}/src/bear_utils/cli/typer_bridge.py

@@ -41,7 +41,7 @@ class TyperBridge(SingletonBase):
         self.console: AsyncLoggerProtocol | LoggerProtocol | Console = console or Console()
         self.command_meta: dict[str, CommandMeta] = {}
 
-    def metadata(self, *alias_names: str) -> Callable[..., Callable[..., Any]]:
+    def alias(self, *alias_names: str) -> Callable[..., Callable[..., Any]]:
         """Register aliases as hidden Typer commands."""
 
         def decorator(func: Callable[..., Any]) -> Callable[..., Any]:

{bear_utils-0.8.24 → bear_utils-0.8.25}/src/bear_utils/extras/responses/function_response.py

@@ -41,12 +41,24 @@ class FunctionResponse(BaseModel):
         "arbitrary_types_allowed": True,
     }
 
+    def _has_attr(self, key: str) -> bool:
+        """Check if the attribute exists in the attrs Namespace."""
+        return hasattr(self.attrs, key)
+
+    def _get_attr(self, key: str, default: Any = None) -> Any:
+        """Get the attribute from the attrs Namespace, returning default if not found."""
+        if self._has_attr(key):
+            return getattr(self.attrs, key, default)
+        return default
+
+    def _get_attrs(self) -> dict[str, Any]:
+        """Get all attributes from the attrs Namespace as a dictionary."""
+        return {k: getattr(self.attrs, k, None) for k in self.attrs.__dict__ if not k.startswith("_")}
+
     def __getattr__(self, key: str, default: Any = None) -> Any:
         if key in FunctionResponse.model_fields:
             raise AttributeError(f"This should never be called, {key} is a model field.")
-        if hasattr(self.attrs, key):
-            return getattr(self.attrs, key)
-        return default
+        return self._get_attr(key, default)
 
     def __setattr__(self, key: str, value: Any) -> None:
         if key in FunctionResponse.model_fields:
@@ -58,19 +70,23 @@ class FunctionResponse(BaseModel):
         """Return a string representation of Response."""
         parts: list[str] = []
 
-        def add(k: str, v: Any, _bool: bool = True, formatter: Callable | None = None) -> None:
+        def add(k: str, v: Any, _bool: bool = True, fmt_func: Callable | None = None) -> None:
             if _bool:
-                formatted_value: str = formatter(v) if formatter else repr(v)
+                formatted_value: str = fmt_func(v) if fmt_func else repr(v)
                 parts.append(f"{k}={formatted_value}")
 
         add("name", self.name, bool(self.name))
-        add("returncode", self.returncode, self.returncode != 0)
-        add("success", self.success, bool(self.returncode))
         add("content", ", ".join(self.content), bool(self.content))
-        add("error", ", ".join(self.error), bool(self.error))
-        add("extra", self.extra, bool(self.extra), json.dumps)
-        add("number_of_tasks", self.number_of_tasks, self.number_of_tasks > 0)
 
+        # error state depends on returncode or error
+        add("error", ", ".join(self.error), self.error_state)
+        add("success", self.success, _bool=True)
+        add("returncode", self.returncode, self.error_state)
+        add("number_of_tasks", self.number_of_tasks, self.error_state)
+        add("extra", self.extra, bool(self.extra), json.dumps)
+        attrs = self._get_attrs()
+        for attr in attrs:
+            add(attr, attrs[attr])
         return f"Response({', '.join(parts)})"
 
     def __str__(self) -> str:
@@ -139,28 +155,19 @@ class FunctionResponse(BaseModel):
         content: str = process.stdout.strip() if process.stdout else ""
         error: str = process.stderr.strip() if process.stderr else ""
 
-        if returncode == 0 and not content and error:
+        if returncode == 0 and not content and error:  # Some processes return empty stdout on success
             error, content = content, error
-
         return cls().add(returncode=returncode, content=content, error=error, **kwargs)
 
-    def from_response(self, response: FunctionResponse | Any, **kwargs) -> Self:
-        """Create a FunctionResponse from another FunctionResponse object."""
-        if not isinstance(response, FunctionResponse):
-            raise TypeError("Expected a FunctionResponse instance.")
-        self.sub_tasks.append(response)
-        return self.add(
-            content=response.content,
-            error=response.error,
-            returncode=response.returncode,
-            log_output=kwargs.pop("log_output", False),
-            **kwargs,
-        )
+    @property
+    def error_state(self) -> bool:
+        """Check if the returncode or error field indicates an error state."""
+        return self.returncode != 0 or bool(self.error)
 
     @property
     def success(self) -> bool:
         """Check if the response indicates success."""
-        return self.returncode == 0
+        return self.returncode == 0 and not bool(self.error)
 
     def sub_task(
         self,
@@ -185,13 +192,15 @@ class FunctionResponse(BaseModel):
 
     def successful(
         self,
-        content: str | list[str] | CompletedProcess,
+        content: str | list[str] | CompletedProcess | FunctionResponse,
         error: str | list[str] = "",
         returncode: int | None = None,
+        log_output: bool = False,
         **kwargs,
     ) -> Self:
         """Set the response to a success state with optional content."""
-        self.add(content=content, error=error, returncode=returncode or 0, **kwargs)
+        return_code: int = returncode if returncode is not None else 0
+        self.add(content=content, error=error, returncode=return_code, log_output=log_output, **kwargs)
         return self
 
     def fail(
@@ -199,16 +208,17 @@ class FunctionResponse(BaseModel):
         content: list[str] | str | CompletedProcess = "",
         error: str | list[str] = "",
         returncode: int | None = None,
+        log_output: bool = False,
         **kwargs,
     ) -> Self:
         """Set the response to a failure state with an error message."""
-        self.add(content=content, error=error, returncode=returncode or 1, **kwargs)
+        return_code: int = returncode if returncode is not None else 1
+        self.add(content=content, error=error, returncode=return_code, log_output=log_output, **kwargs)
         return self
 
     def _add_item(self, item: str, target_list: list[str]) -> None:
         """Append an item to the target list if not empty."""
-        if item != "":
-            target_list.append(item)
+        target_list.append(item) if item != "" else None
 
     def _add_to_list(self, items: str | list[str], target_list: list[str], name: str | None = None) -> None:
         """Append items to the target list with optional name prefix."""
@@ -222,24 +232,24 @@ class FunctionResponse(BaseModel):
             raise ValueError(f"Failed to add items: {e!s}") from e
 
     def _add_content(self, content: str | list[str], name: str | None = None) -> None:
-        """Append content to the existing content."""
-        self._add_to_list(content, self.content, name)
+        """Add content to the FunctionResponse content list."""
+        return self._add_to_list(items=content, target_list=self.content, name=name)
 
     def _add_error(self, error: str | list[str], name: str | None = None) -> None:
-        """Append error to the existing error."""
-        self._add_to_list(error, self.error, name)
+        """Add error messages to the FunctionResponse error list."""
+        return self._add_to_list(items=error, target_list=self.error, name=name)
 
     def _handle_function_response(self, func_response: FunctionResponse) -> None:
         """Handle a FunctionResponse object and update the current response."""
         if func_response.extra:
             self.extra.update(func_response.extra)
-        self._add_error(error=func_response.error, name=func_response.name)
-        self._add_content(content=func_response.content, name=func_response.name)
+        self._add_content(func_response.content, name=func_response.name)
+        self._add_error(func_response.error, name=func_response.name)
 
     def _handle_completed_process(self, result: CompletedProcess[str]) -> None:
         """Handle a CompletedProcess object and update the FunctionResponse."""
-        self._add_content(content=result.stdout.strip() if result.stdout else "")
-        self._add_error(error=result.stderr.strip() if result.stderr else "")
+        self._add_content(result.stdout.strip())
+        self._add_error(result.stderr.strip())
         self.returncode = result.returncode
 
     def _handle_content(self, content: list[str] | str | FunctionResponse | CompletedProcess | Any) -> None:
@@ -249,7 +259,7 @@ class FunctionResponse(BaseModel):
         elif isinstance(content, CompletedProcess):
             self._handle_completed_process(result=content)
         elif isinstance(content, (str | list)):
-            self._add_content(content=content)
+            self._add_to_list(content, self.content)
         else:
             return
         self.number_of_tasks += 1
@@ -293,7 +303,7 @@ class FunctionResponse(BaseModel):
             if content is not None:
                 self._handle_content(content=content)
             if error is not None and isinstance(error, (str | list)):
-                self._add_error(error=error)
+                self._add_to_list(error, target_list=self.error)
             if isinstance(returncode, int):
                 self.returncode = returncode
             if isinstance(extra, dict):
@@ -302,9 +312,7 @@ class FunctionResponse(BaseModel):
                 self._log_handling(content=content, error=error, logger=self.logger)
         except Exception as e:
             raise ValueError(f"Failed to add content: {e!s}") from e
-        if to_dict:
-            return self.done(to_dict=True)
-        return self
+        return self.done(to_dict=True) if to_dict else self
 
     def _log_handling(
         self,
@@ -350,17 +358,34 @@ class FunctionResponse(BaseModel):
         res.conditional_run()
 
     @overload
-    def done(self, to_dict: Literal[True], suppress: list[str] | None = None) -> dict[str, Any]: ...
+    def done(
+        self,
+        to_dict: Literal[True],
+        suppress: list[str] | None = None,
+        include: list[str] | None = None,
+    ) -> dict[str, Any]: ...
 
     @overload
-    def done(self, to_dict: Literal[False], suppress: list[str] | None = None) -> Self: ...
+    def done(
+        self,
+        to_dict: Literal[False],
+        suppress: list[str] | None = None,
+        include: list[str] | None = None,
+    ) -> Self: ...
 
-    def done(self, to_dict: bool = False, suppress: list[str] | None = None) -> dict[str, Any] | Self:
+    def done(
+        self,
+        to_dict: bool = False,
+        suppress: list[str] | None = None,
+        include: list[str] | None = None,
+    ) -> dict[str, Any] | Self:
         """Convert the FunctionResponse to a dictionary or return the instance itself.
 
         Args:
             to_dict (bool): If True, return a dictionary representation.
             If False, return the FunctionResponse instance.
+            suppress (list[str] | None): List of keys to suppress in the output dictionary.
+            include (list[str] | None): List of keys to include in the output dictionary.
 
         Returns:
             dict[str, Any] | Self: The dictionary representation or the FunctionResponse instance.
@@ -371,36 +396,60 @@ class FunctionResponse(BaseModel):
         if suppress is None:
             suppress = []
 
+        if include is None:
+            include = []
+
         result: dict[str, Any] = {}
 
         def add(k: str, v: Any, _bool: bool = True) -> None:
             if k not in suppress and _bool:
                 result[k] = v
 
+        def dict_include(_bool: bool = True) -> dict[str, Any]:
+            result.update(self.extra)
+            for k in include:
+                if hasattr(self.attrs, k) and _bool:
+                    result[k] = getattr(self.attrs, k)
+            return result
+
         add("name", self.name, bool(self.name))
-        add("success", self.success)
-        add("returncode", self.returncode, self.returncode > 0)
-        add("number_of_tasks", self.number_of_tasks, (self.number_of_tasks > 0 and not self.success))
         add("content", self.content, bool(self.content))
-        add("error", self.error, bool(self.error))
-        result.update(self.extra)
-        return result
+        add("success", self.success, _bool=True)
+        # depends on the error state
+        add("error", self.error, self.error_state)
+        add("returncode", self.returncode, self.error_state)
+        add("number_of_tasks", self.number_of_tasks, self.error_state)
+
+        return dict_include()
 
 
 def success(
     content: str | list[str] | CompletedProcess[str] | FunctionResponse,
     error: str = "",
+    log_output: bool = False,
     **kwargs,
 ) -> FunctionResponse:
     """Create a successful FunctionResponse."""
-    return FunctionResponse().add(content=content, error=error, **kwargs)
+    res = FunctionResponse()
+    return res.successful(content, error, 0, log_output, **kwargs)
 
 
 def fail(
     content: str | list[str] | CompletedProcess[str] = "",
     error: str | list[str] = "",
     returncode: int | None = None,
+    log_output: bool = False,
     **kwargs,
 ) -> FunctionResponse:
     """Create a failed FunctionResponse."""
-    return FunctionResponse().fail(content=content, error=error, returncode=returncode, **kwargs)
+    res = FunctionResponse()
+    return res.fail(content, error, returncode, log_output, **kwargs)
+
+
+if __name__ == "__main__":
+    # For testing purposes, you can run this module directly.
+
+    response = FunctionResponse(name="test_function")
+    response.add(content=["This is a test content."], error=["No errors."], returncode=1, extra={"smelly": "value"})
+    response.poop = "farts"
+    print(response.done(to_dict=True))

bear_utils-0.8.25/src/bear_utils/extras/wrappers/string_io.py

@@ -0,0 +1,46 @@
+"""A Simple wrapper around StringIO to make things easier."""
+
+from io import BytesIO, StringIO
+from typing import Any, cast
+
+
+class BaseIOWrapper[T: StringIO | BytesIO]:
+    """A Base wrapper around IO objects to make things easier."""
+
+    def __init__(self, io_obj: T | Any) -> None:
+        """Initialize the IOWrapper with a IO Object object."""
+        if not isinstance(io_obj, (StringIO | BytesIO)):
+            raise TypeError("io_obj must be an instance of StringIO or BytesIO")
+        self._value: T = cast("T", io_obj)
+        self._cached_value = None
+
+    def _reset_io(self) -> None:
+        """Reset the current a IO Object."""
+        self._value.truncate(0)
+        self._value.seek(0)
+        self._cached_value = None
+
+
+class StringIOWrapper(BaseIOWrapper[StringIO]):
+    """A Simple wrapper around StringIO to make things easier."""
+
+    def __init__(self, **kwargs) -> None:
+        """Initialize the IOWrapper with a a IO Object object."""
+        super().__init__(StringIO(**kwargs))
+        self._cached_value: str = ""
+
+    def _reset_io(self) -> None:
+        """Reset the current a IO Object."""
+        self._value.truncate(0)
+        self._value.seek(0)
+        self._cached_value = ""
+
+    def write(self, *values: str) -> None:
+        """Write values to the a IO Object object."""
+        for value in values:
+            self._value.write(value)
+
+    def getvalue(self) -> str:
+        """Get the string value from the a IO Object object."""
+        self._cached_value = self._value.getvalue()
+        return self._cached_value

{bear_utils-0.8.24 → bear_utils-0.8.25}/tests/test_function_response.py

@@ -507,16 +507,6 @@ class TestDoneMethod:
         assert "name" not in result
         assert "success" not in result
 
-    def test_done_with_suppress_failure(self):
-        """Test done() with FAILURE suppress list."""
-        response = FunctionResponse(name="test", content=["output"], returncode=1)
-        result = response.done(to_dict=True, suppress=FAILURE)
-
-        expected = {"success": False, "returncode": 1, "content": ["output"]}
-
-        assert result == expected
-        assert "name" not in result
-
     def test_done_with_custom_suppress(self):
         """Test done() with custom suppress list."""
         response = FunctionResponse(name="test", content=["output"], number_of_tasks=5)
@@ -565,7 +555,7 @@ class TestStringRepresentation:
         """Test repr with minimal data."""
         response = FunctionResponse()
         result = repr(response)
-        assert result == "Response()"
+        assert "Response(" in result
 
     def test_repr_full(self):
         """Test repr with all fields populated."""
@@ -637,7 +627,6 @@ class TestComplexScenarios:
 
         result = response.done(to_dict=True)
 
-        # SUCCESS suppresses "name" and "success", so check what actually remains
         assert "content" in result
         assert "number_of_tasks" not in result  # This will only be here in failures
         assert "name" in result

{bear_utils-0.8.24 → bear_utils-0.8.25}/tests/test_gradient.py

@@ -21,17 +21,6 @@ def test_gradients_visual():
         health_bar = "█" * (health // 5)
         console.print(f"HP: {health:3d}/100 {health_bar:<20}", style=color.rgb)
 
-    console.print("\n" + "=" * 50 + "\n")
-
-    # Reversed: Infection/Damage meter (Green = good, Red = bad)
-    console.print("[bold red]Infection Level (0% = Healthy, 100% = Critical):[/bold red]")
-    health_gradient.reverse = True
-    for infection in range(0, 101, 10):
-        color: ColorTriplet = health_gradient.map_to_color(0, 100, infection)
-        infection_bar = "█" * (infection // 5)
-        status = "🦠" if infection > 70 else "⚠️" if infection > 30 else "✅"
-        console.print(f"Infection: {infection:3d}% {infection_bar:<20} {status}", style=color.rgb)
-
     health_scenarios = [
         (5, "💀 Nearly Dead"),
         (25, "🩸 Critical Condition"),
@@ -45,3 +34,27 @@ def test_gradients_visual():
     for hp, status in health_scenarios:
         color: ColorTriplet = health_gradient.map_to_color(0, 100, hp)
         console.print(f"{status}: {hp}/100 HP", style=color.rgb)
+
+    console.print("\n" + "=" * 50 + "\n")
+
+    # Reversed: Infection/Damage meter (Green = good, Red = bad)
+    console.print("[bold red]Infection Level (0% = Healthy, 100% = Critical):[/bold red]")
+    health_gradient.reverse = True
+    for infection in range(0, 101, 10):
+        color: ColorTriplet = health_gradient.map_to_color(0, 100, infection)
+        infection_bar = "█" * (infection // 5)
+        status = "🦠" if infection > 70 else "⚠️" if infection > 30 else "✅"
+        console.print(f"Infection: {infection:3d}% {infection_bar:<20} {status}", style=color.rgb)
+
+    infected_scenarios = [
+        (5, "✅ Healthy"),
+        (25, "⚠️ Mild Infection"),
+        (50, "🦠 Moderate Infection"),
+        (75, "🦠 Severe Infection"),
+        (100, "💀 Critical Condition"),
+    ]
+
+    console.print("[bold red]Infection Status Examples:[/bold red]")
+    for ip, status in infected_scenarios:
+        color: ColorTriplet = health_gradient.map_to_color(0, 100, ip)
+        console.print(f"{status}: {ip}/100 Infection", style=color.rgb)

{bear_utils-0.8.24 → bear_utils-0.8.25}/tests/test_prompt_helpers.py

@@ -111,7 +111,7 @@ class TestAskQuestion:
 
         assert result == "hello world"
         mock_console.print.assert_called_with("Enter text: ")
-        mock_sub.verbose.assert_called_with("str detected")
+        mock_console.verbose.assert_called_with("str detected")
 
     @patch("bear_utils.cli.prompt_helpers.prompt")
     @patch("bear_utils.cli.prompt_helpers.get_console")
@@ -126,7 +126,7 @@ class TestAskQuestion:
 
         assert result == 42
         assert isinstance(result, int)
-        mock_sub.verbose.assert_called_with("int detected")
+        mock_console.verbose.assert_called_with("int detected")
 
     @patch("bear_utils.cli.prompt_helpers.prompt")
     @patch("bear_utils.cli.prompt_helpers.get_console")
@@ -140,7 +140,7 @@ class TestAskQuestion:
         result = ask_question("Continue? ", bool)
 
         assert result is True
-        mock_sub.verbose.assert_called_with("bool detected")
+        mock_console.verbose.assert_called_with("bool detected")
 
     @patch("bear_utils.cli.prompt_helpers.prompt")
     @patch("bear_utils.cli.prompt_helpers.get_console")
@@ -168,7 +168,7 @@ class TestAskQuestion:
 
         assert result == 42
         # Should have shown error for invalid input
-        mock_sub.error.assert_called_with(
+        mock_console.error.assert_called_with(
             "Invalid input: invalid literal for int() with base 10: 'not_a_number'. Please enter a valid int."
         )
 
@@ -257,7 +257,7 @@ class TestAskYesNo:
         result = ask_yes_no("Continue? ")
 
         assert result is True
-        mock_sub.error.assert_called_with("Invalid input. Please enter 'yes', 'no', or 'exit'.")
+        mock_console.print.assert_called_with("Invalid input. Please enter 'yes', 'no', or 'exit'.", style="red")
 
     @patch("bear_utils.cli.prompt_helpers.prompt")
     @patch("bear_utils.cli.prompt_helpers.get_console")
@@ -271,7 +271,7 @@ class TestAskYesNo:
         result = ask_yes_no("Continue? ")
 
         assert result is None
-        mock_sub.warning.assert_called_with("KeyboardInterrupt: Exiting the prompt.")
+        mock_console.print.assert_called_with("KeyboardInterrupt: Exiting the prompt.", style="yellow")
 
 
 class TestRestrictedPrompt:
@@ -354,7 +354,7 @@ class TestRestrictedPrompt:
         result = restricted_prompt("Choose: ", ["option1", "option2"])
 
         assert result == "option1"
-        mock_sub.error.assert_called_with("Please enter a valid option or 'exit'.")
+        mock_console.print.assert_called_with("Please enter a valid option or 'exit'.", style="red")
 
     @patch("bear_utils.cli.prompt_helpers.prompt")
     @patch("bear_utils.cli.prompt_helpers.get_console")
@@ -368,7 +368,7 @@ class TestRestrictedPrompt:
         result = restricted_prompt("Choose: ", ["option1", "option2"])
 
         assert result is None
-        mock_sub.warning.assert_called_with("KeyboardInterrupt: Exiting the prompt.")
+        mock_console.print.assert_called_with("KeyboardInterrupt: Exiting the prompt.", style="yellow")
 
 
 class TestPromptHelpersIntegration:

{bear_utils-0.8.24 → bear_utils-0.8.25}/src/bear_utils/cli/shell/_base_shell.py

@@ -13,8 +13,8 @@ import subprocess
 from subprocess import CompletedProcess
 from typing import Self, override
 
-from bear_utils.logger_manager.logger_protocol import LoggerProtocol
 from bear_utils.logger_manager import VERBOSE, BaseLogger, SubConsoleLogger
+from bear_utils.logger_manager.logger_protocol import LoggerProtocol
 
 from ._base_command import BaseShellCommand
 from ._common import DEFAULT_SHELL