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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.8.23
+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
@@ -19,12 +19,13 @@ Requires-Dist: singleton-base>=1.0.5
 Requires-Dist: sqlalchemy<3.0.0,>=2.0.40
 Requires-Dist: tinydb>=4.8.2
 Requires-Dist: toml>=0.10.2
+Requires-Dist: typer>=0.16.0
 Requires-Dist: uvicorn>=0.35.0
 Provides-Extra: gui
 Requires-Dist: pyqt6>=6.9.0; extra == 'gui'
 Description-Content-Type: text/markdown
 
-# Bear Utils v# Bear Utils v0.8.23
+# 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.23 → bear_utils-0.8.25}/README.md

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.8.23
+# 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.23 → bear_utils-0.8.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.8.23"
+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"
@@ -22,6 +22,7 @@ dependencies = [
     "fastapi>=0.116.0",
     "uvicorn>=0.35.0",
     "bear-epoch-time>=1.1.1",
+    "typer>=0.16.0",
 ]
 
 [project.optional-dependencies]

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

@@ -10,7 +10,11 @@ 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_exit(value: str) -> bool:
+    """Parse a string into a boolean indicating if the user wants to exit."""
+    lower_value: str = value.lower().strip()
+    return lower_value in ("exit", "quit", "q")
 
 
 def _parse_bool(value: str) -> bool:
@@ -70,7 +74,7 @@ def ask_question(question: str, expected_type: type, default: Any = None) -> Any
         UserCancelledError: If the user cancels input with Ctrl+C
         ValueError: If an unsupported type is specified
     """
-    console, sub = get_console("prompt_helpers.py")
+    console, _ = get_console("prompt_helpers.py")
 
     try:
         while True:
@@ -80,14 +84,14 @@ def ask_question(question: str, expected_type: type, default: Any = None) -> Any
             if not response:
                 if default is not None:
                     return default
-                sub.error("Input required. Please enter a value.")
+                console.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")
+                console.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__}.")
+                console.error(f"Invalid input: {e}. Please enter a valid {expected_type.__name__}.")
 
     except KeyboardInterrupt:
         raise UserCancelledError("User cancelled input") from None
@@ -103,32 +107,32 @@ 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")
-
-    try:
-        while True:
-            console.print(question)
-            response = prompt("> ").strip().lower()
+    console, _ = get_console("prompt_helpers.py")
 
+    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 response in ("exit", "quit"):
+            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(
-    question: str, valid_options: list[str], exit_command: str = "exit", case_sensitive: bool = False
+    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.
 
@@ -141,12 +145,12 @@ def restricted_prompt(
     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]
+    console, _ = get_console("prompt_helpers.py")
+    completer_options: list[str] = [*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()
+    comparison_options: list[str] = valid_options if case_sensitive else [opt.lower() for opt in valid_options]
+    comparison_exit: str = exit_command if case_sensitive else exit_command.lower()
 
     class OptionValidator(Validator):
         def validate(self, document: Any) -> None:
@@ -160,13 +164,15 @@ def restricted_prompt(
 
     try:
         while True:
-            console.print(question)
             response: str = prompt(
-                "> ", completer=completer, validator=OptionValidator(), complete_while_typing=True
+                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:
-                sub.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
@@ -175,7 +181,6 @@ def restricted_prompt(
                     idx: int = comparison_options.index(comparison_response)
                     return valid_options[idx]
                 return response
-
     except KeyboardInterrupt:
-        sub.warning("KeyboardInterrupt: Exiting the prompt.")
+        console.print("KeyboardInterrupt: Exiting the prompt.", style="yellow")
         return None

{bear_utils-0.8.23 → 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.25/src/bear_utils/cli/typer_bridge.py

@@ -0,0 +1,90 @@
+"""A simple bridge for augmenting Typer with alias support and command execution for interactive use."""
+
+from collections.abc import Callable
+import shlex
+from typing import Any, TypedDict
+
+from rich.console import Console
+from singleton_base import SingletonBase
+from typer import Exit, Typer
+from typer.models import CommandInfo
+
+from bear_utils.logger_manager import AsyncLoggerProtocol, LoggerProtocol
+
+
+class CommandMeta(TypedDict):
+    """Metadata for a Typer command."""
+
+    name: str
+    help: str
+    hidden: bool
+
+
+def get_command_meta(command: CommandInfo) -> CommandMeta:
+    """Extract metadata from a Typer command."""
+    return {
+        "name": command.name or (command.callback.__name__ if command.callback else "unknown"),
+        "help": (command.callback.__doc__ if command.callback else None) or "No description available",
+        "hidden": command.hidden,
+    }
+
+
+# TODO: Add support for usage statements for a more robust help system
+
+
+class TyperBridge(SingletonBase):
+    """Simple bridge for Typer command execution."""
+
+    def __init__(self, typer_app: Typer, console: AsyncLoggerProtocol | LoggerProtocol | Console) -> None:
+        """Initialize the TyperBridge with a Typer app instance."""
+        self.app: Typer = typer_app
+        self.console: AsyncLoggerProtocol | LoggerProtocol | Console = console or Console()
+        self.command_meta: dict[str, CommandMeta] = {}
+
+    def alias(self, *alias_names: str) -> Callable[..., Callable[..., Any]]:
+        """Register aliases as hidden Typer commands."""
+
+        def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+            for alias in alias_names:
+                self.app.command(name=alias, hidden=True)(func)
+            return func
+
+        return decorator
+
+    def execute_command(self, command_string: str) -> bool:
+        """Execute command via Typer. Return True if successful."""
+        try:
+            parts: list[str] = shlex.split(command_string.strip())
+            if not parts:
+                return False
+            self.app(parts, standalone_mode=False)
+            return True
+        except Exit:
+            return True
+        except Exception as e:
+            if isinstance(self.console, Console):
+                self.console.print(f"[red]Error executing command: {e}[/red]")
+            else:
+                self.console.error(f"Error executing command: {e}", exc_info=True)
+            return False
+
+    def bootstrap_command_meta(self) -> None:
+        """Bootstrap command metadata from the Typer app."""
+        if not self.command_meta:
+            for cmd in self.app.registered_commands:
+                cmd_meta: CommandMeta = get_command_meta(command=cmd)
+                self.command_meta[cmd_meta["name"]] = cmd_meta
+
+    def get_all_command_info(self, show_hidden: bool = False) -> dict[str, CommandMeta]:
+        """Get all command information from the Typer app."""
+        if not self.command_meta:
+            self.bootstrap_command_meta()
+        if not show_hidden:
+            return {name: meta for name, meta in self.command_meta.items() if not meta["hidden"]}
+        return self.command_meta
+
+    def get_command_info(self, command_name: str) -> CommandMeta | None:
+        """Get metadata for a specific command."""
+        if not self.command_meta:
+            self.bootstrap_command_meta()
+        return self.command_meta.get(command_name)

{bear_utils-0.8.23 → 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