bear-utils 0.8.6__tar.gz → 0.8.7__tar.gz

{bear_utils-0.8.6 → bear_utils-0.8.7}/.bumpversion.cfg

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

{bear_utils-0.8.6 → bear_utils-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.8.6
+Version: 0.8.7
 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
@@ -20,7 +20,7 @@ Requires-Dist: tinydb>=4.8.2
 Requires-Dist: toml>=0.10.2
 Description-Content-Type: text/markdown
 
-# Bear Utils v# Bear Utils v0.8.6
+# Bear Utils v# Bear Utils v0.8.7
 
 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.6 → bear_utils-0.8.7}/README.md

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.8.6
+# Bear Utils v# Bear Utils v0.8.7
 
 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.6 → bear_utils-0.8.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.8.6"
+version = "0.8.7"
 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.7/src/bear_utils/cli/prompt_helpers.py

@@ -0,0 +1,185 @@
+"""Prompt Helpers Module for user input handling."""
+
+from typing import Any, overload
+
+from prompt_toolkit import prompt
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.validation import ValidationError, Validator
+
+from bear_utils.constants._exceptions import UserCancelledError
+from bear_utils.constants._lazy_typing import OptBool, OptFloat, OptInt, OptStr
+from bear_utils.logger_manager import get_console
+
+# TODO: ehhhhhhhh, it is okay
+
+
+def _parse_bool(value: str) -> bool:
+    """Parse a string into a boolean value."""
+    lower_value: str = value.lower().strip()
+    if lower_value in ("true", "t", "yes", "y", "1"):
+        return True
+    if lower_value in ("false", "f", "no", "n", "0"):
+        return False
+    raise ValueError(f"Cannot convert '{value}' to boolean")
+
+
+def _convert_value(value: str, target_type: type) -> str | int | float | bool:
+    """Convert a string value to the target type."""
+    if target_type is str:
+        return value
+    if target_type is int:
+        return int(value)
+    if target_type is float:
+        return float(value)
+    if target_type is bool:
+        return _parse_bool(value)
+    raise ValueError(f"Unsupported type: {target_type}")
+
+
+@overload
+def ask_question(question: str, expected_type: type[bool], default: OptBool = None) -> bool: ...
+
+
+@overload
+def ask_question(question: str, expected_type: type[int], default: OptInt = None) -> int: ...
+
+
+@overload
+def ask_question(question: str, expected_type: type[float], default: OptFloat = None) -> float: ...
+
+
+@overload
+def ask_question(question: str, expected_type: type[str], default: OptStr = None) -> str: ...
+
+
+def ask_question(question: str, expected_type: type, default: Any = None) -> Any:
+    """Ask a question and return the answer, ensuring the entered type is correct.
+
+    This function will keep asking until it gets a valid response or the user cancels with Ctrl+C.
+    If the user cancels, a UserCancelledError is raised.
+
+    Args:
+        question: The prompt question to display
+        expected_type: The expected type class (int, float, str, bool)
+        default: Default value if no input is provided
+
+    Returns:
+        The user's response in the expected type
+
+    Raises:
+        UserCancelledError: If the user cancels input with Ctrl+C
+        ValueError: If an unsupported type is specified
+    """
+    console, sub = get_console("prompt_helpers.py")
+
+    try:
+        while True:
+            console.print(question)
+            response = prompt("> ").strip()
+
+            if not response:
+                if default is not None:
+                    return default
+                sub.error("Input required. Please enter a value.")
+                continue
+            try:
+                result: str | int | float | bool = _convert_value(response, expected_type)
+                sub.verbose(f"{expected_type.__name__} detected")
+                return result
+            except ValueError as e:
+                sub.error(f"Invalid input: {e}. Please enter a valid {expected_type.__name__}.")
+
+    except KeyboardInterrupt:
+        raise UserCancelledError("User cancelled input") from None
+
+
+def ask_yes_no(question: str, default: bool | None = None) -> bool | None:
+    """Ask a yes or no question and return the answer.
+
+    Args:
+        question: The prompt question to display
+        default: Default value if no input is provided
+
+    Returns:
+        True for yes, False for no, or None if user exits
+    """
+    console, sub = get_console("prompt_helpers.py")
+
+    try:
+        while True:
+            console.print(question)
+            response = prompt("> ").strip().lower()
+
+            if not response:
+                if default is not None:
+                    return default
+                sub.error("Please enter 'yes', 'no', or 'exit'.")
+                continue
+
+            if response in ("exit", "quit"):
+                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
+
+
+def restricted_prompt(
+    question: str, valid_options: list[str], exit_command: str = "exit", case_sensitive: bool = False
+) -> str | None:
+    """Continuously prompt the user until they provide a valid response or exit.
+
+    Args:
+        question: The prompt question to display
+        valid_options: List of valid responses
+        exit_command: Command to exit the prompt (default: "exit")
+        case_sensitive: Whether options are case-sensitive (default: False)
+
+    Returns:
+        The user's response or None if they chose to exit
+    """
+    console, sub = get_console("prompt_helpers.py")
+    completer_options = [*valid_options, exit_command]
+    completer = WordCompleter(completer_options)
+
+    comparison_options = valid_options if case_sensitive else [opt.lower() for opt in valid_options]
+    comparison_exit = exit_command if case_sensitive else exit_command.lower()
+
+    class OptionValidator(Validator):
+        def validate(self, document: Any) -> None:
+            """Validate the user's input against the valid options."""
+            text: Any = document.text if case_sensitive else document.text.lower()
+            if text and text != comparison_exit and text not in comparison_options:
+                raise ValidationError(
+                    message=f"Invalid option. Choose from: {', '.join(valid_options)} or '{exit_command}'",
+                    cursor_position=len(document.text),
+                )
+
+    try:
+        while True:
+            console.print(question)
+            response: str = prompt(
+                "> ", completer=completer, validator=OptionValidator(), complete_while_typing=True
+            ).strip()
+            comparison_response: str = response if case_sensitive else response.lower()
+            if not response:
+                sub.error("Please enter a valid option or 'exit'.")
+                continue
+            if comparison_response == comparison_exit:
+                return None
+            if comparison_response in comparison_options:
+                if not case_sensitive:
+                    idx: int = comparison_options.index(comparison_response)
+                    return valid_options[idx]
+                return response
+
+    except KeyboardInterrupt:
+        sub.warning("KeyboardInterrupt: Exiting the prompt.")
+        return None
+
+
+if __name__ == "__main__":
+    ask_question("What is your age?", int)

