U
|
O ±dWF ã @ sr d Z ddddddgZddlZdd lmZmZmZmZm Z dd
|
l
|
m Z m Z z ddl Z W n ek
|
rl dZ Y nX e dkrd d ZeZeZeZdd lmZ eZn*ddlm mZ e ¡ Z[e j Zdd Zdd Z ddddddgZ dd Z G dd deZ G dd d e Z!i Z"d-d dZ#e dk rnd d Z$d d! Z%e% Z&d"d# Z'd$d% Z(d&d' Z)d(d) Z*d*d Z+d.d+dZd,d ZdS )/a7
|
============================
|
``ctypes`` Utility Functions
|
============================
|
|
See Also
|
--------
|
load_library : Load a C library.
|
ndpointer : Array restype/argtype with verification.
|
as_ctypes : Create a ctypes array from an ndarray.
|
as_array : Create an ndarray from a ctypes array.
|
|
References
|
----------
|
.. [1] "SciPy Cookbook: ctypes", https://scipy-cookbook.readthedocs.io/items/Ctypes.html
|
|
Examples
|
--------
|
Load the C library:
|
|
>>> _lib = np.ctypeslib.load_library('libmystuff', '.') #doctest: +SKIP
|
|
Our result type, an ndarray that must be of type double, be 1-dimensional
|
and is C-contiguous in memory:
|
|
>>> array_1d_double = np.ctypeslib.ndpointer(
|
... dtype=np.double,
|
... ndim=1, flags='CONTIGUOUS') #doctest: +SKIP
|
|
Our C-function typically takes an array and updates its values
|
in-place. For example::
|
|
void foo_func(double* x, int length)
|
{
|
int i;
|
for (i = 0; i < length; i++) {
|
x[i] = i*i;
|
}
|
}
|
|
We wrap it using:
|
|
>>> _lib.foo_func.restype = None #doctest: +SKIP
|
>>> _lib.foo_func.argtypes = [array_1d_double, c_int] #doctest: +SKIP
|
|
Then, we're ready to call ``foo_func``:
|
|
>>> out = np.empty(15, dtype=np.double)
|
>>> _lib.foo_func(out, len(out)) #doctest: +SKIP
|
|
Ú load_libraryÚ ndpointerÚc_intpÚ as_ctypesÚas_arrayÚas_ctypes_typeé N)ÚintegerÚndarrayÚdtypeÚasarrayÚ
|
frombuffer)Ú _flagdictÚflagsobjc O s t ddS )z±
|
Dummy object that raises an ImportError if ctypes is not available.
|
|
Raises
|
------
|
ImportError
|
If ctypes is not available.
|
|
zctypes is not available.N)Ú ImportError)ÚargsÚkwds© r úFd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/ctypeslib.pyÚ_dummyC s
|
r )Úintpc C s t jdk r ddl}|jddd t | ¡} t |¡}tj | ¡d }|sddlm } | }| | g}|d d
|
}||ks|
|
d| | ¡ n| g}tj |¡}tj |¡s´tj |¡}n|}|D ]H} tj || ¡}
|
tj |
|
¡r¼zt j|
|
W S tk
|
r Y q¼X q¼td dS ) a
|
|
It is possible to load a library using
|
|
>>> lib = ctypes.cdll[<full_path_name>] # doctest: +SKIP
|
|
But there are cross-platform considerations, such as library file extensions,
|
plus the fact Windows will just load the first library it finds with that name.
|
NumPy supplies the load_library function as a convenience.
|
|
.. versionchanged:: 1.20.0
|
Allow libname and loader_path to take any
|
:term:`python:path-like object`.
|
|
Parameters
|
----------
|
libname : path-like
|
Name of the library, which can have 'lib' as a prefix,
|
but without an extension.
|
loader_path : path-like
|
Where the library can be found.
|
|
Returns
|
-------
|
ctypes.cdll[libpath] : library object
|
A ctypes library object
|
|
Raises
|
------
|
OSError
|
If there is no library with the expected extension, or the
|
library is defective and cannot be loaded.
|
z1.0.1r NzAAll features of ctypes interface may not work with ctypes < 1.0.1é )Ú
|
stacklevelé )Úget_shared_lib_extensionT)Z is_python_extz no file with expected extension)ÚctypesÚ __version__ÚwarningsÚwarnÚosÚfsdecodeÚpathÚsplitextZnumpy.distutils.misc_utilr ÚinsertÚabspathÚisdirÚdirnameÚjoinÚexistsÚcdllÚOSError) ÚlibnameZ loader_pathr Úextr Zso_extZ libname_extZso_ext2ZlibdirÚlnZlibpathr r r r Z s8 !
|
ÿ
|
|
|
|
|
c C s d}| D ]}|t | 7 }q|S ©Nr )r )ZflaglistÚnumÚvalr r r Ú_num_fromflags¦ s r0 Z C_CONTIGUOUSZ F_CONTIGUOUSZALIGNEDZ WRITEABLEZOWNDATAZWRITEBACKIFCOPYc C s, g }t D ] }t| }| |@ r| |¡ q|S ©N)Ú
|
_flagnamesr Úappend)r. ÚresÚkeyÚvaluer r r Ú_flags_fromnum® s r7 c @ s e Zd Zedd ZdS )Ú_ndptrc C s¸ t |tstd| jd k r6|j| jkr6td| j | jd k rZ|j| jkrZtd| j | jd k r|j| jkrtdt | j | j
|
d k r²|j j | j
|
@ | j
|
kr²tdt | j
|
|jS )Nzargument must be an ndarrayz array must have data type %sz array must have %d dimension(s)zarray must have shape %szarray must have flags %s)Ú
|
isinstancer Ú TypeErrorÚ_dtype_r
|
Ú_ndim_ÚndimÚ_shape_ÚshapeÚstrÚ_flags_Úflagsr. r7 r )ÚclsÚobjr r r Ú
|
from_param¸ s*
|
|
|
ÿ
|
|
ÿ
|
|
ÿ
|
ÿÿz_ndptr.from_paramN)Ú__name__Ú
|
__module__Ú __qualname__Ú classmethodrE r r r r r8 · s r8 c @ s$ e Zd ZdZdd Zedd ZdS )Ú_concrete_ndptrz¹
|
Like _ndptr, but with `_shape_` and `_dtype_` specified.
|
|
Notably, this means the pointer has enough information to reconstruct
|
the array, which is not generally true.
|
c C s | j S )z¹
|
This method is called when this class is used as the .restype
|
attribute for a shared-library function, to automatically wrap the
|
pointer into an array.
|
)Úcontents)Úselfr r r Ú_check_retval_Ó s z _concrete_ndptr._check_retval_c C sD t | j| jf}tj|j }t | t |¡¡j}t ||dj
|
ddS )z
|
Get an ndarray viewing the data pointed to by this pointer.
|
|
This mirrors the `contents` attribute of a normal ctypes pointer
|
©r
|
r )Zaxis) Ú_dtyper; r> r Úc_charÚitemsizeÚcastÚPOINTERrK r Zsqueeze)rL Z
|
full_dtypeZ
|
full_ctypeÚbufferr r r rK Û s z_concrete_ndptr.contentsN)rF rG rH Ú__doc__rM ÚpropertyrK r r r r rJ Ì s rJ c
|
|
C sâ | dk rt | } d}|dk r¶t|tr2| d¡}n4t|ttfrN|}t|}nt|trf|j}t|}|dkr¶zdd |D }W n, t k
|
r¬ } zt
|
d|W 5 d}~X Y nX t |}|dk ræz t |}W n t
|
k
|
rä |f}Y nX | |||f}z
|
t | W S tk
|
r Y nX | dkr$d}n | jdk r>tt| }n| j}|dk rZ|d| 7 }|dk r|dd d
|
d |D ¡ 7 }|dk r|dd |¡ 7 }| dk r¶|dk r¶t}nt}td | |f| |||d } | t |< | S )aF
|
Array-checking restype/argtypes.
|
|
An ndpointer instance is used to describe an ndarray in restypes
|
and argtypes specifications. This approach is more flexible than
|
using, for example, ``POINTER(c_double)``, since several restrictions
|
can be specified, which are verified upon calling the ctypes function.
|
These include data type, number of dimensions, shape and flags. If a
|
given array does not satisfy the specified restrictions,
|
a ``TypeError`` is raised.
|
|
Parameters
|
----------
|
dtype : data-type, optional
|
Array data-type.
|
ndim : int, optional
|
Number of array dimensions.
|
shape : tuple of ints, optional
|
Array shape.
|
flags : str or tuple of str
|
Array flags; may be one or more of:
|
|
- C_CONTIGUOUS / C / CONTIGUOUS
|
- F_CONTIGUOUS / F / FORTRAN
|
- OWNDATA / O
|
- WRITEABLE / W
|
- ALIGNED / A
|
- WRITEBACKIFCOPY / X
|
|
Returns
|
-------
|
klass : ndpointer type object
|
A type object, which is an ``_ndtpr`` instance containing
|
dtype, ndim, shape and flags information.
|
|
Raises
|
------
|
TypeError
|
If a given array does not satisfy the specified restrictions.
|
|
Examples
|
--------
|
>>> clib.somefunc.argtypes = [np.ctypeslib.ndpointer(dtype=np.float64,
|
... ndim=1,
|
... flags='C_CONTIGUOUS')]
|
... #doctest: +SKIP
|
>>> clib.somefunc(np.array([1, 2, 3], dtype=np.float64))
|
... #doctest: +SKIP
|
|
Nú,c S s g | ]}| ¡ ¡ qS r )ÚstripÚupper©Ú.0Úxr r r Ú
|
<listcomp>0 s z ndpointer.<locals>.<listcomp>zinvalid flags specificationÚanyz_%ddÚ_r\ c s s | ]}t |V qd S r1 )r@ rZ r r r Ú <genexpr>N s z ndpointer.<locals>.<genexpr>z ndpointer_%s)r; r> r< rA )rO r9 r@ ÚsplitÚintr r7 r r. Ú Exceptionr: r0 ÚtupleÚ_pointer_type_cacheÚKeyErrorÚnamesÚidr& rJ r8 Útype)
|
r
|
r= r? rB r. ÚeÚ cache_keyÚnameÚbaseÚklassr r r r ë sf 5
|
|
|
|
|
|
|
|
ýÿc C s& |ddd
D ]}|| } d| _ q| S )z7 Create an ndarray of the given element type and shape Néÿÿÿÿ)rG )Z element_typer? Zdimr r r Ú_ctype_ndarraya s rp c C sJ t } | j| j| j| j| j| j| j| j| j | j
|
| j | j | j g }dd |D S )zX
|
Return a dictionary mapping native endian scalar dtype to ctypes types
|
c S s i | ]}t ||qS r )rO )r[ Úctyper r r Ú
|
<dictcomp>u s z(_get_scalar_type_map.<locals>.<dictcomp>)r Úc_byteÚc_shortÚc_intÚc_longÚ
|
c_longlongÚc_ubyteÚc_ushortÚc_uintÚc_ulongÚ c_ulonglongÚc_floatÚc_doubleÚc_bool)ÚctZ simple_typesr r r Ú_get_scalar_type_mapj s ür c
|
C s | d¡ d¡}| d¡}z t| }W n2 tk
|
rX } ztd | ¡d W 5 d }~X Y nX |jdkrl|j}n|jdkr||j}|S )NÚSú=z Converting {!r} to a ctypes typeú>ú<)Z newbyteorderÚ_scalar_type_maprf ÚNotImplementedErrorÚformatÚ byteorderÚ __ctype_be__Ú __ctype_le__)r
|
Zdtype_with_endianZ dtype_nativerq rj r r r Ú_ctype_from_dtype_scalar{ s
|
ÿþ
|
|
r c C s | j \}}t|}t||S r1 )ÚsubdtypeÚ_ctype_from_dtyperp )r
|
Z element_dtyper? rq r r r Ú_ctype_from_dtype_subarray s
|
r c
|
C s g }| j D ].}| j| d d
\}}| ||t|f¡ q
|
t|dd d}t|dkrØtdd |D rØd}g }|D ](\}}}| ||f¡ t|t |¡}qt| j
|
|kr¾| d tj | j
|
f¡ t d
|
tj ft|dd d S d}g }|D ]^\}}}|| } | dk rtd | dkr&| d tj | f¡ | ||f¡ |t |¡ }qä| j
|
| } | dkrl| d tj | f¡ t d tjft|dd d S d S )Nr c S s | d S r- r )Úfr r r Ú<lambda> ó z._ctype_from_dtype_structured.<locals>.<lambda>)r5 r c s s | ]\}}}|d kV qdS )r Nr )r[ Úoffsetrl rq r r r r` s z/_ctype_from_dtype_structured.<locals>.<genexpr>r Ú Úunion)Ú_fields_Ú_pack_rG zOverlapping fieldsÚstruct)rg Úfieldsr3 r ÚsortedÚlenÚallÚmaxr ÚsizeofrQ rP ri ÚUnionÚdictr Ú Structure)
|
r
|
Z
|
field_datarl Z field_dtyper Úsizer rq Z last_offsetÚpaddingr r r Ú _ctype_from_dtype_structured sH
|
|
ý
|
|
|
|
ýr¤ c C s0 | j d k rt| S | jd k r$t| S t| S d S r1 )r r¤ r r r rN r r r r Ê s
|
|
|
r c C s t t| S )a
|
Convert a dtype into a ctypes type.
|
|
Parameters
|
----------
|
dtype : dtype
|
The dtype to convert
|
|
Returns
|
-------
|
ctype
|
A ctype scalar, union, array, or struct
|
|
Raises
|
------
|
NotImplementedError
|
If the conversion is not possible
|
|
Notes
|
-----
|
This function does not losslessly round-trip in either direction.
|
|
``np.dtype(as_ctypes_type(dt))`` will:
|
|
- insert padding fields
|
- reorder fields to be sorted by offset
|
- discard field titles
|
|
``as_ctypes_type(np.dtype(ctype))`` will:
|
|
- discard the class names of `ctypes.Structure`\ s and
|
`ctypes.Union`\ s
|
- convert single-element `ctypes.Union`\ s into single-element
|
`ctypes.Structure`\ s
|
- insert padding fields
|
|
)r rO rN r r r r Ó s &c C sD t | tjr<|dkr tdt t| j|¡}t | |¡j} t | S )a"
|
Create a numpy array from a ctypes array or POINTER.
|
|
The numpy array shares the memory with the ctypes object.
|
|
The shape parameter must be given if converting from a ctypes POINTER.
|
The shape parameter is ignored if converting from a ctypes array
|
Nz=as_array() requires a shape argument when called on a pointer)
|
r9 r Ú_Pointerr: rS rp Ú_type_rR rK r )rD r? Z
|
p_arr_typer r r r ü s ÿc C sp | j }|d rtd|d dkr*td|d \}}|rBtdt|d }t||d }| |¡}| |_|S )
|
zCreate and return a ctypes object from a numpy array. Actually
|
anything that exposes the __array_interface__ is accepted.Ústridesz strided arrays not supportedÚversioné z,only __array_interface__ version 3 supportedÚdatazreadonly arrays unsupportedZtypestrr? )Z__array_interface__r: r rp Ú from_addressZ__keep)rD ZaiÚaddrÚreadonlyZ ctype_scalarZ result_typeÚresultr r r r s
|
)NNNN)N),rU Ú__all__r Únumpyr r r
|
rO r r Znumpy.core.multiarrayr r r r r r r r r r ÚobjectZ _ndptr_baseZnumpy.core._internalÚcoreÚ _internalZnicZ_getintp_ctypeÚc_void_pr0 r2 r7 r8 rJ re r rp r r r r r¤ r r r r r r Ú<module> sV 3
|
ÿ
|
L ÿ
|
u
|
6 )
|
|
