U #c4D@srdZddddddgZddlZdd lmZmZmZmZm Z dd l m Z m Z z ddl Z Wnek rldZ YnXe dkrd d ZeZeZeZdd lmZeZn*ddlmmZeZ[e jZddZddZddddddgZddZGdddeZ Gddde Z!iZ"d-ddZ#e dk rnddZ$d d!Z%e%Z&d"d#Z'd$d%Z(d&d'Z)d(d)Z*d*dZ+d.d+dZd,dZdS)/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 ndpointerc_intp as_ctypesas_arrayas_ctypes_typeN)integerndarraydtypeasarray frombuffer) _flagdictflagsobjcOs tddS)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)argskwdsr3/tmp/pip-unpacked-wheel-b2rbor69/numpy/ctypeslib.py_dummyCs r)intpc Cstjdkr ddl}|jdddt|}t|}tj|d}|sddlm }|}||g}|d d }||ks| d||n|g}tj |}tj |stj |}n|}|D]H} tj|| } tj| rztj| WStk rYqXqtd dS) a  It is possible to load a library using >>> lib = ctypes.cdll[] # 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.1rNzAAll features of ctypes interface may not work with ctypes < 1.0.1) stacklevel)get_shared_lib_extensionT)Z is_python_extzno file with expected extension)ctypes __version__warningswarnosfsdecodepathsplitextZnumpy.distutils.misc_utilrinsertabspathisdirdirnamejoinexistscdllOSError) ZlibnameZ loader_pathrextrZso_extZ libname_extZso_ext2ZlibdirlnZlibpathrrrrZs8!          cCsd}|D]}|t|7}q|SNr)r )Zflaglistnumvalrrr_num_fromflagssr/Z C_CONTIGUOUSZ F_CONTIGUOUSZALIGNEDZ WRITEABLEZOWNDATAZWRITEBACKIFCOPYcCs,g}tD]}t|}||@r||q|SN) _flagnamesr append)r-reskeyvaluerrr_flags_fromnums  r6c@seZdZeddZdS)_ndptrcCst|tstd|jdk r6|j|jkr6td|j|jdk rZ|j|jkrZtd|j|jdk r|j|jkrtdt |j|j dk r|j j |j @|j krtdt |j |jS)Nzargument must be an ndarrayzarray must have data type %szarray must have %d dimension(s)zarray must have shape %szarray must have flags %s) isinstancer TypeError_dtype_r _ndim_ndim_shape_shapestr_flags_flagsr-r6r)clsobjrrr from_params*        z_ndptr.from_paramN)__name__ __module__ __qualname__ classmethodrDrrrrr7sr7c@s$eZdZdZddZeddZdS)_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. cCs|jS)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)selfrrr_check_retval_sz_concrete_ndptr._check_retval_cCsDt|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=rc_charitemsizecastPOINTERrJr Zsqueeze)rKZ full_dtypeZ full_ctypebufferrrrrJs z_concrete_ndptr.contentsN)rErFrG__doc__rLpropertyrJrrrrrIsrIc Cs|dk rt|}d}|dk rt|tr2|d}n4t|ttfrN|}t|}nt|trf|j}t|}|dkrzdd|D}Wn,t k r}zt d|W5d}~XYnXt |}|dk rz t |}Wnt k r|f}YnX||||f}z t |WStk rYnX|dkr$d}n |jdk r>tt|}n|j}|dk rZ|d|7}|dk r|dd d d |D7}|dk r|dd|7}|dk r|dk rt}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,cSsg|]}|qSr)stripupper.0xrrr 0szndpointer..zinvalid flags specificationanyz_%dd_r[css|]}t|VqdSr0)r?rYrrr Nszndpointer..z ndpointer_%s)r:r=r;r@)rNr8r?splitintrr6rr- Exceptionr9r/tuple_pointer_type_cacheKeyErrornamesidr&rIr7type) r r<r>rAr-e cache_keynamebaseklassrrrrsf5               cCs&|dddD]}||}d|_q|S)z7 Create an ndarray of the given element type and shape N)rF)Z element_typer>Zdimrrr_ctype_ndarrayasroc CsJt}|j|j|j|j|j|j|j|j|j |j |j |j |j g }dd|DS)zX Return a dictionary mapping native endian scalar dtype to ctypes types cSsi|]}t||qSr)rN)rZctyperrr usz(_get_scalar_type_map..)rc_bytec_shortc_intc_long c_longlongc_ubytec_ushortc_uintc_ulong c_ulonglongc_floatc_doublec_bool)ctZ simple_typesrrr_get_scalar_type_mapjs rc Cs|dd}|d}z t|}Wn2tk rX}ztd|dW5d}~XYnX|jdkrl|j}n|jdkr||j}|S)NS=z Converting {!r} to a ctypes type><)Z newbyteorder_scalar_type_mapreNotImplementedErrorformat byteorder __ctype_be__ __ctype_le__)r Zdtype_with_endianZ dtype_nativerprirrr_ctype_from_dtype_scalar{s    rcCs|j\}}t|}t||Sr0)subdtype_ctype_from_dtypero)r Z element_dtyper>rprrr_ctype_from_dtype_subarrays rc Csg}|jD].}|j|dd\}}|||t|fq t|ddd}t|dkrtdd|Drd}g}|D](\}}}|||ft|t |}qt|j |kr|d tj |j ft d tj ft|ddd Sd}g}|D]^\}}}||} | dkrtd | dkr&|d tj | f|||f|t |}q|j |} | dkrl|d tj | ft d tjft|ddd SdS)NrcSs|dSr,r)frrrz._ctype_from_dtype_structured..)r4rcss|]\}}}|dkVqdS)rNr)rZoffsetrkrprrrr_sz/_ctype_from_dtype_structured..runion)_fields_Z_pack_rFzOverlapping fieldsstruct)rffieldsr2rsortedlenallmaxrsizeofrPrOrhUniondictr Structure) r Z field_datarkZ field_dtypersizerrpZ last_offsetpaddingrrr_ctype_from_dtype_structuredsH        rcCs0|jdk rt|S|jdk r$t|St|SdSr0)rrrrrrMrrrrs   rcCs tt|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 )rrNrMrrrrs&cCsDt|tjr<|dkrtdtt|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) r8r_Pointerr9rRro_type_rQrJr )rCr>Z p_arr_typerrrrs cCsp|j}|drtd|ddkr*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.strideszstrided arrays not supportedversionz,only __array_interface__ version 3 supporteddatazreadonly arrays unsupportedZtypestrr>)Z__array_interface__r9rro from_addressZ__keep)rCZaiaddrreadonlyZ ctype_scalarZ result_typeresultrrrrs    )NNNN)N),rT__all__rZnumpyrr r rNr r Znumpy.core.multiarrayr rrrrrrrrrobjectZ _ndptr_baseZnumpy.core._internalcore _internalZnicZ_getintp_ctypec_void_pr/r1r6r7rIrdrrorrrrrrrrrrrsV3     L  u  6 )