Lib/test/test_memoryio.py:1041

• Similarly, CStringIOPickleTest.test_newline_empty was removed rather than just un-xfailing it. Re-adding the override (without @expectedFailure) keeps the upstream test layout consistent and makes future syncs/conflict resolution easier.

    @unittest.expectedFailure  # TODO: RUSTPYTHON; +
    def test_issue5265(self):
        return super().test_issue5265()

    @unittest.expectedFailure  # TODO: RUSTPYTHON; ?                   ^^^^^

crates/vm/src/stdlib/_io.rs (2)

4467-4486: 🚀 Performance & Scalability | 🔵 Trivial | 🏗️ Heavy lift

read_size decodes the entire remaining buffer on every call — quadratic cost for line-by-line reads.

bytes spans from the current position to the end of the whole buffer, and Wtf8::from_bytes(bytes) validates/decodes all of it just to answer a bounded "how many bytes for size chars / until the next newline" question. Since read() and readline() both route through this, a common pattern like for line in string_io: degrades from ~O(total length) to ~O(total length²) on a large buffer, because each readline() call re-decodes everything after the current position instead of only the bytes needed to find the next boundary or satisfy size.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/vm/src/stdlib/_io.rs` around lines 4467 - 4486, Update read_size to
avoid constructing and decoding a Wtf8 value for the entire buffer remainder on
every call. Limit scanning to the bytes required to satisfy the requested size
or locate the next newline, while preserving the existing byte-count result and
handling invalid Wtf8 consistently. Keep the change scoped to read_size, which
serves both read and readline.

---

4440-4453: 🚀 Performance & Scalability | 🔵 Trivial | ⚡ Quick win

char_offset_to_byte always scans the whole buffer, even when the target is in range.

text.code_points().count() runs over the entire bytes slice unconditionally, before checking whether char_offset is actually in range. For the common case (char_offset < char_len), this makes every call O(buffer length) instead of O(char_offset). This function is on the hot path for seek(), truncate(), and __setstate__(), so seeking near the start of a large StringIO still costs a full-buffer scan.

⚡ Proposed fix: try the bounded conversion first

 fn char_offset_to_byte(
     bytes: &[u8],
     char_offset: usize,
     vm: &VirtualMachine,
 ) -> PyResult<usize> {
     let text = Wtf8::from_bytes(bytes)
         .ok_or_else(|| vm.new_value_error("Error Retrieving Value"))?;
-    let char_len = text.code_points().count();
-    if char_offset >= char_len {
-        return Ok(bytes.len() + (char_offset - char_len));
-    }
-    Ok(crate::common::str::codepoint_range_end(text, char_offset)
-        .expect("char_offset is within the string"))
+    match crate::common::str::codepoint_range_end(text, char_offset) {
+        Some(byte_pos) => Ok(byte_pos),
+        None => {
+            let char_len = text.code_points().count();
+            Ok(bytes.len() + (char_offset - char_len))
+        }
+    }
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@crates/vm/src/stdlib/_io.rs` around lines 4440 - 4453, Update
char_offset_to_byte to attempt codepoint_range_end(text, char_offset) before
scanning for the total code-point count, returning the bounded result when the
offset is in range. Only count code points after that attempt fails, then
preserve the existing bytes.len() plus overflow-offset behavior for out-of-range
offsets.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes