telnetlib3 5.0.0__tar.gz → 5.0.2__tar.gz

{telnetlib3-5.0.0 → telnetlib3-5.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: telnetlib3
-Version: 5.0.0
+Version: 5.0.2
 Summary:  Python Telnet server and client CLI and Protocol library
 Project-URL: Homepage, https://github.com/jquast/telnetlib3
 Project-URL: Documentation, https://telnetlib3.readthedocs.io

{telnetlib3-5.0.0 → telnetlib3-5.0.2}/docs/history.rst

@@ -1,6 +1,20 @@
 History
 =======
 
+5.0.2
+  * bugfix: :meth:`~telnetlib3.stream_reader.TelnetReaderUnicode.read`,
+    :meth:`~telnetlib3.stream_reader.TelnetReaderUnicode.readline`, and
+    :meth:`~telnetlib3.stream_reader.TelnetReaderUnicode.readexactly` returned incorrect text when
+    a multibyte sequence ended on a packet boundary, and dropped text retained by the incremental
+    decoder at end of stream.  ``readline()`` now finalizes a truncated character with the line it
+    belongs to, ``read(n)`` no longer returns more than *n* characters, and
+    ``encoding_errors="strict"`` raises :exc:`UnicodeDecodeError` at EOF.
+
+5.0.1
+  * bugfix: :func:`~telnetlib3.client.open_connection` raised ``AttributeError: 'NoneType' object
+    has no attribute 'isatty'`` in processes without a console, like ``pythonw.exe`` on Windows.
+
+
 5.0.0
   * changed: :meth:`~telnetlib3.stream_writer.TelnetWriter.handle_zmp` now receives ``command,
     *args`` instead of one ``parts`` list; ``zmp_data`` moved to ``writer.ctx`` and is now a dict
@@ -16,18 +30,17 @@ History
     ``always_do`` / ``passive_do``) used by downstream clients such as telix to accept them.  Note
     that MXP's negotiation direction is server-sends-``DO`` (the LPMud family convention, e.g.
     Discworld), so a client accepting MXP replies ``WILL`` to ``IAC DO MXP``.
+  * new: :meth:`~telnetlib3.stream_writer.TelnetWriter.add_will_callback` and
     :meth:`~telnetlib3.stream_writer.TelnetWriter.remove_will_callback` for per-option callbacks
     invoked after :meth:`~telnetlib3.stream_writer.TelnetWriter.handle_will` negotiation.  Replaces
-    the previous
-    closure-wrapping pattern in :class:`~telnetlib3.client.TelnetClient` for GMCP, ZMP, and CHARSET
-    will-detection.
+    the previous closure-wrapping pattern in :class:`~telnetlib3.client.TelnetClient` for GMCP, ZMP,
+    and CHARSET will-detection.
   * enhancement: ``telnetlib3-fingerprint`` now accepts all MUD protocol offers (ATCP, AARDWOLF,
     MSP, MXP, MSDP, MSSP) to collect subnegotiation data.
   * enhancement: sub-negotiation payloads are bounded to 1,000KB.
   * enhancement: ``--loglevel=trace`` receive dumps show the decompressed telnet stream (MCCP2,
     MCCP3) instead of raw compressed bytes.
   * bugfix: ``IAC SB IAC SE`` (sub-negotiation with no option byte) should not raise ``IndexError``
-  * new: :meth:`~telnetlib3.stream_writer.TelnetWriter.add_will_callback` and
 
 
 4.0.6

