You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
314 lines
9.6 KiB
314 lines
9.6 KiB
"""Python version-independent methods for C/Python buffers.
|
|
|
|
This file was copied and adapted from mpi4py.
|
|
|
|
Authors
|
|
-------
|
|
* MinRK
|
|
"""
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Copyright (c) 2010 Lisandro Dalcin
|
|
# All rights reserved.
|
|
# Used under BSD License: http://www.opensource.org/licenses/bsd-license.php
|
|
#
|
|
# Retrieval:
|
|
# Jul 23, 2010 18:00 PST (r539)
|
|
# http://code.google.com/p/mpi4py/source/browse/trunk/src/MPI/asbuffer.pxi
|
|
#
|
|
# Modifications from original:
|
|
# Copyright (c) 2010-2012 Brian Granger, Min Ragan-Kelley
|
|
#
|
|
# Distributed under the terms of the New BSD License. The full license is in
|
|
# the file COPYING.BSD, distributed as part of this software.
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Python includes.
|
|
#-----------------------------------------------------------------------------
|
|
|
|
# get version-independent aliases:
|
|
cdef extern from "pyversion_compat.h":
|
|
pass
|
|
|
|
# Python 3 buffer interface (PEP 3118)
|
|
cdef extern from "Python.h":
|
|
int PY_MAJOR_VERSION
|
|
int PY_MINOR_VERSION
|
|
ctypedef int Py_ssize_t
|
|
ctypedef struct PyMemoryViewObject:
|
|
pass
|
|
ctypedef struct Py_buffer:
|
|
void *buf
|
|
Py_ssize_t len
|
|
int readonly
|
|
char *format
|
|
int ndim
|
|
Py_ssize_t *shape
|
|
Py_ssize_t *strides
|
|
Py_ssize_t *suboffsets
|
|
Py_ssize_t itemsize
|
|
void *internal
|
|
cdef enum:
|
|
PyBUF_SIMPLE
|
|
PyBUF_WRITABLE
|
|
PyBUF_FORMAT
|
|
PyBUF_ANY_CONTIGUOUS
|
|
int PyObject_CheckBuffer(object)
|
|
int PyObject_GetBuffer(object, Py_buffer *, int) except -1
|
|
void PyBuffer_Release(Py_buffer *)
|
|
|
|
int PyBuffer_FillInfo(Py_buffer *view, object obj, void *buf,
|
|
Py_ssize_t len, int readonly, int infoflags) except -1
|
|
object PyMemoryView_FromBuffer(Py_buffer *info)
|
|
|
|
object PyMemoryView_FromObject(object)
|
|
|
|
# Python 2 buffer interface (legacy)
|
|
cdef extern from "Python.h":
|
|
Py_ssize_t Py_END_OF_BUFFER
|
|
int PyObject_CheckReadBuffer(object)
|
|
int PyObject_AsReadBuffer (object, const void **, Py_ssize_t *) except -1
|
|
int PyObject_AsWriteBuffer(object, void **, Py_ssize_t *) except -1
|
|
|
|
object PyBuffer_FromMemory(void *ptr, Py_ssize_t s)
|
|
object PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t s)
|
|
|
|
object PyBuffer_FromObject(object, Py_ssize_t offset, Py_ssize_t size)
|
|
object PyBuffer_FromReadWriteObject(object, Py_ssize_t offset, Py_ssize_t size)
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# asbuffer: C buffer from python object
|
|
#-----------------------------------------------------------------------------
|
|
|
|
|
|
cdef inline int memoryview_available():
|
|
return PY_MAJOR_VERSION >= 3 or (PY_MAJOR_VERSION >=2 and PY_MINOR_VERSION >= 7)
|
|
|
|
cdef inline int oldstyle_available():
|
|
return PY_MAJOR_VERSION < 3
|
|
|
|
|
|
cdef inline int check_buffer(object ob):
|
|
"""Version independent check for whether an object is a buffer.
|
|
|
|
Parameters
|
|
----------
|
|
object : object
|
|
Any Python object
|
|
|
|
Returns
|
|
-------
|
|
int : 0 if no buffer interface, 3 if newstyle buffer interface, 2 if oldstyle.
|
|
"""
|
|
if PyObject_CheckBuffer(ob):
|
|
return 3
|
|
if oldstyle_available():
|
|
return PyObject_CheckReadBuffer(ob) and 2
|
|
return 0
|
|
|
|
|
|
cdef inline object asbuffer(object ob, int writable, int format,
|
|
void **base, Py_ssize_t *size,
|
|
Py_ssize_t *itemsize):
|
|
"""Turn an object into a C buffer in a Python version-independent way.
|
|
|
|
Parameters
|
|
----------
|
|
ob : object
|
|
The object to be turned into a buffer.
|
|
Must provide a Python Buffer interface
|
|
writable : int
|
|
Whether the resulting buffer should be allowed to write
|
|
to the object.
|
|
format : int
|
|
The format of the buffer. See Python buffer docs.
|
|
base : void **
|
|
The pointer that will be used to store the resulting C buffer.
|
|
size : Py_ssize_t *
|
|
The size of the buffer(s).
|
|
itemsize : Py_ssize_t *
|
|
The size of an item, if the buffer is non-contiguous.
|
|
|
|
Returns
|
|
-------
|
|
An object describing the buffer format. Generally a str, such as 'B'.
|
|
"""
|
|
|
|
cdef void *bptr = NULL
|
|
cdef Py_ssize_t blen = 0, bitemlen = 0
|
|
cdef Py_buffer view
|
|
cdef int flags = PyBUF_SIMPLE
|
|
cdef int mode = 0
|
|
|
|
bfmt = None
|
|
|
|
mode = check_buffer(ob)
|
|
if mode == 0:
|
|
raise TypeError("%r does not provide a buffer interface."%ob)
|
|
|
|
if mode == 3:
|
|
flags = PyBUF_ANY_CONTIGUOUS
|
|
if writable:
|
|
flags |= PyBUF_WRITABLE
|
|
if format:
|
|
flags |= PyBUF_FORMAT
|
|
PyObject_GetBuffer(ob, &view, flags)
|
|
bptr = view.buf
|
|
blen = view.len
|
|
if format:
|
|
if view.format != NULL:
|
|
bfmt = view.format
|
|
bitemlen = view.itemsize
|
|
PyBuffer_Release(&view)
|
|
else: # oldstyle
|
|
if writable:
|
|
PyObject_AsWriteBuffer(ob, &bptr, &blen)
|
|
else:
|
|
PyObject_AsReadBuffer(ob, <const void **>&bptr, &blen)
|
|
if format:
|
|
try: # numpy.ndarray
|
|
dtype = ob.dtype
|
|
bfmt = dtype.char
|
|
bitemlen = dtype.itemsize
|
|
except AttributeError:
|
|
try: # array.array
|
|
bfmt = ob.typecode
|
|
bitemlen = ob.itemsize
|
|
except AttributeError:
|
|
if isinstance(ob, bytes):
|
|
bfmt = b"B"
|
|
bitemlen = 1
|
|
else:
|
|
# nothing found
|
|
bfmt = None
|
|
bitemlen = 0
|
|
if base: base[0] = <void *>bptr
|
|
if size: size[0] = <Py_ssize_t>blen
|
|
if itemsize: itemsize[0] = <Py_ssize_t>bitemlen
|
|
|
|
if PY_MAJOR_VERSION >= 3 and bfmt is not None:
|
|
return bfmt.decode('ascii')
|
|
return bfmt
|
|
|
|
|
|
cdef inline object asbuffer_r(object ob, void **base, Py_ssize_t *size):
|
|
"""Wrapper for standard calls to asbuffer with a readonly buffer."""
|
|
asbuffer(ob, 0, 0, base, size, NULL)
|
|
return ob
|
|
|
|
|
|
cdef inline object asbuffer_w(object ob, void **base, Py_ssize_t *size):
|
|
"""Wrapper for standard calls to asbuffer with a writable buffer."""
|
|
asbuffer(ob, 1, 0, base, size, NULL)
|
|
return ob
|
|
|
|
#------------------------------------------------------------------------------
|
|
# frombuffer: python buffer/view from C buffer
|
|
#------------------------------------------------------------------------------
|
|
|
|
|
|
cdef inline object frombuffer_3(void *ptr, Py_ssize_t s, int readonly):
|
|
"""Python 3 version of frombuffer.
|
|
|
|
This is the Python 3 model, but will work on Python >= 2.6. Currently,
|
|
we use it only on >= 3.0.
|
|
"""
|
|
cdef Py_buffer pybuf
|
|
cdef Py_ssize_t *shape = [s]
|
|
cdef str astr=""
|
|
PyBuffer_FillInfo(&pybuf, astr, ptr, s, readonly, PyBUF_SIMPLE)
|
|
pybuf.format = "B"
|
|
pybuf.shape = shape
|
|
pybuf.ndim = 1
|
|
return PyMemoryView_FromBuffer(&pybuf)
|
|
|
|
|
|
cdef inline object frombuffer_2(void *ptr, Py_ssize_t s, int readonly):
|
|
"""Python 2 version of frombuffer.
|
|
|
|
This must be used for Python <= 2.6, but we use it for all Python < 3.
|
|
"""
|
|
|
|
if oldstyle_available():
|
|
if readonly:
|
|
return PyBuffer_FromMemory(ptr, s)
|
|
else:
|
|
return PyBuffer_FromReadWriteMemory(ptr, s)
|
|
else:
|
|
raise NotImplementedError("Old style buffers not available.")
|
|
|
|
|
|
cdef inline object frombuffer(void *ptr, Py_ssize_t s, int readonly):
|
|
"""Create a Python Buffer/View of a C array.
|
|
|
|
Parameters
|
|
----------
|
|
ptr : void *
|
|
Pointer to the array to be copied.
|
|
s : size_t
|
|
Length of the buffer.
|
|
readonly : int
|
|
whether the resulting object should be allowed to write to the buffer.
|
|
|
|
Returns
|
|
-------
|
|
Python Buffer/View of the C buffer.
|
|
"""
|
|
# oldstyle first priority for now
|
|
if oldstyle_available():
|
|
return frombuffer_2(ptr, s, readonly)
|
|
else:
|
|
return frombuffer_3(ptr, s, readonly)
|
|
|
|
|
|
cdef inline object frombuffer_r(void *ptr, Py_ssize_t s):
|
|
"""Wrapper for readonly view frombuffer."""
|
|
return frombuffer(ptr, s, 1)
|
|
|
|
|
|
cdef inline object frombuffer_w(void *ptr, Py_ssize_t s):
|
|
"""Wrapper for writable view frombuffer."""
|
|
return frombuffer(ptr, s, 0)
|
|
|
|
#------------------------------------------------------------------------------
|
|
# viewfromobject: python buffer/view from python object, refcounts intact
|
|
# frombuffer(asbuffer(obj)) would lose track of refs
|
|
#------------------------------------------------------------------------------
|
|
|
|
cdef inline object viewfromobject(object obj, int readonly):
|
|
"""Construct a Python Buffer/View object from another Python object.
|
|
|
|
This work in a Python version independent manner.
|
|
|
|
Parameters
|
|
----------
|
|
obj : object
|
|
The input object to be cast as a buffer
|
|
readonly : int
|
|
Whether the result should be prevented from overwriting the original.
|
|
|
|
Returns
|
|
-------
|
|
Buffer/View of the original object.
|
|
"""
|
|
if not memoryview_available():
|
|
if readonly:
|
|
return PyBuffer_FromObject(obj, 0, Py_END_OF_BUFFER)
|
|
else:
|
|
return PyBuffer_FromReadWriteObject(obj, 0, Py_END_OF_BUFFER)
|
|
else:
|
|
return PyMemoryView_FromObject(obj)
|
|
|
|
|
|
cdef inline object viewfromobject_r(object obj):
|
|
"""Wrapper for readonly viewfromobject."""
|
|
return viewfromobject(obj, 1)
|
|
|
|
|
|
cdef inline object viewfromobject_w(object obj):
|
|
"""Wrapper for writable viewfromobject."""
|
|
return viewfromobject(obj, 0)
|