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

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.8.24
+Version: 0.8.26
 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.26
 
 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.26}/README.md

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.8.24
+# Bear Utils v# Bear Utils v0.8.26
 
 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.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.8.24"
+version = "0.8.26"
 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.26}/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.26}/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.26}/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.26}/src/bear_utils/extras/__init__.py

@@ -2,7 +2,7 @@
 
 from singleton_base import SingletonBase
 
-from ._tools import ClipboardManager, clear_clipboard, copy_to_clipboard, fmt_header, paste_from_clipboard
+from ._tools import ClipboardManager, ascii_header, clear_clipboard, copy_to_clipboard, paste_from_clipboard
 from .platform_utils import OS, get_platform, is_linux, is_macos, is_windows
 from .wrappers.add_methods import add_comparison_methods
 
@@ -11,9 +11,9 @@ __all__ = [
     "ClipboardManager",
     "SingletonBase",
     "add_comparison_methods",
+    "ascii_header",
     "clear_clipboard",
     "copy_to_clipboard",
-    "fmt_header",
     "get_platform",
     "is_linux",
     "is_macos",

{bear_utils-0.8.24 → bear_utils-0.8.26}/src/bear_utils/extras/_tools.py

@@ -5,42 +5,16 @@ from functools import cached_property
 import shutil
 from typing import TYPE_CHECKING
 
+from rich.console import Console
+
 from bear_utils.cli.shell._base_command import BaseShellCommand as ShellCommand
 from bear_utils.cli.shell._base_shell import AsyncShellSession
 from bear_utils.extras.platform_utils import OS, get_platform
-from bear_utils.logger_manager.loggers.base_logger import BaseLogger
 
 if TYPE_CHECKING:
     from subprocess import CompletedProcess
 
 
-class TextHelper:
-    @cached_property
-    def local_console(self) -> BaseLogger:
-        from bear_utils.logger_manager import BaseLogger  # noqa: PLC0415
-
-        init: bool = not BaseLogger.has_instance()
-        return BaseLogger.get_instance(init=init)
-
-    def print_header(
-        self,
-        title: str,
-        sep: str = "#",
-        length: int = 60,
-        s1: str = "bold red",
-        s2: str = "bold blue",
-        return_txt: bool = False,
-    ) -> str:
-        """Generate a header string"""
-        # FIXME: There are probably better ways to do this, but this is OK.
-        fill: str = sep * length
-        title = f" {title} ".center(length, sep).replace(title, f"[{s1}]{title}[/{s1}]")
-        output_text: str = f"\n{fill}\n{title}\n{fill}\n"
-        if not return_txt:
-            self.local_console.print(output_text, style=s2)
-        return output_text
-
-
 class ClipboardManager:
     """A class to manage clipboard operations such as copying, pasting, and clearing.
 
@@ -201,9 +175,71 @@ async def clear_clipboard_async() -> int:
     return await clipboard_manager.clear()
 
 
-def fmt_header(
+class TextHelper:
+    @cached_property
+    def local_console(self) -> Console:
+        return Console()
+
+    def print_header(
+        self,
+        title: str,
+        top_sep: str = "#",
+        left_sep: str = ">",
+        right_sep: str = "<",
+        bottom_sep: str = "#",
+        length: int = 60,
+        s1: str = "bold red",
+        s2: str = "bold blue",
+        return_txt: bool = False,
+    ) -> str:
+        """Generate a header string with customizable separators for each line.
+
+        Args:
+            title: The title text to display
+            top_sep: Character(s) for the top separator line
+            left_sep: Character(s) for the left side of title line
+            right_sep: Character(s) for the right side of title line
+            bottom_sep: Character(s) for the bottom separator line
+            length: Total width of each line
+            s1: Style for the title text
+            s2: Style for the entire header block
+            return_txt: If True, return the text instead of printing
+        """
+        # Top line: all top_sep characters
+        top_line: str = top_sep * length
+
+        # Bottom line: all bottom_sep characters
+        bottom_line: str = bottom_sep * length
+
+        # Title line: left_sep chars + title + right_sep chars
+        title_with_spaces = f" {title} "
+        styled_title = f"[{s1}]{title}[/{s1}]"
+
+        # Calculate padding needed on each side
+        title_length = len(title_with_spaces)
+        remaining_space = length - title_length
+        left_padding = remaining_space // 2
+        right_padding = remaining_space - left_padding
+
+        # Build the title line with different left and right separators
+        title_line = (
+            (left_sep * left_padding) + title_with_spaces.replace(title, styled_title) + (right_sep * right_padding)
+        )
+
+        # Assemble the complete header
+        output_text: str = f"\n{top_line}\n{title_line}\n{bottom_line}\n"
+
+        if not return_txt:
+            self.local_console.print(output_text, style=s2)
+        return output_text
+
+
+def ascii_header(
     title: str,
-    sep: str = "#",
+    top_sep: str = "#",
+    left_sep: str = ">",
+    right_sep: str = "<",
+    bottom_sep: str = "#",
     length: int = 60,
     style1: str = "bold red",
     style2: str = "bold blue",
@@ -213,13 +249,45 @@ def fmt_header(
 
     Args:
         title (str): The title to display in the header.
-        sep (str): The character to use for the separator. Defaults to '#'.
+        top_sep (str): The character to use for the top separator line. Defaults to '#'.
+        left_sep (str): The character to use for the left side of title line. Defaults to '>'.
+        right_sep (str): The character to use for the right side of title line. Defaults to '<'.
+        bottom_sep (str): The character to use for the bottom separator line. Defaults to '#'.
         length (int): The total length of the header line. Defaults to 60.
         style1 (str): The style for the title text. Defaults to 'bold red'.
         style2 (str): The style for the separator text. Defaults to 'bold blue'.
+        print_out (bool): Whether to print the header or just return it. Defaults to True.
     """
     text_helper = TextHelper()
     if print_out:
-        text_helper.print_header(title=title, sep=sep, length=length, s1=style1, s2=style2, return_txt=False)
+        text_helper.print_header(
+            title=title,
+            top_sep=top_sep,
+            left_sep=left_sep,
+            right_sep=right_sep,
+            bottom_sep=bottom_sep,
+            length=length,
+            s1=style1,
+            s2=style2,
+            return_txt=False,
+        )
         return ""
-    return text_helper.print_header(title=title, sep=sep, length=length, s1=style1, s2=style2, return_txt=True)
+    return text_helper.print_header(
+        title=title,
+        top_sep=top_sep,
+        left_sep=left_sep,
+        right_sep=right_sep,
+        bottom_sep=bottom_sep,
+        length=length,
+        s1=style1,
+        s2=style2,
+        return_txt=True,
+    )
+
+
+if __name__ == "__main__":
+    # Example usage of the TextHelper
+    text_helper = TextHelper()
+    text_helper.print_header("My Title", top_sep="#", bottom_sep="#")
+    text_helper.print_header("My Title", top_sep="=", left_sep=">", right_sep="<", bottom_sep="=")
+    text_helper.print_header("My Title", top_sep="-", left_sep="[", right_sep="]", bottom_sep="-")

{bear_utils-0.8.24 → bear_utils-0.8.26}/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.26/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