{bear_utils-0.8.6 → bear_utils-0.8.7}/src/bear_utils/extras/responses/function_response.py

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
-from io import StringIO
+from collections.abc import Callable
 import json
 from subprocess import CompletedProcess
+from types import SimpleNamespace as Namespace
 from typing import Any, Literal, Self, overload
 
 from pydantic import BaseModel, Field, field_validator
@@ -23,35 +24,46 @@ class FunctionResponse(BaseModel):
     extra: dict = Field(default_factory=dict, description="Additional metadata or information related to the response.")
     content: list[str] = Field(default=[], description="Content returned by the function call")
     error: list[str] = Field(default=[], description="Error message if the function call failed")
+    sub_tasks: list[FunctionResponse] = Field(default_factory=list, description="List of sub-tasks.")
     number_of_tasks: int = Field(default=0, description="Number of tasks processed in this response.")
     logger: LoggerProtocol | None = Field(default=None, description="Logger instance for logging messages.")
+    attrs: Namespace = Field(default_factory=Namespace, description="Storing additional attributes dynamically.")
 
     model_config = {
         "arbitrary_types_allowed": True,
     }
 
+    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
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        if key in FunctionResponse.model_fields:
+            object.__setattr__(self, key, value)
+            return
+        setattr(self.attrs, key, value)
+
     def __repr__(self) -> str:
         """Return a string representation of Response."""
