termtastic 0.0.3__tar.gz

termtastic-0.0.3/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.3
+Name: termtastic
+Version: 0.0.3
+Summary: A fantastic set of terminal utilities for python
+Author: Bearmine
+Requires-Python: >=3.12
+Project-URL: Repository, https://forge.bearmine.com/bearmine/termtastic
+Description-Content-Type: text/markdown
+
+# termtastic
+

termtastic-0.0.3/README.md

@@ -0,0 +1,2 @@
+# termtastic
+

termtastic-0.0.3/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "termtastic"
+version = "0.0.3"
+description = "A fantastic set of terminal utilities for python"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = []
+
+[[project.authors]]
+name = "Bearmine"
+
+[project.urls]
+Repository = "https://forge.bearmine.com/bearmine/termtastic"
+
+[dependency-groups]
+lint = ["ruff"]
+test = ["pytest"]
+
+[[dependency-groups.dev]]
+include-group = "lint"
+
+[[dependency-groups.dev]]
+include-group = "test"
+
+[build-system]
+requires = ["uv_build>=0.12.9,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.ruff.lint]
+extend-select = [
+    "F",
+    "W",
+    "E",
+    "I",
+    "UP",
+    "C4",
+    "FA",
+    "ISC",
+    "ICN",
+    "RET",
+    "SIM",
+    "TID",
+    "TC",
+    "PTH",
+    "TD",
+    "NPY",
+    "FURB",
+]
+ignore = ["TD003"]
+
+[tool.ruff.lint.pycodestyle]
+max-line-length = 100

termtastic-0.0.3/pyproject.toml.orig

@@ -0,0 +1,59 @@
+[project]
+name = "termtastic"
+version = "0.0.3"
+description = "A fantastic set of terminal utilities for python"
+readme = "README.md"
+authors = [
+    { name = "Bearmine" }
+]
+requires-python = ">=3.12"
+dependencies = []
+
+[dependency-groups]
+dev = [
+  {include-group = "lint"},
+  {include-group = "test"},
+]
+
+lint = [
+  "ruff"
+]
+
+test = [
+  "pytest"
+]
+
+[project.urls]
+Repository = "https://forge.bearmine.com/bearmine/termtastic"
+
+[build-system]
+requires = ["uv_build>=0.12.9,<0.13.0"]
+build-backend = "uv_build"
+
+[tool.ruff.lint]
+extend-select = [
+    "F",        # Pyflakes rules
+    "W",        # PyCodeStyle warnings
+    "E",        # PyCodeStyle errors
+    "I",        # Sort imports properly
+    "UP",       # Warn if certain things can changed due to newer Python versions
+    "C4",       # Catch incorrect use of comprehensions, dict, list, etc
+    "FA",       # Enforce from __future__ import annotations
+    "ISC",      # Good use of string concatenation
+    "ICN",      # Use common import conventions
+    "RET",      # Good return practices
+    "SIM",      # Common simplification rules
+    "TID",      # Some good import practices
+    "TC",       # Enforce importing certain types in a TYPE_CHECKING block
+    "PTH",      # Use pathlib instead of os.path
+    "TD",       # Be diligent with TODO comments
+    "NPY",      # Some numpy-specific things
+    "FURB",     # Suggest more idiomatic Python patterns
+]
+
+ignore = [
+    "TD003", # Missing issue link TODOs
+]
+
+[tool.ruff.lint.pycodestyle]
+max-line-length = 100

termtastic-0.0.3/src/termtastic/__init__.py

@@ -0,0 +1 @@
+"""A fantastic set of terminal utilities for python"""

termtastic-0.0.3/src/termtastic/block_printer.py

@@ -0,0 +1,167 @@
+import io
+from abc import ABC, abstractmethod
+from contextlib import AbstractContextManager
+from types import TracebackType
+from typing import Self
+
+from termtastic import cursor
+from termtastic.protected_line_writer import ProtectedLineWriter
+
+
+class _AbstractBlockPrinter(ABC):
+    @abstractmethod
+    def print(self, *values, sep=" ", end="\n", flush=False):
+        """Print text into the block. Use this instead of normal print."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def replace(self, *values, sep=" ", end="\n", flush=False):
+        """Replace the current block text with the given text"""
+        raise NotImplementedError
+
+    def flush(self):
+        pass
+
+    @abstractmethod
+    def clear(self, flush=False):
+        """Clear all text from the block"""
+        raise NotImplementedError
+
+
+class _BufferedBlockPrinter(_AbstractBlockPrinter, AbstractContextManager):
+    def __init__(self, parent_printer: _AbstractBlockPrinter) -> None:
+        self._parent_printer = parent_printer
+        self._closed = False
+        self._buffer: io.StringIO = io.StringIO()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
+        self.close()
+
+    def _clear_buffer(self):
+        old_buffer = self._buffer
+        self._buffer = io.StringIO()
+        old_buffer.close()
+
+    def close(self):
+        if not self._closed:
+            self.flush()
+            self._buffer.close()
+            self._closed = True
+
+    def print(self, *values, sep=" ", end="\n", flush=False):
+        assert not self._closed, f"{self.__class__.__name__} is closed"
+        print(*values, sep=sep, end=end, file=self._buffer)
+        if flush:
+            self.flush()
+
+    def replace(self, *values, sep=" ", end="\n", flush=False):
+        # We don't need to worry about flickering at all like in BlockPrinter,
+        # so we can just clear and then call print.
+        self.clear()
+        self.print(*values, sep=sep, end=end, flush=flush)
+
+    def flush(self):
+        assert not self._closed, f"{self.__class__.__name__} is closed"
+        # We replace the block but do not clear the buffer as the user
+        # can still append additional text to the buffer
+        self._parent_printer.replace(self._buffer.getvalue(), end="", flush=True)
+
+    def clear(self, flush=False):
+        assert not self._closed, f"{self.__class__.__name__} is closed"
+        # Since we buffer and only write on flush, all we have to do is clear the buffer.
+        self._clear_buffer()
+        if flush:
+            self.flush()
+
+
+class BlockPrinter(_AbstractBlockPrinter, AbstractContextManager):
+    def __init__(self, *, debug=False) -> None:
+        self._protected_printer = ProtectedLineWriter(debug=debug)
+        self._closed = False
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
+        self.close()
+
+    def close(self):
+        if self._closed:
+            return
+        self._protected_printer.close()
+        self._closed = True
+
+    def print(self, *values, sep=" ", end="\n", flush=False):
+        assert not self._closed, f"{self.__class__.__name__} is closed"
+        print(*values, sep=sep, end=end, flush=flush, file=self._protected_printer)
+
+    def _reset_print(self, *values, sep=" ", end="\n", flush=False):
+        assert not self._closed, f"{self.__class__.__name__} is closed"
+        with self._protected_printer.lock():
+            self._protected_printer.reset()
+            print(*values, sep=sep, end=end, flush=flush, file=self._protected_printer)
+
+    def replace(self, *values, sep=" ", end="\n", flush=False):
+        assert not self._closed, f"{self.__class__.__name__} is closed"
+        with io.StringIO() as buffer:
+            # Return cursor to top of block
+            cursor.prev_line(self._protected_printer.protected_lines, file=buffer)
+
+            with io.StringIO() as str_io:
+                # Print given text into buffer
+                print(*values, sep=sep, end=end, file=str_io)
+
+                # Loop through lines clear then replace
+                str_io.seek(0)
+                for line in str_io.readlines():
+                    if line.endswith("\n"):
+                        print(line.rstrip("\r\n"), end="", file=buffer)
+                        cursor.erase_to_end_of_line(file=buffer)
+                        print(file=buffer)
+                    else:
+                        print(line, end="", file=buffer)
+                        cursor.erase_to_end_of_line(file=buffer)
+
+            # Clear rest of block
+            cursor.clear_screen_to_end(file=buffer)
+
+            # Reset the protected printer and print buffer
+            self._reset_print(buffer.getvalue(), end="", flush=flush)
+
+    def clear(self, flush=False):
+        assert not self._closed, f"{self.__class__.__name__} is closed"
+        with io.StringIO() as buffer:
+            # Return cursor to top of block
+            cursor.prev_line(self._protected_printer.protected_lines, file=buffer)
+            # Clear all text
+            cursor.clear_screen_to_end(file=buffer)
+
+            # Reset the protected printer and print buffer
+            self._reset_print(buffer.getvalue(), end="", flush=flush)
+
+    def replace_block(self) -> _BufferedBlockPrinter:
+        """
+        Returns a buffer that can be used to replace the block.
+        The replacement is printed all at once on flush or close.
+
+        This can reduce text flickering when replacing using multiple prints.
+
+        Returned buffer must be closed.
+
+        Using BlockPrinter while a buffer is open is undefined behavior.
+        """
+        assert not self._closed, f"{self.__class__.__name__} is closed"
+        return _BufferedBlockPrinter(self)

termtastic-0.0.3/src/termtastic/ctrlseq.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+
+class CtrlSeq:
+    def __init__(self, seq: str, param: None | str | int = None) -> None:
+        """Represents a terminal control sequence."""
+        self._seq = seq
+        self._param = "" if param is None else str(param)
+
+    def __call__(self, param: None | str | int) -> CtrlSeq:
+        """Set control sequence parameter"""
+        return CtrlSeq(self._seq, param)
+
+    def __str__(self) -> str:
+        return f"\033[{self._param}{self._seq}"
+
+    def __repr__(self) -> str:
+        return f"\\033[{self._param}{self._seq}"
+
+
+CUU = CtrlSeq("A")
+"""Cursor Up"""
+
+CUD = CtrlSeq("B")
+"""Cursor Down"""
+
+CUF = CtrlSeq("C")
+"""Cursor Forward"""
+
+CUB = CtrlSeq("D")
+"""Cursor Back"""
+
+CNL = CtrlSeq("E")
+"""Cursor Next Line"""
+
+CPL = CtrlSeq("F")
+"""Cursor Previous Line"""
+
+CHA = CtrlSeq("G")
+"""Cursor Horizontal Absolute"""
+
+CUP = CtrlSeq("H")
+"""Cursor Position"""
+
+ED = CtrlSeq("J")
+"""Erase in Display"""
+
+EL = CtrlSeq("K")
+"""Erase in Line"""
+
+SU = CtrlSeq("S")
+"""Scroll Up"""
+
+SD = CtrlSeq("T")
+"""Scroll Down"""
+
+HVP = CtrlSeq("f")
+"""Horizontal Vertical Position"""
+
+IL = CtrlSeq("L")
+"""Insert Line"""
+
+DL = CtrlSeq("M")
+"""Delete Lines"""
+
+DISPLAY_CURSOR = CtrlSeq("h")("?25")
+"""Make the cursor visible"""
+
+HIDE_CURSOR = CtrlSeq("l")("?25")
+"""Make the cursor invisible"""

termtastic-0.0.3/src/termtastic/cursor.py

@@ -0,0 +1,207 @@
+from contextlib import contextmanager
+
+from termtastic import ctrlseq
+
+
+def _clean_print(*values: object, sep=" ", file=None, flush=False):
+    print(*values, sep=sep, end="", file=file, flush=flush)
+
+
+def flush(file=None):
+    _clean_print("", file=file, flush=True)
+
+
+def forward(n: int, *, file=None):
+    """
+    Move cursor forwards the given number of columns
+
+    `n` must be positive
+    """
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CUF(n), file=file)
+
+
+def right(n: int, *, file=None):
+    """Alias for forward"""
+    forward(n, file=file)
+
+
+def back(n: int, *, file=None):
+    """
+    Move cursor back the given number of columns
+
+    `n` must be positive
+    """
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CUB(n), file=file)
+
+
+def left(n: int, *, file=None):
+    """Alias for back"""
+    back(n, file=file)
+
+
+def up(n: int, *, file=None):
+    """
+    Move cursor up the given number of lines
+
+    `n` must be positive
+    """
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CUU(n), file=file)
+
+
+def down(n: int, *, file=None):
+    """
+    Move cursor down the given number of lines
+
+    `n` must be positive
+    """
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CUD(n), file=file)
+
+
+def next_line(n: int, *, file=None):
+    """Move cursor to beginning of line n lines down"""
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CNL(n), file=file)
+
+
+def prev_line(n: int, *, file=None):
+    """Move cursor to beginning of line n lines up"""
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.CPL(n), file=file)
+
+
+def horizontal_absolute(column: int, *, file=None):
+    """1 based column position in the current row"""
+    _clean_print(ctrlseq.CHA(column), file=file)
+
+
+def position(row: int, column: int, *, file=None):
+    """Move cursor to the specified row and column (1 based)"""
+    _clean_print(ctrlseq.CUP(f"{row};{column}"), file=file)
+
+
+def erase_display(n: int | None = None, *, file=None):
+    """
+    Clears screen.
+
+    Accepted values are:
+
+    0 - Clear from cursor to end of screen (Default)</br>
+    1 - Clear from cursor to start of screen</br>
+    2 - Clear entire screen</br>
+    3 - Clear entire screen and scrollback buffer
+    """
+    _clean_print(ctrlseq.ED(n), file=file)
+
+
+def clear_screen_to_end(*, file=None):
+    erase_display(0, file=file)
+
+
+def clear_screen_to_start(*, file=None):
+    erase_display(1, file=file)
+
+
+def clear_screen(*, file=None):
+    erase_display(2, file=file)
+
+
+def clear_screen_and_scrollback(*, file=None):
+    erase_display(3, file=file)
+
+
+def erase_in_line(n: int | None = None, *, file=None):
+    """
+    Erases text in line. Cursor position does not change.
+
+    Accepted values are:
+
+    0 - Clear from cursor to end of line (Default)</br>
+    1 - Clear from cursor to beginning of line</br>
+    """
+    _clean_print(ctrlseq.EL(n), file=file)
+
+
+def erase_to_end_of_line(*, file=None):
+    erase_in_line(0, file=file)
+
+
+def erase_to_start_of_line(*, file=None):
+    erase_in_line(1, file=file)
+
+
+def scroll_up(n: int, *, file=None):
+    """Scroll whole page up by n lines. New lines are added at the bottom."""
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.SU(n), file=file)
+
+
+def scroll_down(n: int, *, file=None):
+    """Scroll whole page down by n lines. New lines are added at the top."""
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.SD(n), file=file)
+
+
+def horizontal_vertical_position(row: int, column: int, *, file=None):
+    _clean_print(ctrlseq.HVP(f"{row};{column}"))
+
+
+def insert_lines(n: int, *, file=None):
+    """
+    Insert `n` lines at current cursor position.
+
+    `n` must be positive
+    """
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.IL(n), file=file)
+
+
+def delete_lines(n: int, *, file=None):
+    """
+    Delete `n` lines at current cursor position.
+
+    `n` must be positive
+    """
+    assert n >= 0, "n must be positive"
+    if n > 0:
+        _clean_print(ctrlseq.DL(n), file=file)
+
+
+def enable_cursor(*, file=None):
+    """Enable display of cursor"""
+    _clean_print(ctrlseq.DISPLAY_CURSOR, file=file, flush=True)
+
+
+def disable_cursor(*, file=None):
+    """Disable display of cursor"""
+    _clean_print(ctrlseq.HIDE_CURSOR, file=file, flush=True)
+
+
+@contextmanager
+def show_cursor(*, file=None):
+    enable_cursor(file=file)
+    try:
+        yield
+    finally:
+        disable_cursor(file=file)
+
+
+@contextmanager
+def hide_cursor(*, file=None):
+    disable_cursor(file=file)
+    try:
+        yield
+    finally:
+        enable_cursor(file=file)

termtastic-0.0.3/src/termtastic/protected_line_writer.py

@@ -0,0 +1,350 @@
+import logging
+import math
+import shutil
+import sys
+import time
+from abc import abstractmethod
+from contextlib import AbstractContextManager, contextmanager
+from io import StringIO, TextIOBase
+from threading import RLock
+from types import TracebackType
+from typing import Literal, Self, TextIO
+
+from termtastic import cursor
+
+
+def _get_all_stream_handlers() -> set[logging.StreamHandler]:
+    handler_set: set[logging.StreamHandler] = set()
+    for handler in logging.root.handlers:
+        if isinstance(handler, logging.StreamHandler):
+            handler_set.add(handler)
+
+    children = logging.root.getChildren()
+
+    while children:
+        sub_children = set()
+        for child in children:
+            for handler in child.handlers:
+                if isinstance(handler, logging.StreamHandler):
+                    handler_set.add(handler)
+            sub_children.update(child.getChildren())
+        children = sub_children
+
+    return handler_set
+
+
+def _newlines_in_terminal(text: str, columns: int) -> int:
+    """
+    Return how many lines in a terminal with the given number of columns the given text will take up
+    """
+    if len(text) == 0:
+        return 0
+    newlines = text.count("\n")
+    for ln in text.splitlines():
+        newlines += math.floor(max(0, len(ln) - 1) / (columns))
+    return newlines
+
+
+class _StreamRedirect[T](AbstractContextManager):
+    def __init__(self, old_stream: T) -> None:
+        super().__init__()
+        self._old_stream: T = old_stream
+        self._closed = False
+
+    @property
+    def old_stream(self) -> T:
+        return self._old_stream
+
+    def close(self):
+        if self._closed:
+            return
+        self._close()
+        self._closed = True
+
+    @abstractmethod
+    def _close(self):
+        raise NotImplementedError
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> bool | None:
+        self.close()
+
+
+class _RedirectStreamHandler(_StreamRedirect):
+    def __init__(self, handler: logging.StreamHandler, stream: TextIOBase) -> None:
+        super().__init__(handler.setStream(stream))
+        self._handler = handler
+
+    def _close(self):
+        if self.old_stream:
+            self._handler.setStream(self.old_stream)
+
+
+class _RedirectStdout(_StreamRedirect[TextIO]):
+    def __init__(self, stream: TextIOBase) -> None:
+        """Redirect sys.stdout to the given stream"""
+        super().__init__(sys.stdout)
+        sys.stdout = stream
+
+    def _close(self):
+        sys.stdout = self.old_stream
+
+
+class _RedirectStderr(_StreamRedirect[TextIO]):
+    def __init__(self, stream: TextIOBase) -> None:
+        """Redirect sys.stderr to the given stream"""
+        super().__init__(sys.stderr)
+        sys.stderr = stream
+
+    def _close(self):
+        sys.stderr = self.old_stream
+
+
+class ProtectedLineWriter(TextIOBase, AbstractContextManager):
+    def __init__(
+        self,
+        io: TextIOBase | TextIO | None = None,
+        *,
+        redirect_stdout=True,
+        redirect_stderr=True,
+        redirect_logging=True,
+        debug=False,
+        debug_delay_sec=0.25,
+    ) -> None:
+        super().__init__()
+        self._io = io or sys.stdout
+        self._last_writer: TextIOBase | TextIO | None = None
+        self._protected_lines: int = 0
+        self._prev_line_len: int = 0
+        self._buffered_newline: bool = True
+        self._debug_delay_sec = debug_delay_sec
+        self._closed = False
+
+        # Print lock used for protecting against
+        # multithreaded print statements
+        self._print_lock = RLock()
+
+        # Setup redirects
+        writer_cls = (
+            _ProtectedRedirectWriterDEBUG if debug else _ProtectedRedirectWriter
+        )
+
+        self._redirects: list[_StreamRedirect[TextIO]] = []
+
+        if redirect_stdout:
+            self._stdout_writer = writer_cls(self, sys.stdout)
+            self._redirects.extend(
+                self._redirect_sys_stream(
+                    "stdout", self._stdout_writer, redirect_logging
+                )
+            )
+            self._stdout_writer.flush()
+        else:
+            self._stdout_writer = None
+
+        if redirect_stderr:
+            self._stderr_writer = writer_cls(self, sys.stderr)
+            self._redirects.extend(
+                self._redirect_sys_stream(
+                    "stderr", self._stderr_writer, redirect_logging
+                )
+            )
+            self._stderr_writer.flush()
+        else:
+            self._stderr_writer = None
+
+    def _redirect_sys_stream(
+        self,
+        sys_stream: Literal["stdout", "stderr"],
+        writer: TextIOBase,
+        redirect_logging: bool,
+    ) -> list[_StreamRedirect[TextIO]]:
+        if sys_stream == "stdout":
+            sys_redirect = _RedirectStdout(writer)
+        else:
+            sys_redirect = _RedirectStderr(writer)
+
+        stream_redirects: list[_StreamRedirect[TextIO]] = []
+        stream_redirects.append(sys_redirect)
+
+        if redirect_logging:
+            for handler in _get_all_stream_handlers():
+                if handler.stream is sys_redirect.old_stream:
+                    stream_redirects.append(_RedirectStreamHandler(handler, writer))
+
+        return stream_redirects
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    @contextmanager
+    def lock(self, writer: TextIO | TextIOBase | None = None):
+        """Acquire lock and flush previous writer if necessary"""
+        try:
+            self._print_lock.acquire()
+            if writer and self._last_writer and self._last_writer is not writer:
+                self._last_writer.flush()
+            yield
+        finally:
+            if writer:
+                self._last_writer = writer
+            self._print_lock.release()
+
+    @property
+    def protected_lines(self):
+        return self._protected_lines
+
+    def close(self):
+        if self._closed:
+            return
+
+        self.flush()
+
+        # Close all redirects
+        for redirect in self._redirects:
+            redirect.close()
+
+        # Close stdout and stderr writers
+        if self._stdout_writer:
+            self._stdout_writer.close()
+
+        if self._stderr_writer:
+            self._stderr_writer.close()
+
+        self._closed = True
+
+    def flush(self):
+        with self.lock(self._io):
+            self._io.flush()
+
+    def write(self, s: str) -> int:
+        assert not self._closed, f"{ProtectedLineWriter.__class__.__name__} is closed"
+        with self.lock(self._io):
+            # Add number of line breaks to protected lines
+            self._protected_lines += _newlines_in_terminal(
+                s, shutil.get_terminal_size().columns
+            )
+            self._io.write(s)
+        return len(s)
+
+    def reset(self):
+        with self.lock(self._io):
+            self._protected_lines = 0
+            self._prev_line_len = 0
+
+
+class _ProtectedRedirectWriter(TextIOBase, AbstractContextManager):
+    def __init__(
+        self,
+        printer: ProtectedLineWriter,
+        io: TextIOBase | TextIO,
+    ) -> None:
+        super().__init__()
+        self._printer = printer
+        self._io = io
+
+    def _debug_delay(self, buffer: StringIO):
+        return
+
+    def flush(self) -> None:
+        with self._printer.lock(self._io):
+            self._io.flush()
+
+    def close(self) -> None:
+        self.flush()
+
+    def _insert_lines(self, lines_to_insert: int, lines_up: int, buffer: StringIO):
+        # TODO(Bearmine): Has issues at edges of screen. i.e. if lines to insert is greats that
+        #       number of lines in the terminal
+
+        # Move all text up to make room for new lines
+        # If we don't do this we lose the text at the bottom of the terminal
+        print("\n" * lines_to_insert, end="", file=buffer)
+        # Move cursor up to position to insert
+        cursor.prev_line(lines_up + lines_to_insert, file=buffer)
+        # Insert blank lines (this will push existing text down)
+        cursor.insert_lines(lines_to_insert, file=buffer)
+
+    def write(self, s: str) -> int:
+        # Empty String
+        if not s:
+            return 0
+
+        # Write out string while protecting lines
+        with self._printer.lock(self._io):
+            with StringIO() as buffer:
+                term_size = shutil.get_terminal_size()
+                lines_to_insert = _newlines_in_terminal(
+                    s.rstrip("\r\n"), term_size.columns
+                )
+
+                if self._printer._buffered_newline:
+                    lines_to_insert += 1
+
+                self._insert_lines(
+                    lines_to_insert, self._printer.protected_lines, buffer=buffer
+                )
+                self._debug_delay(buffer)
+
+                # Move cursor up one because we should be 1 more line up
+                # before we print, as we are currently on a blank inserted line.
+                #
+                # We might actually be on a partial line.
+                cursor.prev_line(1, file=buffer)
+
+                # Move the cursor into position (end of last write)
+                cursor.forward(self._printer._prev_line_len, file=buffer)
+                self._debug_delay(buffer)
+
+                # Fill blank space with given text
+                if self._printer._buffered_newline:
+                    buffer.write("\n")
+                    self._printer._buffered_newline = False
+                buffer.write(s.rstrip("\r\n"))
+                self._debug_delay(buffer)
+
+                # Move back to bottom of terminal
+                cursor.next_line(self._printer._protected_lines + 1, file=buffer)
+                self._debug_delay(buffer)
+
+                # Track lines that don't end in newline so we can place the cursor correctly the
+                # next time a write occurs
+                if s.endswith("\n"):
+                    self._printer._prev_line_len = 0
+                    self._printer._buffered_newline = True
+                else:
+                    if lines_to_insert == 0:
+                        self._printer._prev_line_len += len(s) % term_size.columns
+                    else:
+                        self._printer._prev_line_len = (
+                            len(s.splitlines()[-1]) % term_size.columns
+                        )
+
+                # Write result
+                self._io.write(buffer.getvalue())
+
+            return len(s)
+
+
+class _ProtectedRedirectWriterDEBUG(_ProtectedRedirectWriter):
+    def _debug_delay(self, buffer: StringIO):
+        self._io.write(buffer.getvalue())
+        buffer.seek(0)
+        buffer.truncate()
+        self.flush()
+        time.sleep(self._printer._debug_delay_sec)