Uploaded Test files
This commit is contained in:
parent
f584ad9d97
commit
2e81cb7d99
16627 changed files with 2065359 additions and 102444 deletions
313
venv/Lib/site-packages/zmq/utils/buffers.pxd
Normal file
313
venv/Lib/site-packages/zmq/utils/buffers.pxd
Normal file
|
|
@ -0,0 +1,313 @@
|
|||
"""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)
|
||||
Loading…
Add table
Add a link
Reference in a new issue