o 0c4D@sbdZgdZddlZddlmZmZmZmZm Z ddl m Z m Z zddl Z Wn ey1dZ Ynwe durIddZeZeZeZddlmZeZnddlmmZeZ[e jZd d Zd d Zgd ZddZGdddeZ Gddde Z!iZ"d(ddZ#e durddZ$ddZ%e%Z&ddZ'ddZ(ddZ)d d!Z*d"d#Z+d)d$d%Zd&d'ZdSdS)*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) _flagdictflagsobjcOstd)z Dummy object that raises an ImportError if ctypes is not available. Raises ------ ImportError If ctypes is not available. zctypes is not available.) ImportError)argskwdsrE/var/www/html/gps/gps/lib/python3.10/site-packages/numpy/ctypeslib.py_dummyCs r)intpc Cstjdkrddl}|jdddt|}t|}tj|d}|sDddlm }|}||g}|d d }||ksC| d||n|g}tj |}tj |sZtj |}n|}|D] } tj|| } tj| r~ztj| WSty}wq^td ) 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) is_python_extzno file with expected extension)ctypes __version__warningswarnosfsdecodepathsplitextnumpy.distutils.misc_utilrinsertabspathisdirdirnamejoinexistscdllOSError) libname loader_pathrextrso_ext libname_extso_ext2libdirlnlibpathrrrrZs> !         rcCsd}|D]}|t|7}q|SNr)r )flaglistnumvalrrr_num_fromflagssr9) C_CONTIGUOUS F_CONTIGUOUSALIGNED WRITEABLEOWNDATAWRITEBACKIFCOPYcCs,g}tD]}t|}||@r||q|SN) _flagnamesr append)r7reskeyvaluerrr_flags_fromnums rFc@seZdZeddZdS)_ndptrcCst|ts td|jdur|j|jkrtd|j|jdur-|j|jkr-td|j|jdurA|j|jkrAtdt |j|j durY|j j |j @|j krYtdt |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_flagsr7rFr)clsobjrrr from_params*        z_ndptr.from_paramN)__name__ __module__ __qualname__ classmethodrTrrrrrGsrGc@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)axis) _dtyperJrMrc_charitemsizecastPOINTERrZr squeeze)r[ full_dtype full_ctypebufferrrrrZs z_concrete_ndptr.contentsN)rUrVrW__doc__r\propertyrZrrrrrYs rYc Cs|durt|}d}|durVt|tr|d}nt|ttfr'|}t|}n t|tr3|j}t|}|durVz dd|D}Wnt yQ}zt d|d}~wwt |}|durmzt |}Wn t yl|f}Ynw||||f}zt |WStyYnw|durd}n|jdurtt|}n|j}|dur|d|7}|dur|dd d d |D7}|dur|dd|7}|dur|durt}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_rocss|]}t|VqdSr@)rOrmrrr Nszndpointer..z ndpointer_%s)rJrMrKrP)r_rHrOsplitintrrFrr7 ExceptionrIr9tuple_pointer_type_cacheKeyErrornamesidr(rYrGtype) r rLrNrQr7e cache_keynamebaseklassrrrrsn5              rcCs&|dddD] }||}d|_q|S)z7 Create an ndarray of the given element type and shape N)rV) element_typerNdimrrr_ctype_ndarrayasrc 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)r_)rnctyperrr usz(_get_scalar_type_map..)rc_bytec_shortc_intc_long c_longlongc_ubytec_ushortc_uintc_ulong c_ulonglongc_floatc_doublec_bool)ct simple_typesrrr_get_scalar_type_mapjsrc Csx|dd}|d}zt|}Wnty'}ztd|dd}~ww|jdkr2|j}|S|jdkr:|j}|S)NS=z Converting {!r} to a ctypes type><) newbyteorder_scalar_type_mapryNotImplementedErrorformat byteorder __ctype_be__ __ctype_le__)r dtype_with_endian dtype_nativerr}rrr_ctype_from_dtype_scalar{s$    rcCs|j\}}t|}t||Sr@)subdtype_ctype_from_dtyper)r element_dtyperNrrrr_ctype_from_dtype_subarrays  rc Csg}|jD]}|j|dd\}}|||t|fqt|ddd}t|dkrltdd|Drld}g}|D]\}}}|||ft|t |}q:|j |kr_|d tj |j ft d tj ft|ddd Sd}g}|D]-\}}}||} | dkrtd | dkr|d tj | f|||f|t |}qr|j |} | dkr|d tj | ft d tjft|ddd S)NrcSs|dSr5r)frrrsz._ctype_from_dtype_structured..)rDrcss|] \}}}|dkVqdS)rNr)rnoffsetrrrrrrssz/_ctype_from_dtype_structured..runion)_fields__pack_rVzOverlapping fieldsstruct)rzfieldsrBrsortedlenallmaxrsizeofrar`r|Uniondictr Structure) r field_datar field_dtypersizerr last_offsetpaddingrrr_ctype_from_dtype_structuredsH     rcCs,|jdur t|S|jdurt|St|Sr@)rrrrrr]rrrrs  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 )rr_r]rrrrs &rcCsDt|tjr|durtdtt|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) rHr_PointerrIrcr_type_rbrZr )rSrN p_arr_typerrrrs rcCsp|j}|dr td|ddkrtd|d\}}|r!tdt|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 unsupportedtypestrrN)__array_interface__rIrr from_address__keep)rSaiaddrreadonly ctype_scalar result_typeresultrrrrs    r)NNNNr@),rh__all__rnumpyrr r r_r r numpy.core.multiarrayr rrrrrrrrrobject _ndptr_basenumpy.core._internalcore _internalnic_getintp_ctypec_void_pr9rArFrGrYrxrrrrrrrrrrrrrsT3    L  u 6 )