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

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

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

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

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: bear-utils
-Version: 0.8.25
+Version: 0.8.27
 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
-Requires-Dist: bear-epoch-time>=1.1.1
+Requires-Dist: bear-epoch-time>=1.1.4
 Requires-Dist: diskcache<6.0.0,>=5.6.3
 Requires-Dist: fastapi>=0.116.0
 Requires-Dist: httpx>=0.28.1
@@ -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.25
+# Bear Utils v# Bear Utils v0.8.27
 
 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.25 → bear_utils-0.8.27}/README.md

@@ -1,4 +1,4 @@
-# Bear Utils v# Bear Utils v0.8.25
+# Bear Utils v# Bear Utils v0.8.27
 
 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.25 → bear_utils-0.8.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bear-utils"
-version = "0.8.25"
+version = "0.8.27"
 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"
@@ -21,7 +21,7 @@ dependencies = [
     "tinydb>=4.8.2",
     "fastapi>=0.116.0",
     "uvicorn>=0.35.0",
-    "bear-epoch-time>=1.1.1",
+    "bear-epoch-time>=1.1.4",
     "typer>=0.16.0",
 ]
 
@@ -81,7 +81,7 @@ include = ["src"]
 exclude = ["**/__pycache__"]
 venvPath = "."
 venv = ".venv"
-pythonVersion = "3.12"
+pythonVersion = "3.13"
 typeCheckingMode = "standard"
 reportMissingImports = true
 reportMissingTypeStubs = false

{bear_utils-0.8.25 → bear_utils-0.8.27}/src/bear_utils/__init__.py

@@ -2,11 +2,12 @@
 
 from bear_utils.cache import CacheWrapper, cache, cache_factory
 from bear_utils.config.settings_manager import SettingsManager, get_settings_manager
+from bear_utils.constants import DEVNULL, STDERR, STDOUT, ExitCode, HTTPStatusCode
 from bear_utils.database import DatabaseManager
 from bear_utils.events import Events
-from bear_utils.extras.responses import FAILURE, SUCCESS, FunctionResponse
+from bear_utils.extras.responses import FunctionResponse
 from bear_utils.files.file_handlers.file_handler_factory import FileHandlerFactory
