progress

Include/internal/pycore_global_strings.h

@@ -173,7 +173,7 @@ struct _Py_global_strings {
         STRUCT_FOR_ID(__rdivmod__)
         STRUCT_FOR_ID(__reduce__)
         STRUCT_FOR_ID(__reduce_ex__)
-        STRUCT_FOR_ID(__release_buffer__) 
+        STRUCT_FOR_ID(__release_buffer__)
         STRUCT_FOR_ID(__repr__)
         STRUCT_FOR_ID(__reversed__)
         STRUCT_FOR_ID(__rfloordiv__)

Include/internal/pycore_memoryobject.h

@@ -0,0 +1,17 @@
+#ifndef Py_INTERNAL_MEMORYOBJECT_H
+#define Py_INTERNAL_MEMORYOBJECT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+PyObject *
+PyMemoryView_FromObjectAndFlags(PyObject *v, int flags);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_MEMORYOBJECT_H */

Lib/test/test_buffer.py

@@ -4436,5 +4436,56 @@ def test_pybuffer_size_from_format(self):
                              struct.calcsize(format))
 
 
+class TestPythonBufferProtocol(unittest.TestCase):
+    def test_basic(self):
+        class MyBuffer:
+            def __buffer__(self, flags):
+                return memoryview(b"hello")
+
+        mv = memoryview(MyBuffer())
+        self.assertEqual(mv.tobytes(), b"hello")
+        self.assertEqual(bytes(MyBuffer()), b"hello")
+
+    def test_bad_buffer_method(self):
+        class MustReturnMV:
+            def __buffer__(self, flags):
+                return 42
+
+        self.assertRaises(TypeError, memoryview, MustReturnMV())
+
+        class WrongArity:
+            def __buffer__(self):
+                return memoryview(b"hello")
+
+        self.assertRaises(TypeError, memoryview, WrongArity())
+
+    def test_release_buffer(self):
+        class WhatToRelease:
+            def __init__(self):
+                self.held = False
+                self.ba = bytearray(b"hello")
+            def __buffer__(self, flags):
+                if self.held:
+                    raise TypeError("already held")
+                self.held = True
+                return memoryview(self.ba)
+            def __release_buffer__(self, buffer):
+                assert self is buffer.obj
+                self.held = False
+
+        wr = WhatToRelease()
+        self.assertFalse(wr.held)
+        with memoryview(wr) as mv:
+            self.assertTrue(wr.held)
+            self.assertEqual(mv.tobytes(), b"hello")
+        self.assertFalse(wr.held)
+
+    def test_call_builtins(self):
+        ba = bytearray(b"hello")
+        mv = ba.__buffer__(0)
+        self.assertEqual(mv.tobytes(), b"hello")
+        ba.__release_buffer__(mv)
+
+
 if __name__ == "__main__":
     unittest.main()

Objects/memoryobject.c

@@ -85,15 +85,15 @@ mbuf_alloc(void)
 }
 
 static PyObject *