-        result = StringIO()
-        result.write("Response(")
-        if self.name:
-            result.write(f"name={self.name!r}, ")
-        if self.returncode:
-            result.write(f"success={self.success!r}, ")
-        if self.content:
-            content: str = ", ".join(self.content)
-            result.write(f"content={content!r}, ")
-        if self.error:
-            error: str = ", ".join(self.error)
-            result.write(f"error={error!r}, ")
-        if self.extra:
-            result.write(f"extra={json.dumps(self.extra)!r}, ")
-        if self.number_of_tasks > 0:
-            result.write(f"number_of_tasks={self.number_of_tasks!r}, ")
-        result.write(")")
-        returned_result: str = result.getvalue().replace(", )", ")")
-        result.close()
-        return returned_result
+        parts: list[str] = []
+
+        def add(k: str, v: Any, _bool: bool = True, formatter: Callable | None = None) -> None:
+            if _bool:
+                formatted_value: str = formatter(v) if formatter 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)
+
+        return f"Response({', '.join(parts)})"
 
     def __str__(self) -> str:
         """Return a string representation of Response."""
@@ -124,6 +136,19 @@ class FunctionResponse(BaseModel):
 
         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 success(self) -> bool:
         """Check if the response indicates success."""
@@ -137,7 +162,7 @@ class FunctionResponse(BaseModel):
         extra: dict[str, Any] | None = None,
         returncode: int | None = None,
         log_output: bool = False,
-    ) -> None:
+    ) -> Self:
         """Add a sub-task response to the FunctionResponse."""
         func_response: FunctionResponse = FunctionResponse(name=name, logger=self.logger).add(
             content=content,
@@ -147,6 +172,8 @@ class FunctionResponse(BaseModel):
             extra=extra,
         )
         self.add(content=func_response)
+        self.sub_tasks.append(func_response)
+        return self
 
     def successful(
         self,
@@ -170,49 +197,41 @@ class FunctionResponse(BaseModel):
         self.add(content=content, error=error, returncode=returncode or 1, **kwargs)
         return self
 
-    def _add_error(self, error: str) -> None:
-        """Append an error message to the existing error."""
-        if error != "":
-            self.error.append(error)
+    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)
 
-    def _add_to_error(self, error: str | list[str], name: str | None = None) -> None:
-        """Append additional error messages to the existing error."""
+    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."""
         try:
-            if isinstance(error, list):
-                for err in error:
-                    self._add_error(error=f"{name}: {err}" if name else err)
-            elif isinstance(error, str):
-                self._add_error(error=f"{name}: {error}" if name else error)
+            if isinstance(items, list):
+                for item in items:
+                    self._add_item(f"{name}: {item}" if name else item, target_list)
+            elif isinstance(items, str):
+                self._add_item(f"{name}: {items}" if name else items, target_list)
         except Exception as e:
-            raise ValueError(f"Failed to add error: {e!s}") from e
+            raise ValueError(f"Failed to add items: {e!s}") from e
 
-    def _add_content(self, content: str) -> None:
+    def _add_content(self, content: str | list[str], name: str | None = None) -> None:
         """Append content to the existing content."""
-        if content != "":
-            self.content.append(content)
+        self._add_to_list(content, self.content, name)
 
-    def _add_to_content(self, content: str | list[str], name: str | None = None) -> None:
-        """Append additional content to the existing content."""
-        try:
-            if isinstance(content, list):
-                for item in content:
-                    self._add_content(content=f"{name}: {item}" if name else item)
-            elif isinstance(content, str):
-                self._add_content(content=f"{name}: {content}" if name else content)
-        except Exception as e:
-            raise ValueError(f"Failed to add content: {e!s}") from e
+    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)
 
     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_to_error(error=func_response.error, name=func_response.name)
-        self._add_to_content(content=func_response.content, name=func_response.name)
+        self._add_error(error=func_response.error, name=func_response.name)
+        self._add_content(content=func_response.content, name=func_response.name)
 
     def _handle_completed_process(self, result: CompletedProcess[str]) -> None:
         """Handle a CompletedProcess object and update the FunctionResponse."""
-        self._add_to_content(content=result.stdout.strip() if result.stdout else "")
-        self._add_to_error(error=result.stderr.strip() if result.stderr else "")
+        self._add_content(content=result.stdout.strip() if result.stdout else "")
+        self._add_error(error=result.stderr.strip() if result.stderr else "")
         self.returncode = result.returncode
 
     def add(
@@ -244,13 +263,13 @@ class FunctionResponse(BaseModel):
                     self._handle_completed_process(result=content)
                     self.number_of_tasks += 1
                 case str() | list() if content:
-                    self._add_to_content(content=content)
+                    self._add_content(content=content)
                     self.number_of_tasks += 1
                 case None:
                     content = None
                 case _:
                     content = None
-            self._add_to_error(error=error) if isinstance(error, (str | list)) else None
+            self._add_error(error=error) if isinstance(error, (str | list)) else None
             self.returncode = returncode if returncode is not None else self.returncode
             self.extra.update(extra) if isinstance(extra, dict) else None
             if log_output and self.logger is not None and (content is not None or error is not None):
@@ -266,18 +285,19 @@ class FunctionResponse(BaseModel):
         logger: LoggerProtocol,
     ) -> None:
         """Log the content and error messages if they exist."""
-        if content is not None and error is None:
-            if isinstance(content, list):
-                for item in content:
-                    logger.info(f"{self.name}: {item}" if self.name else item)
-            elif isinstance(content, str):
-                logger.info(f"{self.name}: {content}" if self.name else content)
-        elif error is not None and content is None:
-            if isinstance(error, list):
-                for err in error:
-                    logger.error(f"{self.name}: {err}" if self.name else err)
-            elif isinstance(error, str):
-                logger.error(f"{self.name}: {error}" if self.name else error)
+
+        def _log_messages(messages: str | list[str], log_func: Callable) -> None:
+            if isinstance(messages, str):
+                messages = [messages]
+            if isinstance(messages, list):
+                for msg in messages:
+                    log_func(f"{self.name}: {msg}" if self.name else msg)
+
+        if content and isinstance(content, (str | list)):
+            _log_messages(content, logger.info)
+
+        if error and isinstance(error, (str | list)):
+            _log_messages(error, logger.error)
 
     @overload
     def done(self, to_dict: Literal[True], suppress: list[str] | None = None) -> dict[str, Any]: ...
@@ -295,26 +315,26 @@ class FunctionResponse(BaseModel):
         Returns:
             dict[str, Any] | Self: The dictionary representation or the FunctionResponse instance.
         """