-from bear_utils.logger_manager import BaseLogger, BufferLogger, ConsoleLogger, FileLogger
+from bear_utils.logger_manager import BaseLogger, BufferLogger, ConsoleLogger, FileLogger, LoggingClient, LoggingServer
 from bear_utils.logger_manager._common import VERBOSE_CONSOLE_FORMAT
 from bear_utils.logger_manager._styles import VERBOSE
 from bear_utils.time import (
@@ -21,8 +22,9 @@ from bear_utils.time import (
 __all__ = [
     "DATE_FORMAT",
     "DATE_TIME_FORMAT",
-    "FAILURE",
-    "SUCCESS",
+    "DEVNULL",
+    "STDERR",
+    "STDOUT",
     "VERBOSE",
     "VERBOSE_CONSOLE_FORMAT",
     "BaseLogger",
@@ -32,9 +34,13 @@ __all__ = [
     "DatabaseManager",
     "EpochTimestamp",
     "Events",
+    "ExitCode",
     "FileHandlerFactory",
     "FileLogger",
     "FunctionResponse",
+    "HTTPStatusCode",
+    "LoggingClient",
+    "LoggingServer",
     "SettingsManager",
     "TimeTools",
     "cache",

{bear_utils-0.8.25 → bear_utils-0.8.27}/src/bear_utils/cli/__init__.py

@@ -1,5 +1,6 @@
 """A set of command-line interface (CLI) utilities for bear_utils."""
 
+from ._args import FAILURE, SUCCESS, ExitCode, args_process
 from .commands import GitCommand, MaskShellCommand, OPShellCommand, UVShellCommand
 from .shell._base_command import BaseShellCommand
 from .shell._base_shell import SimpleShellSession, shell_session
@@ -7,11 +8,15 @@ from .shell._common import DEFAULT_SHELL
 
 __all__ = [
     "DEFAULT_SHELL",
+    "FAILURE",
+    "SUCCESS",
     "BaseShellCommand",
+    "ExitCode",
     "GitCommand",
     "MaskShellCommand",
     "OPShellCommand",
     "SimpleShellSession",
     "UVShellCommand",
+    "args_process",
     "shell_session",
 ]

bear_utils-0.8.27/src/bear_utils/cli/_args.py

@@ -0,0 +1,12 @@
+import sys
+
+from bear_utils.constants._exit_code import FAILURE, SUCCESS, ExitCode
+
+
+def args_process(args: list[str] | None = None) -> tuple[list[str], ExitCode]:
+    args = sys.argv[1:] if args is None else args
+
+    if not args:
+        return [], FAILURE
+
+    return args, SUCCESS

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

@@ -13,26 +13,13 @@ import subprocess
 from subprocess import CompletedProcess
 from typing import Self, override
 
+from bear_utils.constants import ExitCode
 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
 
-EXIT_CODES: dict[int, str] = {
-    0: "Success",
-    1: "General error",
-    2: "Misuse of shell command",
-    126: "Command invoked cannot execute",
-    127: "Command not found",
-    128: "Invalid argument to exit",
-    130: "Script terminated by Control-C",
-    137: "Process killed by SIGKILL (9)",
-    139: "Segmentation fault (core dumped)",
-    143: "Process terminated by SIGTERM (15)",
-    255: "Exit status out of range",
-}
-
 
 class FancyCompletedProcess(CompletedProcess[str]):
     def __init__(self, args: list[str], returncode: int, stdout: str | None = None, stderr: str | None = None) -> None:
@@ -53,7 +40,7 @@ class FancyCompletedProcess(CompletedProcess[str]):
     @property
     def exit_message(self) -> str:
         """Get a human-readable message for the exit code"""
-        return EXIT_CODES.get(self.returncode, EXIT_CODES.get(1, "Unknown error"))
+        return ExitCode.from_int(self.returncode).text
 
 
 class CommandList(deque[CompletedProcess[str]]):
@@ -149,7 +136,7 @@ class SimpleShellSession:
 
     def _run(self, command: str) -> CompletedProcess[str]:
         """Internal method to run the accumulated command"""
-        self.logger.verbose(f"Executing: {command}")
+        self.logger.debug(f"Executing: {command}")
         self.next_cmd()
 
         if self.use_shell:
@@ -311,7 +298,7 @@ class AsyncShellSession(SimpleShellSession):
     @override
     async def _run(self, command: str, **kwargs) -> Process:  # type: ignore[override]
         """Run the command using Popen for better control"""
-        self.logger.verbose(f"Executing: {command}")
+        self.logger.debug(f"Executing: {command}")
         self.next_cmd()
 
         if self.use_shell:

bear_utils-0.8.27/src/bear_utils/constants/__init__.py

@@ -0,0 +1,86 @@
+"""Constants Module for Bear Utils."""
+
+from pathlib import Path
+import sys
+from typing import TextIO
+
+from bear_utils.constants._exit_code import (
+    COMMAND_CANNOT_EXECUTE,
+    COMMAND_NOT_FOUND,
+    EXIT_STATUS_OUT_OF_RANGE,
+    FAIL,
+    INVALID_ARGUMENT_TO_EXIT,
+    MISUSE_OF_SHELL_COMMAND,
+    PROCESS_KILLED_BY_SIGKILL,
+    PROCESS_TERMINATED_BY_SIGTERM,
+    SCRIPT_TERMINATED_BY_CONTROL_C,
+    SEGMENTATION_FAULT,
+    SUCCESS,
+    ExitCode,
+)
+from bear_utils.constants._http_status_code import (
+    BAD_REQUEST,
+    CONFLICT,
+    FORBIDDEN,
+    PAGE_NOT_FOUND,
+    SERVER_ERROR,
+    SERVER_OK,
+    UNAUTHORIZED,
+    HTTPStatusCode,
+)
+from bear_utils.constants._meta import NullFile, RichIntEnum, Value
+
+VIDEO_EXTS = [".mp4", ".mov", ".avi", ".mkv"]
+"""Extensions for video files."""
+IMAGE_EXTS = [".jpg", ".jpeg", ".png", ".gif"]
+"""Extensions for image files."""
+FILE_EXTS = IMAGE_EXTS + VIDEO_EXTS
+"""Extensions for both image and video files."""
+
+PATH_TO_DOWNLOADS = Path.home() / "Downloads"
+"""Path to the Downloads folder."""
+PATH_TO_PICTURES = Path.home() / "Pictures"
+"""Path to the Pictures folder."""
+GLOBAL_VENV = Path.home() / ".global_venv"
+"""Path to the global virtual environment."""
+
+STDOUT: TextIO = sys.stdout
+"""Standard output stream."""
+STDERR: TextIO = sys.stderr
+"""Standard error stream."""
+DEVNULL: TextIO = NullFile()
+"""A null file that discards all writes."""
+
+__all__ = [
+    "BAD_REQUEST",
+    "COMMAND_CANNOT_EXECUTE",
+    "COMMAND_NOT_FOUND",
+    "CONFLICT",
+    "EXIT_STATUS_OUT_OF_RANGE",
+    "FAIL",
+    "FILE_EXTS",
+    "FORBIDDEN",
+    "GLOBAL_VENV",
+    "IMAGE_EXTS",
+    "INVALID_ARGUMENT_TO_EXIT",
+    "MISUSE_OF_SHELL_COMMAND",
+    "PAGE_NOT_FOUND",
+    "PATH_TO_DOWNLOADS",
+    "PATH_TO_PICTURES",
+    "PROCESS_KILLED_BY_SIGKILL",
+    "PROCESS_TERMINATED_BY_SIGTERM",
+    "SCRIPT_TERMINATED_BY_CONTROL_C",
+    "SEGMENTATION_FAULT",
+    "SERVER_ERROR",
+    "SERVER_OK",
+    "STDERR",
+    "STDOUT",
+    "SUCCESS",
+    "UNAUTHORIZED",
+    "VIDEO_EXTS",
+    "ExitCode",
+    "HTTPStatusCode",
+    "NullFile",
+    "RichIntEnum",
+    "Value",
+]

bear_utils-0.8.27/src/bear_utils/constants/_exit_code.py

@@ -0,0 +1,60 @@
+from bear_utils.constants._meta import RichIntEnum, Value
+
+
+class ExitCode(RichIntEnum):
+    """An enumeration of common exit codes used in shell commands."""
+
+    SUCCESS = Value(0, "Success")
+    FAILURE = Value(1, "General error")
+    MISUSE_OF_SHELL_COMMAND = Value(2, "Misuse of shell command")
+    COMMAND_CANNOT_EXECUTE = Value(126, "Command invoked cannot execute")
+    COMMAND_NOT_FOUND = Value(127, "Command not found")
+    INVALID_ARGUMENT_TO_EXIT = Value(128, "Invalid argument to exit")
+    SCRIPT_TERMINATED_BY_CONTROL_C = Value(130, "Script terminated by Control-C")
+    PROCESS_KILLED_BY_SIGKILL = Value(137, "Process killed by SIGKILL (9)")
+    SEGMENTATION_FAULT = Value(139, "Segmentation fault (core dumped)")
+    PROCESS_TERMINATED_BY_SIGTERM = Value(143, "Process terminated by SIGTERM (15)")
+    EXIT_STATUS_OUT_OF_RANGE = Value(255, "Exit status out of range")
+
+
+SUCCESS = ExitCode.SUCCESS
+"""An exit code indicating success."""
+FAIL = ExitCode.FAILURE
+"""Deprecated alias for ExitCode.FAILURE."""
+FAILURE = ExitCode.FAILURE
+"""An exit code indicating a general error."""
+MISUSE_OF_SHELL_COMMAND = ExitCode.MISUSE_OF_SHELL_COMMAND
+"""An exit code indicating misuse of a shell command."""
+COMMAND_CANNOT_EXECUTE = ExitCode.COMMAND_CANNOT_EXECUTE
+"""An exit code indicating that the command invoked cannot execute."""
+COMMAND_NOT_FOUND = ExitCode.COMMAND_NOT_FOUND
+"""An exit code indicating that the command was not found."""
+INVALID_ARGUMENT_TO_EXIT = ExitCode.INVALID_ARGUMENT_TO_EXIT
+"""An exit code indicating an invalid argument to exit."""
+SCRIPT_TERMINATED_BY_CONTROL_C = ExitCode.SCRIPT_TERMINATED_BY_CONTROL_C
+"""An exit code indicating that the script was terminated by Control-C."""
+PROCESS_KILLED_BY_SIGKILL = ExitCode.PROCESS_KILLED_BY_SIGKILL
+"""An exit code indicating that the process was killed by SIGKILL (9)."""
+SEGMENTATION_FAULT = ExitCode.SEGMENTATION_FAULT
+"""An exit code indicating a segmentation fault (core dumped)."""
+PROCESS_TERMINATED_BY_SIGTERM = ExitCode.PROCESS_TERMINATED_BY_SIGTERM
+"""An exit code indicating that the process was terminated by SIGTERM (15)."""
+EXIT_STATUS_OUT_OF_RANGE = ExitCode.EXIT_STATUS_OUT_OF_RANGE
+"""An exit code indicating that the exit status is out of range."""
+
+
+__all__ = [
+    "COMMAND_CANNOT_EXECUTE",
+    "COMMAND_NOT_FOUND",
+    "EXIT_STATUS_OUT_OF_RANGE",
+    "FAIL",
+    "FAILURE",
+    "INVALID_ARGUMENT_TO_EXIT",
+    "MISUSE_OF_SHELL_COMMAND",
+    "PROCESS_KILLED_BY_SIGKILL",
+    "PROCESS_TERMINATED_BY_SIGTERM",
+    "SCRIPT_TERMINATED_BY_CONTROL_C",
+    "SEGMENTATION_FAULT",
+    "SUCCESS",
+    "ExitCode",
+]

bear_utils-0.8.27/src/bear_utils/constants/_http_status_code.py

@@ -0,0 +1,37 @@
+"""HTTP status codes."""
+
+from bear_utils.constants._meta import RichIntEnum, Value
+
+
+class HTTPStatusCode(RichIntEnum):
+    """An enumeration of common HTTP status codes."""
+
+    SERVER_ERROR = Value(500, "Internal Server Error")
+    SERVER_OK = Value(200, "OK")
+    PAGE_NOT_FOUND = Value(404, "Not Found")
+    BAD_REQUEST = Value(400, "Bad Request")
+    UNPROCESSABLE_CONTENT = Value(422, "Unprocessable Content")
+    UNAUTHORIZED = Value(401, "Unauthorized")
+    FORBIDDEN = Value(403, "Forbidden")
+    CONFLICT = Value(409, "Conflict")
+    METHOD_NOT_ALLOWED = Value(405, "Method Not Allowed")
+
+
+SERVER_ERROR = HTTPStatusCode.SERVER_ERROR
+"""Internal Server Error"""
+SERVER_OK = HTTPStatusCode.SERVER_OK
+"""OK"""
+PAGE_NOT_FOUND = HTTPStatusCode.PAGE_NOT_FOUND
+"""Not Found"""
+BAD_REQUEST = HTTPStatusCode.BAD_REQUEST
+"""Bad Request"""
+UNPROCESSABLE_CONTENT = HTTPStatusCode.UNPROCESSABLE_CONTENT
+"""Unprocessable Content"""
+UNAUTHORIZED = HTTPStatusCode.UNAUTHORIZED
+"""Unauthorized"""
+FORBIDDEN = HTTPStatusCode.FORBIDDEN
+"""Forbidden"""
+CONFLICT = HTTPStatusCode.CONFLICT
+"""Conflict"""
+METHOD_NOT_ALLOWED = HTTPStatusCode.METHOD_NOT_ALLOWED
+"""Method Not Allowed"""

bear_utils-0.8.27/src/bear_utils/constants/_meta.py

@@ -0,0 +1,107 @@
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Any, Self, TextIO
+
+
+@dataclass(frozen=True)
+class Value:
+    """A frozen dataclass for holding constant values."""
+
+    value: int
+    text: str
+
+
+class RichIntEnum(IntEnum):
+    """Base class for IntEnums with rich metadata."""
+
+    text: str
+
+    def __new__(cls, value: Value) -> Self:
+        _value: int = value.value
+        text: str = value.text
+        obj: Self = int.__new__(cls, _value)
+        obj._value_ = _value
+        obj.text = text
+        return obj
+
+    def __int__(self) -> int:
+        """Return the integer value of the enum."""
+        return self.value
+
+    def __str__(self) -> str:
+        return f"{self.name} ({self.value}): {self.text}"
+
+    @classmethod
+    def get(cls, value: Any) -> Self:
+        """Try to get an enum member by its value, name, or text."""
+        if isinstance(value, cls):
+            return value
+        if isinstance(value, int):
+            return cls.from_int(value)
+        if isinstance(value, str):
+            return cls.from_name(value)
+        raise ValueError(f"Cannot convert {value} to {cls.__name__}")
+
+    @classmethod
+    def from_name(cls, name: str) -> Self:
+        """Convert a string name to its corresponding enum member."""
+        try:
+            return cls[name.upper()]
+        except KeyError as e:
+            raise ValueError(f"Name {name} not found in {cls.__name__}") from e
+
+    @classmethod
+    def from_int(cls, code: int) -> Self:
+        for item in cls:
+            if item.value == code:
+                return item
+        raise ValueError(f"Value {code} not found in {cls.__name__}")
+
+    @classmethod
+    def int_to_text(cls, code: int) -> str:
+        """Convert an integer to its text representation."""
+        try:
+            return cls.from_int(code).text
+        except ValueError:
+            return "Unknown value"
+
+
+class MockTextIO(TextIO):
+    """A mock TextIO class that does nothing."""
+
+    def __init__(self) -> None:
+        """Initialize the mock TextIO."""
+        self._buffer = []
+
+    def write(self, _s: str, *_) -> None:  # type: ignore[override]
+        """Mock write method that appends to the buffer."""
+        if _s == "\n":
+            return
+        self._buffer.append(_s)
+
+    def output_buffer(self) -> list[str]:
+        """Get the output buffer."""
+        return self._buffer
+
+    def clear(self) -> None:
+        """Clear the output buffer."""
+        self._buffer.clear()
+
+    def flush(self) -> None:
+        """Mock flush method that does nothing."""
+
+
+class NullFile(TextIO):
+    """A class that acts as a null file, discarding all writes."""
+
+    def write(self, _s: str, *_: Any) -> None:  # type: ignore[override]
+        """Discard the string written to this null file."""
+
+    def flush(self) -> None:
+        """Flush the null file (no operation)."""
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        """Exit context manager (no operation)."""

{bear_utils-0.8.25 → bear_utils-0.8.27}/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.25 → bear_utils-0.8.27}/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="-")