ٔjғZdZddlZddlZddlmZddlmZddlmZddl m Z m Z ddlmZgd Ze jZd d d d d d d d d d d ddddZe jZeddZedGddZGdde jZedGddeZdZed d!dZed d!dZed d"dZdZed d"dZed d#d Z dS)$z< This module contains a set of functions for record arrays. N)Counter) nullcontext) set_module)numeric numerictypes)_get_legacy_print_mode) recordrecarray format_parser fromarrays fromrecords fromstringfromfilearrayfind_duplicate><=s|)blnBLNSrrrrrIiz numpy.reccXdt|DS)z@Find duplication in a list, return a list of duplicated elementsc$g|] \}}|dk |Sr).0itemcountss gC:\Users\Terasoftware\OneDrive\Desktop\faahhh\fyndo\fyndo\venv\Lib\site-packages\numpy/_core/records.py z"find_duplicate..1s6    D& A:     )ritems)lists r(rr.s5  #DMM//11   r*c.eZdZdZddZd dZdZdZdS) r a Class to convert formats, names, titles description to a dtype. After constructing the format_parser object, the dtype attribute is the converted data-type: ``dtype = format_parser(formats, names, titles).dtype`` Attributes ---------- dtype : dtype The converted data-type. Parameters ---------- formats : str or list of str The format description, either specified as a string with comma-separated format descriptions in the form ``'f8, i4, S5'``, or a list of format description strings in the form ``['f8', 'i4', 'S5']``. names : str or list/tuple of str The field names, either specified as a comma-separated string in the form ``'col1, col2, col3'``, or as a list or tuple of strings in the form ``['col1', 'col2', 'col3']``. An empty list can be used, in that case default field names ('f0', 'f1', ...) are used. titles : sequence Sequence of title strings. An empty list can be used to leave titles out. aligned : bool, optional If True, align the fields by padding as the C-compiler would. Default is False. byteorder : str, optional If specified, all the fields will be changed to the provided byte-order. Otherwise, the default byte-order is used. For all available string specifiers, see `dtype.newbyteorder`. See Also -------- numpy.dtype, numpy.typename Examples -------- >>> import numpy as np >>> np.rec.format_parser(['>> np.rec.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'], ... []).dtype dtype([('col1', '>> np.rec.format_parser(['.s7"7WWg&r*f1c,g|]}|dSrr$r%keyfieldss r(r)z/format_parser._parseFormats..s!:::c6#;q>:::r*c,g|]}|dSr#r$rAs r(r)z/format_parser._parseFormats..s!888CQ888r*) ValueError isinstancer,sbdtype enumeraterCr5 _f_formats_offsetslen_nfields)r3r4r7rHkeysrCs @r(r0zformat_parser._parseFormatszs  6455 5 gt $ $ /H&/&8&8 EEHWg..E  "HtUm_g66E\F{::::T:::88884888 D  r*c|rt|ttfvrnJt|tr|d}nt dt|d|d|jD|_ ng|_ |xj dtt|j |jDz c_ t|j }|rtd||rd|d|jD|_n g|_g}|jt|kr+|xjdg|jt|z zz c_dSdS)zQconvert input field names into a list and assign to the _names attribute ,zillegal input names c6g|]}|Sr$stripr%rs r(r)z0format_parser._setfieldnames..s DDD17799DDDr*Ncg|]}d|zS)zf%dr$)r%r s r(r)z0format_parser._setfieldnames..s.AAAa AAAr*zDuplicate field names: c6g|]}|Sr$rRrTs r(r)z0format_parser._setfieldnames..s FFF!AGGIIFFFr*)typer,tuplerFstrsplit NameErrorreprrM_namesrangerLrrE_titles)r3r5r6_dups r(r1zformat_parser._setfieldnamess  E{{tUm+ FE3'' F C(( DtE{{ D DEEEDDeNT]N.CDDDDKKDK AA5T[1A1A15,@,@AAA A dk**  ?=t==>> >  FFvnt}n/EFFFDLLDLF =3v;; & C LLTFdmc&kk&AB BLLLL C Cr*ctj|j|j|j|jd}|(t |d}||}||_dS)N)r5r4offsetsr6r)rGrHr]rJrKr__byteorderconv newbyteorder)r3r8rHs r(r2zformat_parser._createdtypesg[}l       2&y|4I&&y11E r*)FN)F)__name__ __module__ __qualname____doc__r9r0r1r2r$r*r(r r 8si99v%%%% """"0"C"C"CH     r*r cLeZdZdZdZdZfdZfdZdZdZdZdZ xZ S) r zEA data-type scalar that allows field access as attribute lookup. numpyctdkr|StSNq)r __str__super__repr__r3 __class__s r(rpzrecord.__repr__s: ! # #s * "<<>> !ww!!!r*ctdkr!t|StSrl)r rYr&rornrqs r(rnzrecord.__str__s@ ! # #s * $tyy{{## #ww   r*c|dvr tj||S tj||S#t$rYnwxYwtj|dj}||d}|rW|j|dd} |j}n#t$r|cYSwxYw|j!| |j |jfS|Std|d)NsetfieldgetfieldrHrH"'record' object has no attribute '') ntvoid__getattribute__AttributeErrorrCgetrwrHr5viewrr)r3attr fielddictresobjdts r(r}zrecord.__getattribute__s) 4 4 87++D$77 7 7++D$77 7    D G,,T7;;B mmD$''  O$-RaR)C Y!     x =xx ;<<<J !Md!M!M!MNN Ns#A AA&B.. B=<B=c`|dvrtd|dtj|dj}||d}|r|j|g|ddRSt||dr!tj|||Std|d)Nruz Cannot set 'z ' attributerHrxryrz) r~r{r|r}rCrrvgetattr __setattr__)r3rvalrrs r(rzrecord.__setattr__s 4 4 C !A!A!A!ABB BG,,T7;;B mmD$''  O 4=/s2A2w/// / T4 & & O7&&tT377 7 !Md!M!M!MNN Nr*ctj||}t|tjr-|jj!||j|jfS|Sr/)r{r| __getitem__rFrHr5rrr)r3indxrs r(rzrecord.__getitem__s\g!!$-- c27 # #   88T^SY788 8Jr*cjj}td|D}d|zfd|D}d|S)zPretty-print all fields.c34K|]}t|VdSr/)rL)r%names r( z record.pprint.. s(114SYY111111r*z %% %ds: %%sc:g|]}|t|fzSr$)r)r%rfmtr3s r(r)z!record.pprint.. s-DDDdtWT40011DDDr* )rHr5maxjoin)r3r5maxlenrowsrs` @r(pprintz record.pprintsb  11511111f$DDDDDeDDDyyr*) rerfrgrhrprnr}rrr __classcell__rrs@r(r r s HJ""""" !!!!! OOO0 O O Or*r cPeZdZdZ d dZdZdZd Zfd Zd Z dd Z xZ S)r aSConstruct an ndarray that allows field access using attributes. Arrays may have a data-types containing fields, analogous to columns in a spread sheet. An example is ``[(x, int), (y, float)]``, where each entry in the array is a pair of ``(int, float)``. Normally, these attributes are accessed using dictionary lookups such as ``arr['x']`` and ``arr['y']``. Record arrays allow the fields to be accessed as members of the array, using ``arr.x`` and ``arr.y``. Parameters ---------- shape : tuple Shape of output array. dtype : data-type, optional The desired data-type. By default, the data-type is determined from `formats`, `names`, `titles`, `aligned` and `byteorder`. formats : list of data-types, optional A list containing the data-types for the different columns, e.g. ``['i4', 'f8', 'i4']``. `formats` does *not* support the new convention of using types directly, i.e. ``(int, float, int)``. Note that `formats` must be a list, not a tuple. Given that `formats` is somewhat limited, we recommend specifying `dtype` instead. names : tuple of str, optional The name of each column, e.g. ``('x', 'y', 'z')``. buf : buffer, optional By default, a new array is created of the given shape and data-type. If `buf` is specified and is an object exposing the buffer interface, the array will use the memory from the existing buffer. In this case, the `offset` and `strides` keywords are available. Other Parameters ---------------- titles : tuple of str, optional Aliases for column names. For example, if `names` were ``('x', 'y', 'z')`` and `titles` is ``('x_coordinate', 'y_coordinate', 'z_coordinate')``, then ``arr['x']`` is equivalent to both ``arr.x`` and ``arr.x_coordinate``. byteorder : {'<', '>', '='}, optional Byte-order for all fields. aligned : bool, optional Align the fields in memory as the C-compiler would. strides : tuple of ints, optional Buffer (`buf`) is interpreted according to these strides (strides define how many bytes each array element, row, column, etc. occupy in memory). offset : int, optional Start reading buffer (`buf`) from this offset onwards. order : {'C', 'F'}, optional Row-major (C-style) or column-major (Fortran-style) order. Returns ------- rec : recarray Empty array of the given shape and type. See Also -------- numpy.rec.fromrecords : Construct a record array from data. numpy.record : fundamental data-type for `recarray`. numpy.rec.format_parser : determine data-type from formats, names, titles. Notes ----- This constructor can be compared to ``empty``: it creates a new record array but does not fill it with data. To create a record array from data, use one of the following methods: 1. Create a standard ndarray and convert it to a record array, using ``arr.view(np.recarray)`` 2. Use the `buf` keyword. 3. Use `np.rec.fromrecords`. Examples -------- Create an array with two fields, ``x`` and ``y``: >>> import numpy as np >>> x = np.array([(1.0, 2), (3.0, 4)], dtype=[('x', '>> x array([(1., 2), (3., 4)], dtype=[('x', '>> x['x'] array([1., 3.]) View the array as a record array: >>> x = x.view(np.recarray) >>> x.x array([1., 3.]) >>> x.y array([2, 4]) Create a new, empty record array: >>> np.recarray((2,), ... dtype=[('x', int), ('y', float), ('z', int)]) #doctest: +SKIP rec.array([(-1073741821, 1.2249118382103472e-301, 24547520), (3471280, 1.2134086255804012e-316, 0)], dtype=[('x', '4:?BG44 >&( =Xrw &;<< !F,CC F=C 9q= 2DJ$. 2/VCAAACC2tDJ//11C C#f++% % ! # #s * rBc2z***r*c`t|tr(t|dj}||}t|dj}||dd}|2|j|}|jj|S|tS|j |g|RS)NrHrx) rFintrr}r5rCrwrHrrv)r3rrr5rrrs r(fieldzrecarray.fields dC  ,,T7;;AE;D,,T7;;B obqb!  ,$-%Cy  88G$$ $ 4=+s+++ +r*) NNrNNNNNFrr/) rerfrgrhrrr}rrrprrrs@r(r r sggRIM1558,$$$ %%%D#(#(#(J""+"+"+H,,,,,,,,r*r cN|dkrtjdtddS|S)NrzPassing `shape=0` to have the shape be inferred is deprecated, and in future will be equivalent to `shape=(0,)`. To infer the shape and suppress this warning, pass `shape=None` instead. stacklevel)warningswarn FutureWarning)rs r(_deprecate_shape_0_as_Noner,s@ z  N a  ) ) ) ) t r*Fcd|D}t|}||dj}nt|tr|f}|| d|D}|t j|}nt |||||j}|j} t|t|krtd|dj} t| } | dkr |d| }t||} t|D]R\} }|| j } |jd|j | z }| | }||krtd| d|d|| |<S| S) aCreate a record array from a (flat) list of arrays Parameters ---------- arrayList : list or tuple List of array-like objects (such as lists, tuples, and ndarrays). dtype : data-type, optional valid dtype for all arrays shape : int or tuple of ints, optional Shape of the resulting array. If not provided, inferred from ``arrayList[0]``. formats, names, titles, aligned, byteorder : If `dtype` is ``None``, these arguments are passed to `numpy.rec.format_parser` to construct a dtype. See that function for detailed documentation. Returns ------- np.recarray Record array consisting of given arrayList columns. Examples -------- >>> x1=np.array([1,2,3,4]) >>> x2=np.array(['a','dd','xyz','12']) >>> x3=np.array([1.1,2,3,4]) >>> r = np.rec.fromarrays([x1,x2,x3],names='a,b,c') >>> print(r[1]) (2, 'dd', 2.0) # may vary >>> x1[1]=34 >>> r.a array([1, 2, 3, 4]) >>> x1 = np.array([1, 2, 3, 4]) >>> x2 = np.array(['a', 'dd', 'xyz', '12']) >>> x3 = np.array([1.1, 2, 3,4]) >>> r = np.rec.fromarrays( ... [x1, x2, x3], ... dtype=np.dtype([('a', np.int32), ('b', 'S3'), ('c', np.float32)])) >>> r rec.array([(1, b'a', 1.1), (2, b'dd', 2. ), (3, b'xyz', 3. ), (4, b'12', 4. )], dtype=[('a', '.is 2221A222r*Nrcg|] }|j Sr$r)r%rs r(r)zfromarrays..vs22239222r*z>mismatch between the number of fields and the number of arrayszarray-shape mismatch in array z ("z")) rrrFrrGrHr r5rLrEr rIndim) arrayListrHrr4r5r6r7r8rr]d0nn_arraykr testshapers r(r r 8sb32 222I 'u - -E ! " E3  35332 222 PgufgyIIO [F 5zzS^^#,+,, , qB RB Avdsd  eU # #FI&&3 1X]Insx"}n- ay   NLaLLDLLLMM Mt Mr*c R|Y|Wtj|tfdtjdD}t |||||||S|tjt|f} nt|||||j} tj|| } || j|kr|| _n#ttf$rt|}|t|}t|tr|f}t|dkrtdt|| } t| jD]} t#|| | | <t%jdt(d | cYSwxYw| t} | S) aCreate a recarray from a list of records in text form. Parameters ---------- recList : sequence data in the same field may be heterogeneous - they will be promoted to the highest data type. dtype : data-type, optional valid dtype for all arrays shape : int or tuple of ints, optional shape of each array. formats, names, titles, aligned, byteorder : If `dtype` is ``None``, these arguments are passed to `numpy.format_parser` to construct a dtype. See that function for detailed documentation. If both `formats` and `dtype` are None, then this will auto-detect formats. Use list of tuples rather than list of lists for faster processing. Returns ------- np.recarray record array consisting of given recList rows. Examples -------- >>> r=np.rec.fromrecords([(456,'dbe',1.2),(2,'de',1.3)], ... names='col1,col2,col3') >>> print(r[0]) (456, 'dbe', 1.2) >>> r.col1 array([456, 2]) >>> r.col2 array(['dbe', 'de'], dtype='>> import pickle >>> pickle.loads(pickle.dumps(r)) rec.array([(456, 'dbe', 1.2), ( 2, 'de', 1.3)], dtype=[('col1', '.sD   /0BHSa['')) * *   r*)r4rr5r6r7r8rzCan only deal with 1-d array.zxfromrecords expected a list of tuples, may have received a list of lists instead. In the future that will raise an errorrxr)rGrrr^rr rHr r rrErrLrFrr rrXrrrr)recListrHrr4r5r6r7r8arrlistrretvalrrrrs @r(rrs XO5Ohwf---    49#)B-4H4H   '7%u!'IOOO O &%)) UFGY   !'///*  !!6 ! FL+ z "*511  !LLE eS ! ! HE u::> ><== =%''v{## * *Agaj))F1II   G a ) ) ) ) %. ++h  C JsB??CF  F c ||td|tj|} nt|||||j} | j} t |}|dvrt ||z | z}t|| ||} | S)aCreate a record array from binary data Note that despite the name of this function it does not accept `str` instances. Parameters ---------- datastring : bytes-like Buffer of binary data dtype : data-type, optional Valid dtype for all arrays shape : int or tuple of ints, optional Shape of each array. offset : int, optional Position in the buffer to start reading from. formats, names, titles, aligned, byteorder : If `dtype` is ``None``, these arguments are passed to `numpy.format_parser` to construct a dtype. See that function for detailed documentation. Returns ------- np.recarray Record array view into the data in datastring. This will be readonly if `datastring` is readonly. See Also -------- numpy.frombuffer Examples -------- >>> a = b'\x01\x02\x03abc' >>> np.rec.fromstring(a, dtype='u1,u1,u1,S3') rec.array([(1, 2, 3, b'abc')], dtype=[('f0', 'u1'), ('f1', 'u1'), ('f2', 'u1'), ('f3', 'S3')]) >>> grades_dtype = [('Name', (np.str_, 10)), ('Marks', np.float64), ... ('GradeLevel', np.int32)] >>> grades_array = np.array([('Sam', 33.3, 3), ('Mike', 44.4, 5), ... ('Aadi', 66.6, 6)], dtype=grades_dtype) >>> np.rec.fromstring(grades_array.tobytes(), dtype=grades_dtype) rec.array([('Sam', 33.3, 3), ('Mike', 44.4, 5), ('Aadi', 66.6, 6)], dtype=[('Name', '>> s = '\x01\x02\x03abc' >>> np.rec.fromstring(s, dtype='u1,u1,u1,S3') Traceback (most recent call last): ... TypeError: a bytes-like object is required, not 'str' Nz2fromstring() needs a 'dtype' or 'formats' argument)Nr)rr)rrGrHr itemsizerrLr ) datastringrHrrr4r5r6r7r8rrrs r(rrsp NNLMMM PgufgyIIO~H 'u - -E 7Z6)h6 eU 6 B B BF Mr*c|} |dd||z ||dS#||dwxYw)Nrrx)tellseek)fdposs r(get_remaining_sizer;s] ''))C 1 wwyy3 QQs ,AA1c ||tdt|}|d}nt|tr|f}t |drt |} n"t tj|d} | 5}|dkr| |dt|} |tj |} nt|||||j } | j} tj|t"j} | | z}|dkrlt'|}| | z||d <t+|}tj|t"j} | | z}|| krt-d t/|| }||j}||krt5d  dddn #1swxYwY|S) aCreate an array from binary file data Parameters ---------- fd : str or file type If file is a string or a path-like object then that file is opened, else it is assumed to be a file object. The file object must support random access (i.e. it must have tell and seek methods). dtype : data-type, optional valid dtype for all arrays shape : int or tuple of ints, optional shape of each array. offset : int, optional Position in the file to start reading from. formats, names, titles, aligned, byteorder : If `dtype` is ``None``, these arguments are passed to `numpy.format_parser` to construct a dtype. See that function for detailed documentation Returns ------- np.recarray record array consisting of data enclosed in file. Examples -------- >>> from tempfile import TemporaryFile >>> a = np.empty(10,dtype='f8,i4,a5') >>> a[5] = (0.5,10,'abcde') >>> >>> fd=TemporaryFile() >>> a = a.view(a.dtype.newbyteorder('<')) >>> a.tofile(fd) >>> >>> _ = fd.seek(0) >>> r=np.rec.fromfile(fd, formats='f8,i4,a5', shape=10, ... byteorder='<') >>> print(r[5]) (0.5, 10, b'abcde') >>> r.shape (10,) Nz0fromfile() needs a 'dtype' or 'formats' argument)rreadintorbrrrrz;Not enough bytes left in file for specified shape and type.z%Didn't read as many bytes as expected)rrrFrhasattrropenosfspathrrrGrHr rrprodr{intpr,indexrXrEr rdataOSError)rrHrrr4r5r6r7r8ctxrrr shapeprod shapesizenbytesr nbytesreads r(rrDso\ LLJKKK 'u - -E  E3  r:("oo29R==$'' "C A:  GGFA   !"%%  HUOOEE! >HUOO((rw(77 ( q= <KKE%)iZ%7E%++b// "%LLE,,27,;;IX% D= &  %''[[--   CABB B CC"C"C"C"C"C"C"C"C"C"C"C"C"C"C"CH MsE$G55G9<G9Tc *t|tdtfst|dr||t di} |t j|}n#|t||||| j}n||||| d} |%|t dt|||||St|trt||f||d| St|ttfrBt|dttfrt|f||d | St|f||d | St|tr=|!|j|kr||} n|} | r| } | St|drt#|||| St|t$rU|!|j|kr||} n|} | r| } | tSt'|d d} | t| t(st d t j|}| |j|kr||}|tS) a Construct a record array from a wide-variety of objects. A general-purpose record array constructor that dispatches to the appropriate `recarray` creation function based on the inputs (see Notes). Parameters ---------- obj : any Input object. See Notes for details on how various input types are treated. dtype : data-type, optional Valid dtype for array. shape : int or tuple of ints, optional Shape of each array. offset : int, optional Position in the file or buffer to start reading from. strides : tuple of ints, optional Buffer (`buf`) is interpreted according to these strides (strides define how many bytes each array element, row, column, etc. occupy in memory). formats, names, titles, aligned, byteorder : If `dtype` is ``None``, these arguments are passed to `numpy.format_parser` to construct a dtype. See that function for detailed documentation. copy : bool, optional Whether to copy the input object (True), or to use a reference instead. This option only applies when the input is an ndarray or recarray. Defaults to True. Returns ------- np.recarray Record array created from the specified object. Notes ----- If `obj` is ``None``, then call the `~numpy.recarray` constructor. If `obj` is a string, then call the `fromstring` constructor. If `obj` is a list or a tuple, then if the first object is an `~numpy.ndarray`, call `fromarrays`, otherwise call `fromrecords`. If `obj` is a `~numpy.recarray`, then make a copy of the data in the recarray (if ``copy=True``) and use the new formats, names, and titles. If `obj` is a file, then call `fromfile`. Finally, if obj is an `ndarray`, then return ``obj.view(recarray)``, making a copy of the data if ``copy=True``. Examples -------- >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> a array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> np.rec.array(a) rec.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=int64) >>> b = [(1, 1), (2, 4), (3, 9)] >>> c = np.rec.array(b, formats = ['i2', 'f2'], names = ('x', 'y')) >>> c rec.array([(1, 1.), (2, 4.), (3, 9.)], dtype=[('x', '>> c.x array([1, 2, 3], dtype=int16) >>> c.y array([1., 4., 9.], dtype=float16) >>> r = np.rec.array(['abc','def'], names=['col1','col2']) >>> print(r.col1) abc >>> r.col1 array('abc', dtype='>> r.col2 array('def', dtype='r s """"""######////////......    *  (  K KHHHHHHHHVHHHHHRWHHHf KQ,Q,Q,Q,Q,wQ,Q,Q,h    K:>AE[[[[| KEI6:UUUUp KEIAEHHHHT K;??CeeeeP KGKGKR"R"R"R"R"R"r*