hSrSSKrSSKJr SSKJr SSKJr SSKJ r SS KJ r SS K Jr SS KJr /S Qr\ R$rS SSS SSSSS SSSSSS.r\ R(rSr\"S5"SS55r"SS\ R05r"SS\5rSr\"S5S#Sj5r\"S5S#Sj5r\"S5S$Sj5rS r\"S5S$S!j5r \"S5S%S"j5r!g)&a Record Arrays ============= Record arrays expose the fields of structured arrays as properties. Most commonly, ndarrays contain elements of a single type, e.g. floats, integers, bools etc. However, it is possible for elements to be combinations of these using structured types, such as:: >>> a = np.array([(1, 2.0), (1, 2.0)], dtype=[('x', np.int64), ('y', np.float64)]) >>> a array([(1, 2.), (1, 2.)], dtype=[('x', '>> a['x'] array([1, 1]) >>> a['y'] array([2., 2.]) Record arrays allow us to access fields as properties:: >>> ar = np.rec.array(a) >>> ar.x array([1, 1]) >>> ar.y array([2., 2.]) N)Counter) nullcontext) set_module)numeric) numerictypes) os_fspath)_get_legacy_print_mode)recordrecarray format_parser fromarrays fromrecords fromstringfromfilearray><=s|)blnBLNSrrrrrIicz[U5R5VVs/sHupUS:dM UPM snn$s snnf)z@Find duplication in a list, return a list of duplicated elementsr)ritems)listitemcountss L/var/www/fran/franai/venv/lib/python3.13/site-packages/numpy/core/records.pyfind_duplicater(Ns?$DM//1 1LD A: 1  s 77numpyc8\rSrSrSrS SjrS SjrSrSrSr g) rWa 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, a5'``, or a list of format description strings in the form ``['f8', 'i4', 'a5']``. 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 -------- dtype, typename, sctype2char Examples -------- >>> np.format_parser(['>> np.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'], ... []).dtype dtype([('col1', '>> np.format_parser(['G>PQ>P %,,q/7+>PQE HHW.E >HHtUm_g6E\\F{{59:Tc#;q>T:3784CQ48 D  R;8sD D#Dc`U(a[U5[[4;aO>[U[5(aUR S5nO[ S[U5-5eUSURVs/sHo3R5PM snUl O/Ul U=R[[UR5UR5Vs/sHnSU-PM sn- sl [UR5nU(a[SU-5eU(a3USURVs/sHo3R5PM snUlO /Ul/nUR[U5:a0U=RS/UR[U5- -- slggs snfs snfs snf)zIconvert input field names into a list and assign to the _names attribute ,zillegal input names %sNzf%dzDuplicate field names: %s)typer$tupler=strsplit NameErrorreprrFstrip_namesrangerEr(r<_titles)r1r3r4rr!_dups r'r/format_parser._setfieldnamessg E{tUm+E3'' C( 84; FGG.3NT]].CD.C779.CDDKDK 5T[[1A15,@A,@a ,@A A dkk* 84?@ @ /5nt}}/EF/E!GGI/EFDLDLF ==3v; & LLTFdmmc&k&AB BL '+EAGs1F!F&,F+c[R"URURURUR S.5nUb[ USnURU5nX lg)N)r3r2offsetsr4r)r>r?rTrCrDrV_byteorderconv newbyteorder)r1r6r?s r'r0format_parser._createdtypes\[[}}ll     &y|4I&&y1E r9)rCrTrFrDrVr?)FN)F) __name__ __module__ __qualname____firstlineno____doc__r7r.r/r0__static_attributes__r9r'rrWs8t% "*"CH r9rcX^\rSrSrSrSrSrU4SjrU4SjrSrSrSr S r S r U=r $) r zEA data-type scalar that allows field access as attribute lookup. r)c\>[5S::aUR5$[TU] 5$Nq)r __str__super__repr__r1 __class__s r'rlrecord.__repr__s( ! #s *<<> !w!!r9cn>[5S::a[UR55$[TU]5$rh)r rOr%rkrjrms r'rjrecord.__str__s, ! #s *tyy{# #w  r9cUS;a[RRX5$[RRX5$![a Of=f[RRUS5RnUR US5nU(ahUR "USS6nURnO![a Us$f=fURb'URURUR45$U$[SU-5e)Nsetfieldgetfieldr?r?r%'record' object has no attribute '%s') ntvoid__getattribute__AttributeErrorrBgetrur?r3viewrn)r1attr fielddictresobjdts r'ryrecord.__getattribute__s 4 477++D7 7 77++D7 7   GG,,T7;BB mmD$' --Ra)C YY!   xx#xx ;<<J "%'+",- -s#A AA, B99 CCcZUS;a[SU-5e[RRUS5RnUR US5nU(aUR "U/USSQ76$[XS5(a [RRXU5$[SU-5e)NrszCannot set '%s' attributer?rrv) rzrwrxryrBr{rtgetattr __setattr__)r1r}valr~rs r'rrecord.__setattr__ s 4 4 !URR b'UR URUR45$U$r-)rwrx __getitem__r=r?r3r|rn)r1indxrs r'rrecord.__getitem__sYgg!!$- c277 # # (C88T^^SYY78 8Jr9c URRn[SU55nSU-nUVs/sHoCU[X54-PM nnSR U5$s snf)zPretty-print all fields.c38# UHn[U5v M g7fr-)rE).0names r' record.pprint..'s154SYY5sz %% %ds: %%s )r?r3maxrjoin)r1r3maxlenfmtrrowss r'pprint record.pprint#sb   1511f$>CDedtWT011eDyyEsArd) r^r_r`rarbrlrjryrrrrc __classcell__rns@r'r r s7 HJ" ! -2 1r9r cf^\rSrSrSrSrSrS SjrSrSrSrU4Sjr S r S S jr S r U=r $)r i4a Construct 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 -------- core.records.fromrecords : Construct a record array from data. record : fundamental data-type for `recarray`. format_parser : determine a 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``: >>> 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', 'r?rndarray__new__r )subtypeshaper?bufrrr2r3r4r6r5rdescrr1s r'rrecarray.__new__sz  HHUOE!'&9MSSE ;??7FE?%?PD  ??7FE?-0.5#DD r9cURR[La*URRbURUlgggr-)r?rMr r3)r1rs r'__array_finalize__recarray.__array_finalize__s7 ::??& (TZZ-=-=-IDJ.J (r9c,[RX5$![a Of=f[RUS5RnX!SSnO'![ [ 4an[SU-5UeSnAff=fUR"U6nURRbd[URR[R5(a/URURRUR4S9$U$UR[5$)Nr?rzrecarray has no attribute %sr?)objectryrzrrB TypeErrorKeyErrorrur?r3 issubclassrMrwrxr|)r1r}r~rers r'ryrecarray.__getattribute__s **46 6   ,,T7;BB  O/"1%C8$ O !?$!FGQ N OmmS! 99?? &#)).."''22xxtzz &BxCCJ88G$ $s$ $$AA4 A//A4cUS:XaR[UR[R5(a)URb[ R "[U45nXR;n[RXU5n[RUS5R=(d 0nX;aU$U(a[RX5 OXQSSnUR&"U/UQ76$![a Us$f=f![a2 [RUS5R=(d 0nX;aeNhf=f![ ["4an[%SU-5UeSnAff=f)Nr?rz record array has no attribute %s)rrMrwrxr3r>r?r __dict__rrrryrB __delattr__ Exceptionrrrzrt)r1r}rnewattrretr~rrs r'rrecarray.__setattr__sJ 7?z#((BGG<<AV((FC=)Cmm+ $$T5C  00w?FFL"I$ &&t2  /"1%C }}S'3''!J 00w?FFL"I$% "8$  2T9  s<(C:6C(D9( C76C7:9D65D69E EEc>[TU]U5n[U[5(aURR b~UR [U55n[URR[R5(a/UR URRUR4S9$U$UR [S9$U$)Nr)rM) rkrr=rr?r3r|rMrrwrx)r1rrrns r'rrecarray.__getitem__sg!$' c7 # #yy*hhtDz*ciinnbgg66884::??CII*F8GG xxWx--Jr9c4URnURR[Ld3[URR[R 5(d>UR[La&[ R"[R U45nSnSnOSnSnURS:dURS:Xa[ R"USUSS 9nOS [UR5<3nS S [U5--n[5S ::aS U-nX4XQ4-$)Nz rec.array(zrec.array(%s,%sdtype=%s)zarray(z)array(%s,%sdtype=%s).view(numpy.recarray)r)rz, rL) separatorprefixsuffixz [], shape=r ri) r?rMr rrwrxr>sizer array2stringrRrEr )r1 repr_dtyperrlstlfs r'rlrecarray.__repr__ sZZ ::??f $Jtzz,P,P &(XXrww &;< !F,C F=C 99q=DJJ$.//VCAC/ %)$46C #c&k/ ! ! #s *rB2***r9ch[U[5(a$[RUS5RnX1n[RUS5R nXASSnUc=UR "U6nURRbU$UR[5$UR"U/UQ76$)Nr?r) r=intrryr3rBrur?r|rt)r1r}rr3r~rrs r'fieldrecarray.field.s dC ,,T7;AAE;D,,T7;BB obq! ;--%Cyy* 88G$ $==+s+ +r9r) NNrNNNNNFCr-)r^r_r`rarbrrryrrrlrrcrrs@r'r r 4sJfTHJHL1558"$ %D(B"+B,,r9r cHUS:Xa"S[SS9 gU$)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  )  r9z numpy.reccUVs/sHn[R"U5PM nn[U5nUcUSRnO[ U[ 5(aU4nUcUcUV s/sHoR PM nn Ub[R "U5n O[X4XVU5R n U Rn [U 5[U5:wa [S5eU SRn [U 5n U S:aUSU *n[X*5n[U5HOupXRn U RSU RU - nXnUU:wa[SUSUS35eXU'MQ U$s snfs sn f)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.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.core.records.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.core.records.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', 'mismatch between the number of fields and the number of arrayszarray-shape mismatch in array z ("z"))r>asarrayrrr=rr?rr3rEr<r r@ndim) arrayListr?rr2r3r4r5r6xrrrTd0nn_arrayk testshapers r'rrLsyb)22 1A I2 'u -E }! "" E3  5=)22 99 2 gfyIOO [[F 5zS^#+, , qB RB Avds  e #FI& X]]IInsxx"}- y  =aSD6LM Mt ' MW33s E/'E4c ^UcwUct[R"U[S9n[URS5V s/sH,n [R"USU 4R 55PM. n n [ XX$XVUS9$Ub[R"[U45n O[X4XVU5Rn [R"X S9n UbU RU:waX,lU R-[ 5nU$s sn f![[4a [U5nUc [U5n[U[5(aU4n[U5S:a [S5e[!X+5n [U R"5Hn[%X5X'M [&R("S[*SS 9 U s$f=f) 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.core.records.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', 'rrrUrtolistrr?r rrr<rrEr=rr rrNrrrr|)recListr?rr2r3r4r5r6rr!arrlistrretvalrrrs r'rrsX5=hhwf-;@2;OP;Oa288CQK..01;OP'%!'IO O &%)gfyIOO!'/*  !6 L ++h C JIQ z "*51 =LE eS ! !HE u:><= =%'v{{#Agj)FI$   G a ) %s3C73C<>> a = b'\x01\x02\x03abc' >>> np.core.records.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.core.records.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.core.records.fromstring(s, dtype='u1,u1,u1,S3') Traceback (most recent call last) ... TypeError: a bytes-like object is required, not 'str' z2fromstring() needs a 'dtype' or 'formats' argument)Nr)rr)rr>r?ritemsizerrEr ) datastringr?rrr2r3r4r5r6rrrs r'rrsp }LMM gfyIOO~~H 'u -E Z6)h6 e BF Mr9cUR5nURSS5 UR5U- URUS5 $!URUS5 f=f)Nrr)tellseek)fdposs r'get_remaining_sizerKsG '')C 1 wwy3 QQs $A Ac UcUc [S5e[U5nUcSnO[U[5(aU4n[ US5(a [ U5n O[ [U5S5n U nUS:aURUS5 [U5n Ub[R"U5n O[XEXgU5Rn U Rn [R"U5R[ R"S9n X-nUS:a][%U5nX*-X"R'S 5'[)U5n[R"U5R[ R"S9n X-nX:a [+S 5e[-X+5nUR/UR05nUU:wa [3S 5eSSS5 U$!,(df  W$=f) abCreate 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.newbyteorder('<') >>> a.tofile(fd) >>> >>> _ = fd.seek(0) >>> r=np.core.records.fromfile(fd, formats='f8,i4,a5', shape=10, ... byteorder='<') >>> print(r[5]) (0.5, 10, 'abcde') >>> r.shape (10,) Nz0fromfile() needs a 'dtype' or 'formats' argument)rreadintorbrrrrz:Not enough bytes left in file for specified shape and typez%Didn't read as many bytes as expected)rrr=rhasattrropenr rrr>r?rrrprodrwintpr$indexrNr<r rdataOSError)rr?rrr2r3r4r5r6ctxrrr shapeprod shapesizenbytesr nbytesreads r'rrTs\ }JKK 'u -E } E3  r:"o9R=$'  A: GGFA !"%  HHUOE!'&9MSSE>>HHUO((rww(7 ( q=KE%)Z%7E++b/ "%LE,,277,;I% =PR R%'[[-  AB B ; @ MA @ Ms /EF>> G c [U[S5[45(d[US5(aUcUc [ S5e0n Ub[ R "U5nO#Ub[XVUX5R nOUUUUU S.n UcUc [ S5e[X!XUS9$[U[5(a[X4X#S.U D6$[U[[45(a:[US[[45(a[U4XS .U D6$[U4XS .U D6$[U[5(a@Ub"UR U:waURU5n OUn U (aU R!5n U $[US5(a [#XX#S 9$[U[$5(aSUb"UR U:waURU5n OUn U (aU R!5n U R[5$['US S5n U b[U [(5(d [ S 5e[ R*"U5nUb!UR U:waURU5nUR[5$) 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]]) array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> np.core.records.array(a) rec.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=int32) >>> b = [(1, 1), (2, 4), (3, 9)] >>> c = np.core.records.array(b, formats = ['i2', 'f2'], names = ('x', 'y')) >>> c rec.array([(1, 1.0), (2, 4.0), (3, 9.0)], dtype=[('x', '>> c.x rec.array([1, 2, 3], dtype=int16) >>> c.y rec.array([ 1.0, 4.0, 9.0], 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?rr bytesrr$rNrrr|copyrrrdictr)rr?rrrr2r3r4r5r6rkwdsnew interfaces r'rrs?j C$t*c* + +wsJ/G/G ?u}9: : D   gf%227% # "&  { =AB B#gNN C  #IEIDII C$ ' ' c!fudm , ,sE%EE EcDDtD D C " "  #))u"4((5/CC ((*C j ! !EE C ! !  #))u"4((5/CC ((*Cxx!!C!6=  Jy$$?$?12 2hhsm  #))u"4((5/Cxx!!r9)NNNNNFN)NNrNNNFN) NNrNNNNFNT)"rbr collectionsr contextlibr_utilsrrr>r rw numpy.compatr arrayprintr __all__rr[ sctypeDictnumfmtr(rrxr r rrrrrrrrdr9r'rso"F" ".  ** (  GDDDNKRWWKjI,wI,X  K:>AE[[| KEI6:QQh KEIAEHHT K;??CaaH KGKGKQ"Q"r9