File size: 7,031 Bytes
d1ceb73 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 |
"""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 LICENSE.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)
#-----------------------------------------------------------------------------
# asbuffer: C buffer from python object
#-----------------------------------------------------------------------------
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 (removed).
"""
if PyObject_CheckBuffer(ob):
return 3
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)
if base: base[0] = <void *>bptr
if size: size[0] = <Py_ssize_t>blen
if itemsize: itemsize[0] = <Py_ssize_t>bitemlen
if 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(void *ptr, Py_ssize_t s, int readonly):
"""Create a Python Memory 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 Memory View of the C buffer.
"""
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_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 Memory View object from another Python object.
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
-------
MemoryView of the original object.
"""
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)
|