o tBhv2@sddlmZddlZddlZddlZddlZddlZddlZddl m Z m Z m Z ddl mZddlmZmZddlm Z dd gZejd krGd nd Zd dZGddde ZGdddeZGdddeZGdddeZGdddeZGdddeZddZdd ZdS))absolute_importN) BaseHandlerregister unregister) numeric_types) b64decode b64encode)compatregister_handlersunregister_handlerslittle<>cCs|jj}|dkr tS|S)z%translate equals sign to native order=)dtype byteordernative_byteorder)arrrrk/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/jsonpickle/ext/numpy.py get_byteordersrc@eZdZddZddZdS)NumpyBaseHandlercCsNt|dr ||d<dSt|}d}||r!|t|d}||d<dS)Ntostringrz(numpy.record, )hasattrrr ustr startswithlen)selfrdataprefixrrr flatten_dtypes    zNumpyBaseHandler.flatten_dtypecCs&|d}|drt|}t|S)Nr){[)rast literal_evalnpr)r r!rrrr restore_dtype&s   zNumpyBaseHandler.restore_dtypeN)__name__ __module__ __qualname__r#r)rrrrrs rc@r)NumpyDTypeHandlercCs||||SN)r#r objr!rrrflatten.s zNumpyDTypeHandler.flattencCs ||Sr.)r))r r!rrrrestore2s zNumpyDTypeHandler.restoreNr*r+r,r1r2rrrrr--s r-c@r)NumpyGenericHandlercCs0||jd||jj|dd|d<|S)NNFresetvalue)r#r newbyteordercontextr1tolistr/rrrr17szNumpyGenericHandler.flattencCs$|jj|ddd}|||S)Nr8Fr6)r:r2r)type)r r!r8rrrr2<szNumpyGenericHandler.restoreNr3rrrrr46s r4c@s0eZdZdZddZddZddZdd Zd S) NumpyNDArrayHandlerz>Stores arrays as text representation, without regard for viewscCs|jjdur d|d<dSdS)NF writeable)flagsr>r/rrr flatten_flagsD  z!NumpyNDArrayHandler.flatten_flagscCs|dds d|j_dSdS)Nr>TF)getr?r>)r r!rrrr restore_flagsHrAz!NumpyNDArrayHandler.restore_flagscCsP||jd|||||jj|dd|d<d|jvr&|j|d<|S)Nr5Fr6valuesrshape)r#rr9r@r:r1r;rEr/rrrr1Ls    zNumpyNDArrayHandler.flattencCs`|jj|ddd}tj||||ddd}|dd}|dur(||}||||S)NrDFr6orderCrrFrE)r:r2r(arrayr)rBreshaperC)r r!rDrrErrrr2Vs   zNumpyNDArrayHandler.restoreN)r*r+r,__doc__r@rCr1r2rrrrr=As  r=csJeZdZdZdefddZddZddZfd d Zfd d Z Z S) NumpyNDArrayHandlerBinaryzstores arrays with size greater than 'size_threshold' as (optionally) compressed base64 Notes ----- This would be easier to implement using np.save/np.load, but that would be less language-agnostic cCs||_||_dS)a :param size_threshold: nonnegative int or None valid values for 'size_threshold' are all nonnegative integers and None if size_threshold is None, values are always stored as nested lists :param compression: a compression module or None valid values for 'compression' are {zlib, bz2, None} if compresion is None, no compression is applied N)size_threshold compression)r rNrOrrr__init__ms z"NumpyNDArrayHandlerBinary.__init__cCs$|jj}|dkrt||d<dSdS)N|r)rrr)r r0r!rrrrflatten_byteorderzsz+NumpyNDArrayHandlerBinary.flatten_byteordercCs&|dd}|r|j||_dSdS)Nr)rBrr9)r r!rrrrrrestore_byteorders z+NumpyNDArrayHandlerBinary.restore_byteordercs|jdus |j|jkrtt|||}|S|jtjkr&t |  }nt |dr2|j dd}n|jdd}|jrA|j|}t||d<|j|d<||jd||||||||jjsjd|d <|S) encode numpy to jsonNtobytesa)rFrDrEr5FrF)rNsizesuperrLr1rr(objectjsondumpsr;encoderrUrrOcompressr rEr#r9rRr@r? c_contiguous)r r0r!buf __class__rrr1s$$        z!NumpyNDArrayHandlerBinary.flattencs|d}t|trtt||}|St|tr%tj|g||d}|S||}t |}|j r7|j |}|tj kr_t |}tj|||ddd}|dd}|dur^||}ntj|||d|ddd}|||||||S) decode numpy from jsonrD)rrFrGrHrEN)bufferrrErF) isinstancelistrYrLr2rr(rIr)rrO decompressrZr[loadsdecoderBrJndarraycopyrSrC)r r!rDrrr`rErarrr2s:          z!NumpyNDArrayHandlerBinary.restore) r*r+r,rKzlibrPrRrSr1r2 __classcell__rrrarrLcs   *rLcs@eZdZdZddeffdd ZfddZfdd ZZS) NumpyNDArrayHandlerViewaPickles references inside ndarrays, or array-views Notes ----- The current implementation has some restrictions. 'base' arrays, or arrays which are viewed by other arrays, must be f-or-c-contiguous. This is not such a large restriction in practice, because all numpy array creation is c-contiguous by default. Relaxing this restriction would be nice though; especially if it can be done without bloating the design too much. Furthermore, ndarrays which are views of array-like objects implementing __array_interface__, but which are not themselves nd-arrays, are deepcopied with a warning (by default), as we cannot guarantee whatever custom logic such classes implement is correctly reproduced. warnrMcstt|||||_dS)aM :param mode: {'warn', 'raise', 'ignore'} How to react when encountering array-like objects whos references we cannot safely serialize :param size_threshold: nonnegative int or None valid values for 'size_threshold' are all nonnegative integers and None if size_threshold is None, values are always stored as nested lists :param compression: a compression module or None valid values for 'compression' are {zlib, bz2, None} if compresion is None, no compression is applied N)rYrnrPmode)r rprNrOrarrrPs z NumpyNDArrayHandlerView.__init__csb|j}|dur|jjrtt|||}|jjsd|d<|St|tj r|jjr|j j|dd|d<|j j |j j }|r@||d<|jjsI|j |d<|j|d <||jd ||||t|d krvt|t|krnd nd}|rv||d <|jdus|j|jkrtt||||S|jdkrd}t|n |jdkrd}t|tt|||}|S)rTNrWrFFr6baseoffsetstridesrEr5rQSrrozndarray is defined by reference to an object we do not know how to serialize. A deep copy is serialized instead, breaking memory aliasing.raisezMndarray is defined by reference to an object we do not know how to serialize.)rqr?forcrYrnr1r_rer(rjr:ctypesr!rsrEr#rr9r@rrNrXrLrpwarningsro ValueErrorrk)r r0r!rqrrrmsgrarrr1sB+       zNumpyNDArrayHandlerView.flattenc s|dd}|durtt||}|S|jj|dd}|jjs$Jdtj|j | | |dd|d|d d |d dd }| |||S) rcrqNFr6z8Current implementation assumes base is C or F contiguousrrQrErrrrs)rdrrErrrs) rBrYrnr2r:r?rvr(rjr!r)r9rC)r r!rqrrarrr2.s$    zNumpyNDArrayHandlerView.restore) r*r+r,rKrlrPr1r2rmrrrarrns  6rncCsttjtddttjtddttjtddtttjj tddtttj j tddtttj j tddtttj j tdddS)NT)rq) rr(rr-genericr4rjrnvoidrbfloat32int32 datetime64rrrrr HscCsjttjttjttjtttjjtttjjtttjjtttj jdSr.) rr(rr{rjr|rbr}r~rrrrrr Ss   ) __future__rr&sysrlrxr[numpyr(handlersrrrr rutilrr __all__rrrrr-r4r=rLrnr r rrrrs,     "ov