[Python]: add bindings for additional Buffer class non-CPU methods

python/pyarrow/device.pxi

@@ -130,6 +130,9 @@ cdef class MemoryManager(_Weakrefable):
         self.init(mm)
         return self
 
+    cdef inline shared_ptr[CMemoryManager] unwrap(self) nogil:
+        return self.memory_manager
+
     def __repr__(self):
         return "<pyarrow.MemoryManager device: {}>".format(
             frombytes(self.memory_manager.get().device().get().ToString())
@@ -152,7 +155,6 @@ cdef class MemoryManager(_Weakrefable):
         """
         return self.memory_manager.get().is_cpu()
 
-
 def default_cpu_memory_manager():
     """
     Return the default CPU MemoryManager instance.

python/pyarrow/includes/libarrow.pxd

@@ -364,6 +364,7 @@ cdef extern from "arrow/api.h" namespace "arrow" nogil:
         shared_ptr[CDevice] device()
         const shared_ptr[CMemoryManager] memory_manager()
         CDeviceAllocationType device_type()
+        CResult[shared_ptr[CBuffer]] Copy(shared_ptr[CBuffer] source, const shared_ptr[CMemoryManager]& to) const
 
     CResult[shared_ptr[CBuffer]] SliceBufferSafe(
         const shared_ptr[CBuffer]& buffer, int64_t offset)

python/pyarrow/io.pxi

@@ -1446,6 +1446,27 @@ cdef class Buffer(_Weakrefable):
         """
         return _wrap_device_allocation_type(self.buffer.get().device_type())
 
+    def copy(self, MemoryManager mm):
+        """
+        The buffer contents will be copied into a new buffer allocated by the
+        given MemoryManager.  This function supports cross-device copies.
+
+        Parameters
+        ---------
+        MemoryManager
+            Memory manager used to allocate the new buffer.
+
+        Returns
+        -------
+        Buffer
+        """
+        cdef:
+            shared_ptr[CBuffer] c_buffer
+
+        c_buffer = GetResultValue(self.buffer.get().Copy(self.buffer, mm.unwrap()))
+        return pyarrow_wrap_buffer(c_buffer)
+
+
     @property
     def parent(self):
         cdef shared_ptr[CBuffer] parent_buf = self.buffer.get().parent()

python/pyarrow/lib.pxd

@@ -544,6 +544,8 @@ cdef class MemoryManager(_Weakrefable):
     @staticmethod
     cdef wrap(const shared_ptr[CMemoryManager]& mm)
 
+    cdef inline shared_ptr[CMemoryManager] unwrap(self) nogil
+
 
 cdef class Buffer(_Weakrefable):
     cdef:

python/pyarrow/tests/test_cuda.py

@@ -115,6 +115,22 @@ def make_random_buffer(size, target='host'):
         return arr, dbuf
     raise ValueError('invalid target value')
 
+def test_copy_from_buffer():
+    arr, buf = make_random_buffer(128)
+    cudabuf = global_context.buffer_from_data(buf)
+
+    mm2 = global_context1.memory_manager
+    buf2 = cudabuf.copy(mm2)
+    cudabuf2 = cuda.CudaBuffer.from_buffer(buf2)
+    cudabuf2.size == cudabuf.size
+
+    arr2 = np.frombuffer(cudabuf2.copy_to_host(), dtype=np.uint8)
+    np.testing.assert_equal(arr, arr2)
+
+    assert cudabuf2.memory_manager.device == mm2.device
+
+
+
 
 @pytest.mark.parametrize("size", [0, 1, 1000])
 def test_context_device_buffer(size):