-_PyManagedBuffer_FromObject(PyObject *base)
+_PyManagedBuffer_FromObject(PyObject *base, int flags)
 {
     _PyManagedBufferObject *mbuf;
 
     mbuf = mbuf_alloc();
     if (mbuf == NULL)
         return NULL;
 
-    if (PyObject_GetBuffer(base, &mbuf->master, PyBUF_FULL_RO) < 0) {
+    if (PyObject_GetBuffer(base, &mbuf->master, flags) < 0) {
         mbuf->master.obj = NULL;
         Py_DECREF(mbuf);
         return NULL;
@@ -779,11 +779,12 @@ PyMemoryView_FromBuffer(const Py_buffer *info)
     return mv;
 }
 
-/* Create a memoryview from an object that implements the buffer protocol.
+/* Create a memoryview from an object that implements the buffer protocol,
+   using the given flags.
    If the object is a memoryview, the new memoryview must be registered
    with the same managed buffer. Otherwise, a new managed buffer is created. */
 PyObject *
-PyMemoryView_FromObject(PyObject *v)
+PyMemoryView_FromObjectAndFlags(PyObject *v, int flags)
 {
     _PyManagedBufferObject *mbuf;
 
@@ -794,7 +795,7 @@ PyMemoryView_FromObject(PyObject *v)
     }
     else if (PyObject_CheckBuffer(v)) {
         PyObject *ret;
-        mbuf = (_PyManagedBufferObject *)_PyManagedBuffer_FromObject(v);
+        mbuf = (_PyManagedBufferObject *)_PyManagedBuffer_FromObject(v, flags);
         if (mbuf == NULL)
             return NULL;
         ret = mbuf_add_view(mbuf, NULL);
@@ -807,6 +808,14 @@ PyMemoryView_FromObject(PyObject *v)
         Py_TYPE(v)->tp_name);
     return NULL;
 }
+/* Create a memoryview from an object that implements the buffer protocol.
+   If the object is a memoryview, the new memoryview must be registered
+   with the same managed buffer. Otherwise, a new managed buffer is created. */
+PyObject *
+PyMemoryView_FromObject(PyObject *v)
+{
+    return PyMemoryView_FromObjectAndFlags(v, PyBUF_FULL_RO);
+}
 
 /* Copy the format string from a base object that might vanish. */
 static int
@@ -853,7 +862,7 @@ memory_from_contiguous_copy(const Py_buffer *src, char order)
     if (bytes == NULL)
         return NULL;
 
-    mbuf = (_PyManagedBufferObject *)_PyManagedBuffer_FromObject(bytes);
+    mbuf = (_PyManagedBufferObject *)_PyManagedBuffer_FromObject(bytes, PyBUF_FULL_RO);
     Py_DECREF(bytes);
     if (mbuf == NULL)
         return NULL;

Objects/typeobject.c

@@ -5,6 +5,7 @@
 #include "pycore_code.h"          // CO_FAST_FREE
 #include "pycore_compile.h"       // _Py_Mangle()
 #include "pycore_initconfig.h"    // _PyStatus_OK()
+#include "pycore_memoryobject.h"  // PyMemoryView_FromObjectAndFlags()
 #include "pycore_moduleobject.h"  // _PyModule_GetDef()
 #include "pycore_object.h"        // _PyType_HasFeature()
 #include "pycore_pyerrors.h"      // _PyErr_Occurred()
@@ -7554,8 +7555,6 @@ wrap_descr_delete(PyObject *self, PyObject *args, void *wrapped)
 static PyObject *
 wrap_buffer(PyObject *self, PyObject *args, void *wrapped)
 {
-    getbufferproc func = (getbufferproc)wrapped;
-    Py_buffer view;
     int flags = 0;
 
     if (!check_num_args(args, 1)) {
@@ -7564,10 +7563,7 @@ wrap_buffer(PyObject *self, PyObject *args, void *wrapped)
     if (!PyArg_ParseTuple(args, "i", &flags)) {
         return NULL;
     }
-    if ((*func)(self, &view, flags) < 0) {
-        return NULL;
-    }
-    return PyMemoryView_FromBuffer(&view);
+    return PyMemoryView_FromObjectAndFlags(self, flags);
 }
 
 static PyObject *
@@ -8441,6 +8437,9 @@ slot_bf_getbuffer(PyObject *self, Py_buffer *buffer, int flags)
         goto fail;
     }
     *buffer = ((PyMemoryViewObject *)ret)->view;
+    // TODO does this leak the existing ref in buffer->obj?
+    buffer->obj = self;
+    Py_INCREF(buffer->obj);
     Py_DECREF(ret);
     Py_DECREF(flags_obj);
     return 0;
@@ -8459,6 +8458,9 @@ slot_bf_releasebuffer(PyObject *self, Py_buffer *buffer)
         PyErr_WriteUnraisable(self);
         return;
     }
+    if (buffer->obj != NULL) {
+        ((PyMemoryViewObject *)mv)->view.obj = Py_NewRef(buffer->obj);
+    }
     PyObject *stack[2] = {self, mv};
     PyObject *ret = vectorcall_method(&_Py_ID(__release_buffer__), stack, 2);
     Py_DECREF(mv);
@@ -8470,7 +8472,6 @@ slot_bf_releasebuffer(PyObject *self, Py_buffer *buffer)
     }
 }
 
-
 static PyObject *
 slot_am_await(PyObject *self)
 {