{telnetlib3-5.0.0 → telnetlib3-5.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "telnetlib3"
-version = "5.0.0"  # Keep in sync with telnetlib3/accessories.py::get_version !
+version = "5.0.2"  # Keep in sync with telnetlib3/accessories.py::get_version !
 description = " Python Telnet server and client CLI and Protocol library"
 readme = "README.rst"
 license = "ISC"

{telnetlib3-5.0.0 → telnetlib3-5.0.2}/telnetlib3/accessories.py

@@ -3,6 +3,8 @@
 from __future__ import annotations
 
 # std imports
+import os
+import sys
 import shlex
 import asyncio
 import logging
@@ -26,6 +28,7 @@ __all__ = (
     "repr_mapping",
     "function_lookup",
     "make_reader_task",
+    "is_a_tty",
 )
 
 PATIENCE_MESSAGES = [
@@ -42,7 +45,7 @@ PATIENCE_MESSAGES = [
 
 def get_version() -> str:
     """Return the current version of telnetlib3."""
-    return "5.0.0"  # keep in sync with pyproject.toml !
+    return "5.0.2"  # keep in sync with pyproject.toml !
 
 
 def encoding_from_lang(lang: str) -> Optional[str]:
@@ -172,3 +175,32 @@ def make_reader_task(
 ) -> "asyncio.Task[Any]":
     """Return asyncio task wrapping coroutine of reader.read(size)."""
     return asyncio.ensure_future(reader.read(size))
+
+
+def is_a_tty() -> bool:
+    """
+    Whether an interactive terminal is available on standard input.
+
+    This is a more conservative test than ``sys.stdin.isatty()``: the standard
+    streams may be ``None`` (running under ``pythonw.exe`` on Windows, or any
+    process launched without a console), replaced by an object without a
+    working :meth:`~io.IOBase.isatty` or :meth:`~io.IOBase.fileno` (test
+    harnesses, GUI frameworks), or detached.  A real file descriptor is
+    required, because terminal features such as window size and raw mode are
+    performed against ``sys.stdin.fileno()``.
+
+    :returns: ``True`` only when stdin is a terminal backed by a file
+        descriptor.
+    """
+    stdin = sys.stdin
+    if stdin is None:
+        return False
+    try:
+        if not stdin.isatty():
+            return False
+        return os.isatty(stdin.fileno())
+    except (AttributeError, ValueError, OSError):
+        # AttributeError: stream without isatty/fileno,
+        # ValueError: closed or detached stream,
+        # OSError: fileno() unsupported by the underlying object.
+        return False

{telnetlib3-5.0.0 → telnetlib3-5.0.2}/telnetlib3/client.py

@@ -577,7 +577,9 @@ async def open_connection(
     :param port: Remote Internet host TCP port.
     :param client_factory: Client connection class factory.  When ``None``,
         :class:`TelnetTerminalClient` is used when *stdin* is attached to a
-        terminal, :class:`TelnetClient` otherwise.
+        terminal, :class:`TelnetClient` otherwise.  Processes without a
+        console, such as those launched by ``pythonw.exe`` on Windows, where
+        ``sys.stdin`` is ``None``, always receive :class:`TelnetClient`.
     :param family: Same meaning as
         :meth:`asyncio.loop.create_connection`.
     :param flags: Same meaning as
@@ -643,7 +645,7 @@ async def open_connection(
     """
     if client_factory is None:
         client_factory = TelnetClient
-        if sys.stdin.isatty():
+        if accessories.is_a_tty():
             client_factory = TelnetTerminalClient
 
     def connection_factory() -> client_base.BaseClient:
@@ -724,7 +726,7 @@ async def run_client() -> None:
     def _client_factory(**kwargs: Any) -> client_base.BaseClient:
         client: TelnetClient
         kwargs["gmcp_modules"] = gmcp_modules
-        if sys.stdin.isatty():
+        if accessories.is_a_tty():
             client = TelnetTerminalClient(**kwargs)
         else:
             client = TelnetClient(**kwargs)

{telnetlib3-5.0.0 → telnetlib3-5.0.2}/telnetlib3/guard_shells.py

@@ -110,7 +110,11 @@ async def _read_line_inner(reader: Union[TelnetReader, TelnetReaderUnicode], max
     """Inner loop for _read_line, separated for wait_for compatibility."""
     buf = ""
     while len(buf) < max_len:
-        char = await reader.read(1)
+        try:
+            char = await reader.read(1)
+        except UnicodeDecodeError:
+            # An incomplete character at end of stream is end of input, as with EOF.
+            break
         if not char:
             break
         if isinstance(char, bytes):

{telnetlib3-5.0.0 → telnetlib3-5.0.2}/telnetlib3/server_shell.py

@@ -67,7 +67,11 @@ async def filter_ansi(
         return reader.read(1)
 
     async def _next() -> str:
-        ch = await _rch()
+        try:
+            ch = await _rch()
+        except UnicodeDecodeError:
+            # An incomplete character at end of stream is end of input, as with EOF.
+            return ""
         if not ch:
             return ""
         return ch.decode("latin-1") if binary else ch  # type: ignore[return-value]

{telnetlib3-5.0.0 → telnetlib3-5.0.2}/telnetlib3/stream_reader.py

@@ -564,6 +564,11 @@ class TelnetReaderUnicode(TelnetReader):
     #: practice, however.
     _decoder = None
 
+    #: Characters finalized from bytes retained by :attr:`_decoder` at end of
+    #: stream, held back when :meth:`read` requested fewer.  Only ever set once
+    #: :attr:`_buffer` is empty, so these are always the last of the stream.
+    _pending = ""
+
     def __init__(
         self,
         fn_encoding: Callable[..., str],
@@ -584,8 +589,13 @@ class TelnetReaderUnicode(TelnetReader):
         self.encoding_errors = encoding_errors
 
     def decode(self, buf: bytes, final: bool = False) -> str:
-        """Decode bytes ``buf`` using preferred encoding."""
-        if buf == b"":
+        """
+        Decode bytes ``buf`` using preferred encoding.
+
+        :param final: When True, bytes retained by the incremental decoder are decoded as the end
+            of the stream, applying ``encoding_errors`` to an incomplete character.
+        """
+        if buf == b"" and (not final or self._decoder is None):
             return ""  # EOF
 
         encoding = self.fn_encoding(incoming=True)
@@ -597,20 +607,53 @@ class TelnetReaderUnicode(TelnetReader):
 
         return self._decoder.decode(buf, final)
 
+    def _finalize_decoder(self, n: int = -1) -> str:
+        """
+        Decode and return bytes retained by the incremental decoder at end of stream.
+
+        Characters decoded beyond *n* are held in :attr:`_pending` for the next read, so that
+        :meth:`read` never returns more characters than requested.
+        """
+        if self._decoder is None:
+            return ""
+
+        u_data = self.decode(b"", final=True)
+        if n < 0 or len(u_data) <= n:
+            return u_data
+
+        self._pending = u_data[n:]
+        return u_data[:n]
+
+    def at_eof(self) -> bool:
+        """Return True if the buffer is empty, nothing is pending, and 'feed_eof' was called."""
+        return self._eof and not self._buffer and not self._pending
+
     async def readline(self) -> str:  # type: ignore[override]
         """
         Read one line.
 
-        See ancestor method, :func:`~TelnetReader.readline` for details.
+        See ancestor method, :func:`~TelnetReader.readline` for details. When the returned bytes
+        are the last of the stream, an incomplete character retained by the incremental decoder is
+        finalized, applying ``encoding_errors``.
+
+        :raises UnicodeDecodeError: if ``encoding_errors`` is ``"strict"`` and the stream
+            ends with an incomplete character.
         """
+        if self._pending:
+            line, self._pending = self._pending, ""
+            return line
+
         buf = await super().readline()
-        return self.decode(buf)
+        return self.decode(buf, final=self._eof and not self._buffer)
 
     async def read(self, n: int = -1) -> str:  # type: ignore[override]
         """
-        Read up to *n* bytes.
+        Read up to *n* characters.
 
-        If the EOF was received and the internal buffer is empty, return an empty string.
+        If the EOF was received and no characters remain, return an empty string. Bytes retained
+        by the incremental decoder are finalized at end of stream, applying
+        ``encoding_errors`` to an incomplete character: ``"strict"`` raises
+        :exc:`UnicodeDecodeError`.
 
         :param n: If *n* is not provided, or set to -1, read until EOF and return all characters as
             one large string.
@@ -621,6 +664,11 @@ class TelnetReaderUnicode(TelnetReader):
         if not n:
             return ""
 
+        if self._pending and n > 0:
+            u_data = self._pending[:n]
+            self._pending = self._pending[n:]
+            return u_data
+
         if n < 0:
             # This used to just loop creating a new waiter hoping to
             # collect everything in self._buffer, but that would
@@ -635,20 +683,35 @@ class TelnetReaderUnicode(TelnetReader):
                 blocks.append(block)
             return "".join(blocks)
 
-        if not self._buffer and not self._eof:
-            await self._wait_for_data("read")
-
-        buf = self.decode(bytes(self._buffer))
-        if n < 0 or len(buf) <= n:
-            u_data = buf
-            self._buffer.clear()
-        else:
-            u_data = ""
-            while n > len(u_data):
-                u_data += self.decode(bytes([self._buffer.pop(0)]))
-
-        self._maybe_resume_transport()
-        return u_data
+        while True:
+            if self._exception is not None:
+                raise self._exception
+            if not self._buffer and not self._eof:
+                await self._wait_for_data("read")
+
+            decoder = self._decoder
+            decoder_state = decoder.getstate() if decoder is not None else None
+            buf = self.decode(bytes(self._buffer))
+            if len(buf) <= n:
+                u_data = buf
+                self._buffer.clear()
+            else:
+                # The probe decoded bytes that remain buffered. Restore the
+                # decoder before consuming only the requested characters.
+                if self._decoder is decoder and decoder_state is not None:
+                    self._decoder.setstate(decoder_state)
+                else:
+                    self._decoder.reset()
+                u_data = ""
+                while n > len(u_data):
+                    u_data += self.decode(bytes([self._buffer.pop(0)]))
+
+            self._maybe_resume_transport()
+            if u_data:
+                return u_data
+            if self._eof:
+                return self._finalize_decoder(n)
+            # A partial character is not EOF: wait for the rest of the character.
 
     async def readexactly(self, n: int) -> str:  # type: ignore[override]
         """
@@ -658,6 +721,8 @@ class TelnetReaderUnicode(TelnetReader):
             reached before *n* can be read. The
             :attr:`asyncio.IncompleteReadError.partial` attribute of the
             exception contains the partial read characters.
+        :raises UnicodeDecodeError: if ``encoding_errors`` is ``"strict"`` and the stream
+            ends with an incomplete character.
         """
         if self._exception is not None:
             raise self._exception

{telnetlib3-5.0.0 → telnetlib3-5.0.2}/telnetlib3/tests/test_client_unit.py

@@ -1,4 +1,6 @@
 # std imports
+import io
+import os
 import sys
 import types
 import asyncio
@@ -224,7 +226,7 @@ def test_transform_args_typescript():
 
 @pytest.mark.asyncio
 async def test_open_connection_default_factory(bind_host, unused_tcp_port, monkeypatch):
-    monkeypatch.setattr(sys.stdin, "isatty", lambda: False)
+    monkeypatch.setattr(cl.accessories, "is_a_tty", lambda: False)
 
     async with create_server(host=bind_host, port=unused_tcp_port, connect_maxwait=0.5):
         reader, writer = await cl.open_connection(
@@ -235,10 +237,9 @@ async def test_open_connection_default_factory(bind_host, unused_tcp_port, monke
         writer.close()
 
 
-@pytest.mark.skipif(sys.platform == "win32", reason="TTY factory not used on win32")
 @pytest.mark.asyncio
 async def test_open_connection_tty_factory(bind_host, unused_tcp_port, monkeypatch):
-    monkeypatch.setattr(sys.stdin, "isatty", lambda: True)
+    monkeypatch.setattr(cl.accessories, "is_a_tty", lambda: True)
 
     async with create_server(host=bind_host, port=unused_tcp_port, connect_maxwait=0.5):
         reader, writer = await cl.open_connection(
@@ -248,6 +249,76 @@ async def test_open_connection_tty_factory(bind_host, unused_tcp_port, monkeypat
         writer.close()
 
 
+@pytest.mark.asyncio
+async def test_open_connection_without_stdin(bind_host, unused_tcp_port, monkeypatch):
+    """Processes without a console, sys.stdin is None, such as pythonw.exe."""
+    monkeypatch.setattr(sys, "stdin", None)
+
+    async with create_server(host=bind_host, port=unused_tcp_port, connect_maxwait=0.5):
+        reader, writer = await cl.open_connection(
+            host=bind_host, port=unused_tcp_port, connect_maxwait=0.1, encoding=False
+        )
+        assert isinstance(writer.protocol, cl.TelnetClient)
+        assert not isinstance(writer.protocol, cl.TelnetTerminalClient)
+        writer.close()
+
+
+def test_is_a_tty_without_stdin(monkeypatch):
+    monkeypatch.setattr(sys, "stdin", None)
+    assert accessories.is_a_tty() is False
+
+
+def test_is_a_tty_stdin_without_isatty(monkeypatch):
+    monkeypatch.setattr(sys, "stdin", object())
+    assert accessories.is_a_tty() is False
+
+
+def test_is_a_tty_stdin_not_a_tty(monkeypatch):
+    monkeypatch.setattr(sys, "stdin", io.StringIO())
+    assert accessories.is_a_tty() is False
+
+
+def test_is_a_tty_stdin_detached(monkeypatch):
+    class _Detached:
+        def isatty(self):
+            return True
+
+        def fileno(self):
+            raise ValueError("underlying buffer has been detached")
+
+    monkeypatch.setattr(sys, "stdin", _Detached())
+    assert accessories.is_a_tty() is False
+
+
+def test_is_a_tty_stdin_unsupported_fileno(monkeypatch):
+    class _NoFileno:
+        def isatty(self):
+            return True
+
+    monkeypatch.setattr(sys, "stdin", _NoFileno())
+    assert accessories.is_a_tty() is False
+
+
+def test_is_a_tty_stdin_is_a_tty(monkeypatch):
+    class _Tty:
+        def isatty(self):
+            return True
+
+        def fileno(self):
+            # a file descriptor that os.isatty() agrees is a terminal
+            return _Tty.fd
+
+    pty = pytest.importorskip("pty")
+    master_fd, slave_fd = pty.openpty()
+    _Tty.fd = slave_fd
+    try:
+        monkeypatch.setattr(sys, "stdin", _Tty())
+        assert accessories.is_a_tty() is True
+    finally:
+        os.close(slave_fd)
+        os.close(master_fd)
+
+
 def test_detect_syncterm_font_sets_force_binary():
     client = BaseClient.__new__(BaseClient)
     client.log = types.SimpleNamespace(debug=lambda *a, **kw: None, isEnabledFor=lambda _: False)

{telnetlib3-5.0.0 → telnetlib3-5.0.2}/telnetlib3/tests/test_reader.py

@@ -425,3 +425,126 @@ async def test_telnet_reader_readuntil_pattern_cancelled_error(bind_host, unused
             client_reader.set_exception(asyncio.CancelledError())
             with pytest.raises(asyncio.CancelledError):
                 await client_reader.readuntil_pattern(pattern)
+
+
+@pytest.mark.parametrize("encoding", ["utf-8", "utf-16", "iso2022_jp"])
+async def test_unicode_read_preserves_decoder_state(encoding):
+    """A size probe must not decode still-buffered bytes twice."""
+    reader = telnetlib3.TelnetReaderUnicode(fn_encoding=lambda **_: encoding)
+    given = "abc€" if encoding != "iso2022_jp" else "abc日本語"
+    encoded = given.encode(encoding)
+    reader.feed_data(encoded[:-1])
+    assert await reader.read(1) == "a"
+    assert await reader.read(1) == "b"
+    reader.feed_data(encoded[-1:])
+    reader.feed_eof()
+    assert await reader.read() == given[2:]
+    assert await reader.read() == ""
+
+
+@pytest.mark.parametrize("method", ["read", "readexactly"])
+async def test_unicode_read_waits_for_split_character(method):
+    """A partial multibyte character must not look like end of stream."""
+    reader = telnetlib3.TelnetReaderUnicode(fn_encoding=lambda **_: "utf-8")
+    reader.feed_data(b"\xe2")
+    task = asyncio.create_task(getattr(reader, method)(1))
+    asyncio.get_running_loop().call_soon(reader.feed_data, b"\x82\xac")
+    assert await asyncio.wait_for(task, 1) == "€"
+
+
+@pytest.mark.parametrize(
+    "method, args, data, errors, expected",
+    [
+        ("read", (), b"ab\xe2", "replace", "ab�"),
+        ("read", (), b"ab\xe2", "ignore", "ab"),
+        ("read", (), b"ab\xe2", "strict", UnicodeDecodeError),
+        ("readline", (), b"ab\xe2", "replace", "ab�"),
+        ("readline", (), b"ab\xe2", "ignore", "ab"),
+        ("readline", (), b"ab\xe2", "strict", UnicodeDecodeError),
+        ("readexactly", (3,), b"ab\xe2", "replace", "ab�"),
+        ("readexactly", (3,), b"ab\xe2", "ignore", asyncio.IncompleteReadError),
+        ("readexactly", (1,), b"\xe2", "strict", UnicodeDecodeError),
+        ("read", (), b"", "replace", ""),
+    ],
+)
+async def test_unicode_finalizes_trailing_character(method, args, data, errors, expected):
+    """The character that ends the stream is decoded once by the configured error policy."""
+    reader = telnetlib3.TelnetReaderUnicode(fn_encoding=lambda **_: "utf-8", encoding_errors=errors)
+    reader.feed_data(data)
+    reader.feed_eof()
+    if not isinstance(expected, str):
+        with pytest.raises(expected):
+            await getattr(reader, method)(*args)
+        return
+    assert await getattr(reader, method)(*args) == expected
+    assert await reader.read() == ""
+
+
+async def test_unicode_readline_finalizes_only_last_line():
+    """Only the last of the buffered lines is decoded as end of stream."""
+    reader = telnetlib3.TelnetReaderUnicode(fn_encoding=lambda **_: "utf-8")
+    reader.feed_data(b"one\ntwo\xe2")
+    reader.feed_eof()
+    assert [await reader.readline() for _ in range(3)] == ["one\n", "two�", ""]
+
+
+async def test_unicode_read_split_character_over_connection(bind_host, unused_tcp_port):
+    """Read-size probes preserve UTF-8 across separate Telnet network writes."""
+
+    async def shell(reader, writer):
+        writer.write(b"abc\xe2")
+        await writer.drain()
+        assert await reader.readexactly(1) == b"!"
+        writer.write(b"\x82\xac")
+        writer.close()
+
+    async with create_server(host=bind_host, port=unused_tcp_port, shell=shell, encoding=False):
+        async with open_connection(host=bind_host, port=unused_tcp_port, encoding="utf-8") as (
+            client_reader,
+            client_writer,
+        ):
+            assert await asyncio.wait_for(client_reader.read(1), 1) == "a"
+            client_writer.write("!")
+            await client_writer.drain()
+            assert await asyncio.wait_for(client_reader.read(), 1) == "bc€"
+
+
+async def test_unicode_read_partial_character_then_connection_error():
+    """A reset immediately after a partial character must wake the read caller."""
+    reader = telnetlib3.TelnetReaderUnicode(fn_encoding=lambda **_: "utf-8")
+    task = asyncio.create_task(reader.read(1))
+    await asyncio.sleep(0)
+    assert reader._waiter is not None
+    reader.feed_data(b"\xe2")
+    reader.set_exception(ConnectionResetError("connection reset"))
+    with pytest.raises(ConnectionResetError, match="connection reset"):
+        await asyncio.wait_for(task, 1)
+
+
+async def test_unicode_read_cancelled_partial_character():
+    """Cancellation leaves the partial decoder state usable by the next reader."""
+    reader = telnetlib3.TelnetReaderUnicode(fn_encoding=lambda **_: "utf-8")
+    reader.feed_data(b"\xe2")
+    task = asyncio.create_task(reader.read(1))
+    await asyncio.sleep(0)
+    assert not task.done()
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await task
+    asyncio.get_running_loop().call_soon(reader.feed_data, b"\x82\xac")
+    assert await asyncio.wait_for(reader.read(1), 1) == "€"
+
+
+@pytest.mark.parametrize("method, args", [("read", (1,)), ("readline", ())])
+async def test_unicode_read_holds_back_finalized_characters(method, args):
+    """A sized read holds back characters decoded past the request."""
+    reader = telnetlib3.TelnetReaderUnicode(
+        fn_encoding=lambda **_: "utf-8", encoding_errors="surrogateescape"
+    )
+    reader.feed_data(b"a\xe2\x82")
+    reader.feed_eof()
+    assert await reader.read(1) == "a"
+    assert await reader.read(1) == "\udce2"
+    assert not reader.at_eof()
+    assert await getattr(reader, method)(*args) == "\udc82"
+    assert reader.at_eof()

{telnetlib3-5.0.0 → telnetlib3-5.0.2}/telnetlib3/tests/test_server_shell_unit.py

@@ -43,6 +43,8 @@ def _run_readline(sequence, max_visible_width=0):
 
 
 class MockReader:
+    """Reader of one character per call; a ``None`` entry raises UnicodeDecodeError."""
+
     is_binary_reader = False
 
     def __init__(self, data):
@@ -54,6 +56,8 @@ class MockReader:
             return ""
         result = self._data[self._idx]
         self._idx += 1
+        if result is None:
+            raise UnicodeDecodeError("utf-8", b"\xe2", 0, 1, "unexpected end of data")
         return result
 
 
@@ -225,6 +229,11 @@ async def test_read_line_inner(input_data, max_len, expected):
     assert await gs._read_line_inner(MockReader(list(input_data)), max_len) == expected
 
 
+@pytest.mark.asyncio
+async def test_read_line_inner_truncated_character_at_eof():
+    assert await gs._read_line_inner(MockReader(["h", "i", None]), 100) == "hi"
+
+
 @pytest.mark.asyncio
 async def test_read_line_with_timeout():
     assert await gs._read_line(MockReader(list("hello\r")), timeout=5.0) == "hello"
@@ -710,6 +719,19 @@ async def test_filter_ansi_esc_then_eof():
     assert not result
 
 
+@pytest.mark.parametrize(
+    "input_chars,expected",
+    [
+        pytest.param(["a", None], "a", id="after_character"),
+        pytest.param([None], "", id="immediately"),
+        pytest.param(["\x1b", None], "", id="esc_then_eof"),
+    ],
+)
+@pytest.mark.asyncio
+async def test_filter_ansi_truncated_character_at_eof(input_chars, expected):
+    assert await ss.filter_ansi(MockReader(input_chars), MockWriter()) == expected
+
+
 class MockBinaryReader:
     is_binary_reader = True