Refuse array.frombytes() a source whose items are not bytes

frombytes() reads its argument as bytes, but accepted any contiguous buffer, so array("i").frombytes(memoryview(array("d", [1.0]))) appended a double's bytes read as ints instead of raising. array_array_frombytes_impl requires an itemsize of 1; ArgBytesLike now reports the itemsize so the same check can be made here. The BufferError that a resize meets while the array is exported also names the array rather than repeating bytearray's wording. stdlib_array.py's frombytes-of-itself case used typecode "i", where the new check answers before the resize guard is reached; it uses "b" so the guard is what refuses, and asserts the wider case separately. Assisted-by: Claude
youknowone · Aug 16, 2026 · Aug 14, 2026 · Aug 14, 2026 · Aug 14, 2026 · Aug 14, 2026
commit ab0d4ff8c0ca49c639ba402ef9018cb611782ca3
diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
@@ -925,6 +925,11 @@ pub mod array {
 
         #[pymethod]
         fn frombytes(&self, b: ArgBytesLike, vm: &VirtualMachine) -> PyResult<()> {
+            // The source is read as bytes, so items of any other width would
+            // be reinterpreted rather than appended.
+            if b.itemsize() != 1 {
+                return Err(vm.new_type_error("a bytes-like object is required"));
+            }
             let b = b.borrow_buf();
             let itemsize = self.read().itemsize();
             self._from_bytes(&b, itemsize, vm)
@@ -1472,6 +1477,12 @@ pub mod array {
             // answered before the lock rather than by waiting on it.
             (self.exports.load(atomic::Ordering::SeqCst) == 0).then(|| self.write())
         }
+
+        fn try_resizable(&self, vm: &VirtualMachine) -> PyResult<Self::Resizable<'_>> {
+            self.try_resizable_opt().ok_or_else(|| {
+                vm.new_buffer_error("cannot resize an array that is exporting buffers")
+            })
+        }
     }
 
     #[pyattr]

diff --git a/crates/vm/src/function/buffer.rs b/crates/vm/src/function/buffer.rs
@@ -76,6 +76,14 @@ impl ArgBytesLike {
         self.0.desc.len
     }
 
+    /// The width of one item. Callers that read the buffer as bytes rather
+    /// than as whatever it holds have to ask, since a contiguous buffer of
+    /// wider items is contiguous all the same.
+    #[must_use]
+    pub const fn itemsize(&self) -> usize {
+        self.0.desc.itemsize
+    }
+
     #[must_use]
     pub const fn is_empty(&self) -> bool {
         self.len() == 0

diff --git a/extra_tests/snippets/stdlib_array.py b/extra_tests/snippets/stdlib_array.py
@@ -163,15 +163,16 @@ def __index__(self):
 
 
 def test_frombytes_of_itself():
-    # Resizing is refused while a buffer is exported, before any lock is taken
-    a = array("i", [1, 2, 3])
+    # Resizing is refused while a buffer is exported, before any lock is taken.
+    # The typecode is "b" so the view's items are bytes and the resize is what
+    # the call is refused for.
+    a = array("b", [1, 2, 3])
     m = memoryview(a)
-    try:
+    with assert_raises(BufferError):
         a.frombytes(m)
-    except (BufferError, TypeError):
-        # Refused either as a resize while exported or as a buffer whose
-        # items are not bytes; which one comes first is not the point here.
-        pass
-    else:
-        raise AssertionError("frombytes of its own exported buffer should be refused")
     del m
+
+    # A view of wider items is not a source of bytes at all.
+    wide = array("i", [1, 2, 3])
+    with assert_raises(TypeError):
+        wide.frombytes(memoryview(wide))