gh-133492: Add readinto to typing.BinaryIO and widen its write signatures

Doc/library/typing.rst

@@ -3027,6 +3027,10 @@ ABCs and Protocols for working with I/O
    :func:`open`. Please note that these classes are not protocols, and
    their interface is fairly broad.
 
+   .. versionchanged:: next
+      ``BinaryIO`` now declares a ``readinto()`` method, matching the binary
+      streams that :func:`open` returns.
+
 The protocols :class:`io.Reader` and :class:`io.Writer` offer a simpler
 alternative for argument types, when only the ``read()`` or ``write()``
 methods are accessed, respectively::

Lib/test/test_typing.py

@@ -9660,6 +9660,29 @@ def stuff(a: BinaryIO) -> bytes:
         a = stuff.__annotations__['a']
         self.assertEqual(a.__parameters__, ())
 
+    def test_write_annotations(self):
+        # These are evaluated lazily, so a wrong name in any of them would
+        # stay invisible until something introspects the stub.  Compare the
+        # whole mapping so that a dropped or stray annotation shows up too.
+        self.assertEqual(
+            IO.writelines.__annotations__,
+            {'lines': collections.abc.Iterable[AnyStr], 'return': None})
+        self.assertEqual(
+            BinaryIO.write.__annotations__,
+            {'s': collections.abc.Buffer, 'return': int})
+        self.assertEqual(
+            BinaryIO.writelines.__annotations__,
+            {'lines': collections.abc.Iterable[collections.abc.Buffer],
+             'return': None})
+
+    def test_binaryio_readinto(self):
+        # Every class typeshed marks as a BinaryIO has readinto(), so the
+        # runtime stub declares it as well.
+        self.assertTrue(BinaryIO.readinto.__isabstractmethod__)
+        self.assertEqual(
+            BinaryIO.readinto.__annotations__,
+            {'buffer': collections.abc.Buffer, 'return': int})
+
 
 class RETests(BaseTestCase):
     # Much of this is really testing _TypeAlias.

Lib/typing.py

@@ -3636,7 +3636,7 @@ def write(self, s: AnyStr, /) -> int:
         pass
 
     @abstractmethod
-    def writelines(self, lines: list[AnyStr], /) -> None:
+    def writelines(self, lines: collections.abc.Iterable[AnyStr], /) -> None:
         pass
 
     @abstractmethod
@@ -3654,7 +3654,17 @@ class BinaryIO(IO[bytes]):
     __slots__ = ()
 
     @abstractmethod
-    def write(self, s: bytes | bytearray, /) -> int:
+    def readinto(self, buffer: collections.abc.Buffer, /) -> int:
+        pass
+
+    @abstractmethod
+    def write(self, s: collections.abc.Buffer, /) -> int:
+        pass
+
+    @abstractmethod
+    def writelines(
+        self, lines: collections.abc.Iterable[collections.abc.Buffer], /
+    ) -> None:
         pass
 
     @abstractmethod

Misc/NEWS.d/next/Library/2026-09-24-23-22-01.gh-issue-133492.-bKR-v.rst

@@ -0,0 +1,5 @@
+:class:`typing.BinaryIO` now annotates ``write()`` and ``writelines()`` in
+terms of :class:`collections.abc.Buffer` rather than :class:`bytes`, and
+``writelines()`` on :class:`typing.IO` takes any iterable rather than a list.
+Binary streams accept all of this already, and typeshed says the same through
+overloads that a runtime stub has no way to spell.

Misc/NEWS.d/next/Library/2026-09-24-23-23-48.gh-issue-133492.9Yd4xo.rst

@@ -0,0 +1,4 @@
+:class:`typing.BinaryIO` now declares a ``readinto()`` method.  Every class
+that typeshed marks as inheriting from ``BinaryIO`` provides it, in
+:class:`codecs.StreamRecoder`'s case through ``__getattr__``, so the runtime
+stub was missing a method the type describes.