o %gI@sNdZgdZddlZddlZddlmZmZzddlZWn e y'dZYnwedur?ddZ e Z e Z e Z ddlmZeZnddlmmZeZ[ejZdd Z d d Zgd Zd dZGdddeZGdddeZiZd'ddZedurddZddZ e Z!ddZ"ddZ#ddZ$dd Z%d!d"Z&d(d#d$Z d%d&Z dSdS))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) _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)argskwdsr N/root/parts/websockify/install/lib/python3.10/site-packages/numpy/ctypeslib.py_dummyAs r)intpc Cs t|}t|}tj|d}|sFddl}ddl}d}|jdr'd}n|jdr/d}||g}|d }||ksE| d||n|g}tj |}tj |s\tj |}n|}|D] } tj || } tj| rztj| WStywq`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. rNz.sodarwinz.dylibwinz.dll EXT_SUFFIXzno file with expected extension)osfsdecodepathsplitextsys sysconfigplatform startswithget_config_varinsertabspathisdirdirnamejoinexistsctypescdllOSError) libname loader_pathextrrbase_ext libname_extso_extlibdirlnlibpathr r rrXs> "         rcCsd}|D]}|t|7}q|SNr)r)flaglistnumvalr r r_num_fromflagssr4) C_CONTIGUOUS F_CONTIGUOUSALIGNED WRITEABLEOWNDATAWRITEBACKIFCOPYcCs,g}tD]}t|}||@r||q|SN) _flagnamesrappend)r2reskeyvaluer r r_flags_fromnums rAc@seZdZeddZdS)_ndptrcCst|tjs td|jdur|j|jkrtd|j|jdur.|j|jkr.td|j|jdurB|j |jkrBtdt |j|j durZ|j j |j @|j krZtdt|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) isinstancenpndarray TypeError_dtype_dtype_ndim_ndim_shape_shapestr_flags_flagsr2rAr$)clsobjr r r from_params"        z_ndptr.from_paramN)__name__ __module__ __qualname__ classmethodrRr r r rrBsrBc@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)selfr r r_check_retval_sz_concrete_ndptr._check_retval_cCsHt|j|jf}tj|j}t|t|j }tj ||dj ddS)z Get an ndarray viewing the data pointed to by this pointer. This mirrors the `contents` attribute of a normal ctypes pointer rHr)axis) rDrHrGrKr$c_charitemsizecastPOINTERrX frombuffersqueeze)rY full_dtype full_ctypebufferr r rrXs z_concrete_ndptr.contentsN)rSrTrU__doc__rZpropertyrXr r r rrWs rWc Cs|dur t|}d}|durXt|tr|d}nt|ttjfr)|}t|}n t|tr5|j }t|}|durXz dd|D}Wnt yS}zt d|d}~wwt |}|durozt |}Wn t yn|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)a: 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.0xr r r ,zndpointer..zinvalid flags specificationanyz_%dd_rmcss|]}t|VqdSr;)rMrkr r r Jszndpointer..z ndpointer_%s)rGrKrIrN)rDrHrCrMsplitintintegerrAr r2 ExceptionrFr4tuple_pointer_type_cacheKeyErrornamesidr"rWrBtype) rHrJrLrOr2e cache_keynamebaseklassr r rrsn5               rcCs&|dddD] }||}d|_q|S)z7 Create an ndarray of the given element type and shape N)rT) element_typerLdimr r r_ctype_ndarray]src 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 )rDrH)rlctyper r r qroz(_get_scalar_type_map..)r$c_bytec_shortc_intc_long c_longlongc_ubytec_ushortc_uintc_ulong c_ulonglongc_floatc_doublec_bool)ct simple_typesr r r_get_scalar_type_mapfsrc 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__)rHdtype_with_endian dtype_nativerr}r r r_ctype_from_dtype_scalarws$    rcCs|j\}}t|}t||Sr;)subdtype_ctype_from_dtyper)rH element_dtyperLrr r r_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)NcSs|dSr0r )fr r rsz._ctype_from_dtype_structured..)r?rcss|] \}}}|dkVqdS)rNr )rloffsetrrr r rrrsz/_ctype_from_dtype_structured..runion)_fields__pack_rTzOverlapping fieldsstruct)rzfieldsr=rsortedlenallmaxr$sizeofr^r]r|Uniondictr Structure) rH field_datar field_dtypersizerr last_offsetpaddingr r r_ctype_from_dtype_structuredsH     rcCs,|jdur t|S|jdurt|St|Sr;)rrrrrr[r r rrs  rcCstt|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 Examples -------- Converting a simple dtype: >>> dt = np.dtype('int8') >>> ctype = np.ctypeslib.as_ctypes_type(dt) >>> ctype Converting a structured dtype: >>> dt = np.dtype([('x', 'i4'), ('y', 'f4')]) >>> ctype = np.ctypeslib.as_ctypes_type(dt) >>> ctype )rrDrHr[r r rrs6rcCsFt|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 Examples -------- Converting a ctypes integer array: >>> import ctypes >>> ctypes_array = (ctypes.c_int * 5)(0, 1, 2, 3, 4) >>> np_array = np.ctypeslib.as_array(ctypes_array) >>> np_array array([0, 1, 2, 3, 4], dtype=int32) Converting a ctypes POINTER: >>> import ctypes >>> buffer = (ctypes.c_int * 5)(0, 1, 2, 3, 4) >>> pointer = ctypes.cast(buffer, ctypes.POINTER(ctypes.c_int)) >>> np_array = np.ctypeslib.as_array(pointer, (5,)) >>> np_array array([0, 1, 2, 3, 4], dtype=int32) Nz=as_array() requires a shape argument when called on a pointer) rCr$_PointerrFr`r_type_r_rXrDasarray)rQrL p_arr_typer r rrs  rcCsp|j}|dr td|ddkrtd|d\}}|r!tdt|d}t||d }||}||_|S) a Create and return a ctypes object from a numpy array. Actually anything that exposes the __array_interface__ is accepted. Examples -------- Create ctypes object from inferred int ``np.array``: >>> inferred_int_array = np.array([1, 2, 3]) >>> c_int_array = np.ctypeslib.as_ctypes(inferred_int_array) >>> type(c_int_array) >>> c_int_array[:] [1, 2, 3] Create ctypes object from explicit 8 bit unsigned int ``np.array`` : >>> exp_int_array = np.array([1, 2, 3], dtype=np.uint8) >>> c_int_array = np.ctypeslib.as_ctypes(exp_int_array) >>> type(c_int_array) >>> c_int_array[:] [1, 2, 3] strideszstrided arrays not supportedversionz,only __array_interface__ version 3 supporteddatazreadonly arrays unsupportedtypestrrL)__array_interface__rFrr from_address__keep)rQaiaddrreadonly ctype_scalar result_typeresultr r rr1s    r)NNNNr;)'rf__all__rnumpyrDnumpy._core.multiarrayrr r$r rrrrrrobject _ndptr_basenumpy._core._internal_core _internalnic_getintp_ctypec_void_pr4r<rArBrWrxrrrrrrrrrr r r rsT3    J  u 6 9 )