Added obj() getter method to PyUntypedBuffer

newsfragments/5870.added.md

@@ -0,0 +1 @@
+Add `obj()` getter to `PyUntypedBuffer` to retrieve the Python object owning the buffer.

src/buffer.rs

@@ -570,6 +570,24 @@ impl PyUntypedBuffer {
         self.raw().buf
     }
 
+    ///Returns the Python object that owns the buffer data.
+    ///
+    ///This is the object that was passed to [`PyBuffer::get()`] when the buffer was created.
+    ///Returns `None` if the buffer was created without owning object.
+    ///
+    ///This is the object passed to [`PyUntypedBuffer::get()`]
+    ///Calling this before [`release()`][Self::release] allows you to clone an owned reference and
+    ///keeps the object alive after the buffer is released.
+    pub fn obj<'py>(&self, py: Python<'py>) -> Option<Bound<'py, PyAny>> {
+        let ptr = self.raw().obj;
+        // SAFETY: Py_buffer.obj is a borrowed reference to a Python object, so it is always valid to create a Bound from it
+        if ptr.is_null() {
+            None
+        } else {
+            Some(unsafe { Bound::from_borrowed_ptr(py, ptr) })
+        }
+    }
+
     /// Gets a pointer to the specified item.
     ///
     /// If `indices.len() < self.dimensions()`, returns the start address of the sub-array at the specified dimension.
@@ -1044,4 +1062,27 @@ mod tests {
             assert_eq!(typed.shape(), [5]);
         });
     }
+
+    #[test]
+    fn test_obj_getter() {
+        Python::attach(|py| {
+            let bytes = PyBytes::new(py, b"hello");
+            let buf = PyUntypedBuffer::get(bytes.as_any()).unwrap();
+
+            // obj() returns the same object that owns the buffer
+            let owner = buf.obj(py).unwrap();
+            assert!(owner.is_instance_of::<PyBytes>());
+            assert!(owner.is(&bytes));
+
+            // can keep the owner alive after releasing the buffer
+            let owner_ref: crate::Py<PyAny> = owner.unbind();
+            buf.release(py);
+            drop(bytes);
+            // owner_ref still valid after buffer and original are dropped
+            Python::attach(|py| {
+                let rebound = owner_ref.bind(py);
+                assert!(rebound.is_instance_of::<PyBytes>());
+            });
+        });
+    }
 }