+        if not to_dict:
+            return self
+
         if suppress is None:
             suppress = []
-        if to_dict:
-            result: dict[str, Any] = {}
-            if self.name and "name" not in suppress:
-                result["name"] = self.name
-            if "success" not in suppress:
-                result.update({"success": self.success})
-            if self.returncode > 0 and "returncode" not in suppress:
-                result["returncode"] = self.returncode
-            if self.number_of_tasks > 0 and "number_of_tasks" not in suppress:
-                result["number_of_tasks"] = self.number_of_tasks
-            if self.content and "content" not in suppress:
-                result["content"] = self.content
-            if self.error and "error" not in suppress:
-                result["error"] = self.error
-            if self.extra:
-                result.update(self.extra)
-            return result
-        return self
+
+        result: dict[str, Any] = {}
+
+        def add(k: str, v: Any, _bool: bool = True) -> None:
+            if k not in suppress and _bool:
+                result[k] = v
+
+        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)
+        add("content", self.content, bool(self.content))
+        add("error", self.error, bool(self.error))
+        result.update(self.extra)
+        return result
 
 
 def success(
@@ -334,3 +354,16 @@ def fail(
 ) -> FunctionResponse:
     """Create a failed FunctionResponse."""
     return FunctionResponse().fail(content=content, error=error, returncode=returncode, **kwargs)
+
+
+if __name__ == "__main__":
+    # Example usage
+    from rich import inspect
+
+    response = FunctionResponse(name="example_function", returncode=0, content=["Task completed successfully."])
+    response.task_id = 124
+
+    inspect(response)
+    print(response)
+    print(response.done(to_dict=True))
+    print(response.done(to_dict=False))

{bear_utils-0.8.6 → bear_utils-0.8.7}/tests/test_function_response.py

@@ -3,7 +3,9 @@
 from subprocess import CompletedProcess
 
 import pytest
+from rich.text import Text
 
+from bear_utils import BufferLogger
 from bear_utils.extras.responses.function_response import (
     FAILURE,
     SUCCESS,
@@ -223,10 +225,7 @@ class TestSubTaskMethod:
         main_response.sub_task(name="subtask", content="test")
         # The sub_task should inherit the parent's returncode
         assert main_response.number_of_tasks == 1
-        # Can't directly test the sub-response returncode, but the behavior should be consistent
-
-        # The sub_task should inherit the parent's returncode
-        assert main_response.number_of_tasks == 1
+        assert main_response.returncode == 5
         # Can't directly test the sub-response returncode, but the behavior should be consistent
 
     def test_sub_task_override_returncode(self):
@@ -235,6 +234,7 @@ class TestSubTaskMethod:
         main_response.sub_task(name="subtask", content="test", returncode=2)
 
         assert main_response.number_of_tasks == 1
+        assert main_response.returncode == 0
         # The sub-task uses the overridden returncode
 
     def test_sub_task_with_extra_and_kwargs(self):
@@ -351,10 +351,45 @@ class TestAddMethod:
         assert response.returncode == 2
         assert response.extra == {"metadata": "value"}
 
-    def test_add_with_logging(self):
+    def get_buffer_logger(self) -> BufferLogger:
+        """Get a BufferLogger instance for testing."""
+        from bear_utils import BufferLogger  # noqa: PLC0415
+
+        if BufferLogger.has_instance():
+            BufferLogger.reset_instance()
+
+            import logging  # noqa: PLC0415
+
+            logging.getLogger().handlers.clear()
+        return BufferLogger.get_instance(init=True, name="TestBufferLogger")
+
+    def test_add_with_logging_content(self) -> None:
         """Test add method with logging enabled."""
-        # Skip this test since LoggerProtocol validation is strict
-        pytest.skip("LoggerProtocol validation prevents mock objects")
+        buffer_logger: BufferLogger = self.get_buffer_logger()
+        response = FunctionResponse(logger=buffer_logger)
+        response.add(content="log entry", log_output=True)
+
+        output: str | Text = buffer_logger.trigger_buffer_flush()
+        assert "log entry" in str(output)
+
+    def test_add_with_logging_error(self) -> None:
+        """Test add method with logging error."""
+        buffer_logger: BufferLogger = self.get_buffer_logger()
+        response = FunctionResponse(logger=buffer_logger)
+        response.add(error="log error", log_output=True)
+
+        output: str | Text = buffer_logger.trigger_buffer_flush()
+        assert "log error" in str(output)
+
+    def test_add_with_logging_content_and_error(self) -> None:
+        """Test add method with logging content and error."""
+        buffer_logger: BufferLogger = self.get_buffer_logger()
+        response = FunctionResponse(logger=buffer_logger)
+        response.add(content="log content", error="log error", log_output=True)
+
+        output: str | Text = buffer_logger.trigger_buffer_flush()
+        assert "log content" in str(output)
+        assert "log error" in str(output)
 
 
 class TestDoneMethod:

bear_utils-0.8.6/src/bear_utils/cli/prompt_helpers.py

@@ -1,172 +0,0 @@
-"""Prompt Helpers Module for user input handling."""
-
-from typing import Any, overload
-
-from prompt_toolkit import prompt
-from prompt_toolkit.completion import WordCompleter
-from prompt_toolkit.validation import ValidationError, Validator
-
-from bear_utils.constants._exceptions import UserCancelledError
-from bear_utils.constants._lazy_typing import LitBool, LitFloat, LitInt, LitStr, OptBool, OptFloat, OptInt, OptStr
-from bear_utils.logger_manager import get_console
-
-# TODO: Overhaul this trash, it is written like absolute garbage.
-
-
-@overload
-def ask_question(question: str, expected_type: LitInt, default: OptInt = None, **kwargs) -> int: ...
-
-
-@overload
-def ask_question(question: str, expected_type: LitFloat, default: OptFloat = None, **kwargs) -> float: ...
-
-
-@overload
-def ask_question(question: str, expected_type: LitStr, default: OptStr = None, **kwargs) -> str: ...
-
-
-@overload
-def ask_question(question: str, expected_type: LitBool, default: OptBool = None, **kwargs) -> bool: ...
-
-
-def ask_question(question: str, expected_type: Any, default: Any = None, **_) -> Any:
-    """Ask a question and return the answer, ensuring the entered type is correct and a value is entered.
-
-    This function will keep asking until it gets a valid response or the user cancels with Ctrl+C.
-    If the user cancels, a UserCancelledError is raised.
-
-    Args:
-        question: The prompt question to display
-        expected_type: The expected type of the answer (int, float, str, bool)
-        default: Default value if no input is provided
-
-    Returns:
-        The user's response in the expected type
-
-    Raises:
-        UserCancelledError: If the user cancels input with Ctrl+C
-        ValueError: If an unsupported type is specified
-    """
-    console, sub = get_console("prompt_helpers.py")
-    try:
-        while True:
-            console.print(question)
-            response: str = prompt("> ")
-            if response == "":
-                if default is not None:
-                    return default
-                continue
-            match expected_type:
-                case "int":
-                    try:
-                        result = int(response)
-                        sub.verbose("int detected")
-                        return result
-                    except ValueError:
-                        sub.error("Invalid input. Please enter a valid integer.")
-                case "float":
-                    try:
-                        result = float(response)
-                        sub.verbose("float detected")
-                        return result
-                    except ValueError:
-                        sub.error("Invalid input. Please enter a valid float.")
-                case "str":
-                    sub.verbose("str detected")
-                    return response
-                case "bool":
-                    lower_response = response.lower()
-                    if lower_response in ("true", "t", "yes", "y", "1"):
-                        return True
-                    if lower_response in ("false", "f", "no", "n", "0"):
-                        return False
-                    sub.error("Invalid input. Please enter a valid boolean (true/false, yes/no, etc).")
-                case _:
-                    raise ValueError(f"Unsupported type: {expected_type}")
-    except KeyboardInterrupt:
-        raise UserCancelledError("User cancelled input") from None
-
-
-def ask_yes_no(question: str, default: None | Any = None, **kwargs) -> None | bool:
-    """Ask a yes or no question and return the answer.
-
-    Args:
-        question: The prompt question to display
-        default: Default value if no input is provided
-
-    Returns:
-        True for yes, False for no, or None if no valid response is given
-    """
-    kwargs = kwargs or {}
-    sub, console = get_console("prompt_helpers.py")
-    try:
-        while True:
-            console.info(question)
-            response = prompt("> ")
-
-            if response == "":
-                if default is not None:
-                    return default
-                continue
-
-            if response.lower() in ["yes", "y"]:
-                return True
-            if response.lower() in ["no", "n"]:
-                return False
-            if response.lower() in ["exit", "quit"]:
-                return None
-            console.error("Invalid input. Please enter 'yes' or 'no' or exit.")
-            continue
-    except KeyboardInterrupt:
-        console.warning("KeyboardInterrupt: Exiting the prompt.")
-        return None
-
-
-def restricted_prompt(question: str, valid_options: list[str], exit_command: str = "exit", **kwargs) -> None | str:
-    """Continuously prompt the user until they provide a valid response or exit.
-
-    Args:
-        question: The prompt question to display
-        valid_options: List of valid responses
-        exit_command: Command to exit the prompt (default: "exit")
-
-    Returns:
-        The user's response or None if they chose to exit
-    """
-    kwargs = kwargs or {}
-    sub, console = get_console("prompt_helpers.py")
-    completer_options: list[str] = [*valid_options, exit_command]
-    completer = WordCompleter(completer_options)
-
-    class OptionValidator(Validator):
-        def validate(self, document: Any) -> None:
-            """Validate the user's input against the valid options."""
-            text: str = document.text.lower()
-            if text != exit_command and text not in valid_options:
-                raise ValidationError(
-                    message=f"Invalid option: {text}. Please choose from {', '.join(valid_options)} or type '{exit_command}' to exit.",
-                    cursor_position=len(document.text),
-                )
-
-    try:
-        while True:
-            if console is not None:
-                console.info(question)
-                response = prompt("> ", completer=completer, validator=OptionValidator(), complete_while_typing=True)
-                response = response.lower()
-            else:
-                response = prompt(
-                    question, completer=completer, validator=OptionValidator(), complete_while_typing=True
-                )
-                response = response.lower()
-
-            if response == exit_command:
-                return None
-            if response == "":
-                sub.error("No input provided. Please enter a valid option or exit.")
-                continue
-            if response in valid_options:
-                return response
-    except KeyboardInterrupt:
-        sub.warning("KeyboardInterrupt: Exiting the prompt.")
-        return None