archive.git - Gitblit

Ë  
KñúhàãódZddlZddlZddlmZddlmZddlmZddl    m
Zddl    mZ dd    lmZgd
¢Zej"Zddd ddd ddddd ddddZe j&Zed«d«Zed«Gdd««ZGdde j.«Zed«Gdde««ZdZed«        d d«Zed«        d d«Zed«        d!d«ZdZed«        d!d«Zed«        d"d«Z y)#z<
This module contains a set of functions for record arrays.
éN)ÚCounter)Únullcontext)Ú
set_moduleé)Únumeric)Únumerictypes)Ú_get_legacy_print_mode)    ÚrecordÚrecarrayÚ format_parserÚ
fromarraysÚfromrecordsÚ
fromstringÚfromfileÚarrayÚfind_duplicateú>ú<ú=Úsú|)ÚbÚlÚnÚBÚLÚNÚSrrrrrÚIÚiz    numpy.reccópt|«j«Dcgc]\}}|dkDr|c}}Scc}}w)z@Find duplication in a list, return a list of duplicated elementsr)rÚitems)ÚlistÚitemÚcountss   úFH:\Change_password\venv_build\Lib\site-packages\numpy/_core/records.pyrr/s<ô
$ DM×/Ñ/Ó1÷áD&ØA:ò     óðùós2có,eZdZdZddZddZdZdZy)    ra
    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(['<f8', '<i4'], ['col1', 'col2'],
    ...                      ['T1', 'T2']).dtype
    dtype([(('T1', 'col1'), '<f8'), (('T2', 'col2'), '<i4')])
 
    `names` and/or `titles` can be empty lists. If `titles` is an empty list,
    titles will simply not appear. If `names` is empty, default field names
    will be used.
 
    >>> np.rec.format_parser(['f8', 'i4', 'a5'], ['col1', 'col2', 'col3'],
    ...                      []).dtype
    dtype([('col1', '<f8'), ('col2', '<i4'), ('col3', '<S5')])
    >>> np.rec.format_parser(['<f8', '<i4', '<a5'], [], []).dtype
    dtype([('f0', '<f8'), ('f1', '<i4'), ('f2', 'S5')])
 
    Ncón|j||«|j||«|j|«y©N)Ú _parseFormatsÚ_setfieldnamesÚ_createdtype)ÚselfÚformatsÚnamesÚtitlesÚalignedÚ    byteorders      r&Ú__init__zformat_parser.__init__vs0Ø×Ñ7 GÔ,Ø×ÑE 6Ô*Ø×Ñ)Õ$ócó|td«t|t«r8tjt|«Dcgc]\}}d||fc}}|«}ntj||«}|j}|%tjd|fg|«}|j}|j}|Dcgc]
}||dc}|_|Dcgc]
}||dc}|_    t|«|_ycc}}wcc}wcc}w)z Parse the field formats NzNeed formats argumentÚfÚf1rr)Ú
ValueErrorÚ
isinstancer#ÚsbÚdtypeÚ    enumerateÚfieldsr/Ú
_f_formatsÚ_offsetsÚlenÚ_nfields)    r-r.r1r Úformat_r;r=ÚkeysÚkeys             r&r*zformat_parser._parseFormats{sòð?ÜÐ4Ó5Ð5ÜgtÔ$ÜHHô'0°Ó&8÷á"7ðWgÒ&óðóEôHHW gÓ.EØØ>ÜHHt Um_¨gÓ6EØ\\FØ{{Ø59Ö:¨c6 #; q>Ò:Ø37Ö8¨C  QÒ8 ÜD     ùóùò;ùÚ8s»C2
Â/C8Ã
C=có$|rt|«ttfvrn9t|t«r|jd«}nt dt|««|d|jDcgc]}|j«c}|_
ng|_
|xjtt|j«|j«Dcgc]}d|z    c}z c_
t|j«}|rtd|«|r1|d|jDcgc]}|j«c}|_n    g|_g}|jt|«kDr0|xjdg|jt|«z
zz c_yycc}wcc}wcc}w)zQconvert input field names into a list and assign to the _names
        attribute ú,zillegal input names Nzf%dzDuplicate field names: )Útyper#Útupler9ÚstrÚsplitÚ    NameErrorÚreprrAÚstripÚ_namesÚranger@rr8Ú_titles)r-r/r0rr Ú_dups      r&r+zformat_parser._setfieldnamessTñÜE{t¤UmÑ+ØÜE¤3Ô'Ø CÓ(äÐ"6´t¸E³{°mÐ DÓEÐEà.3°N°T·]±]Ð.CÖD¨1779ÒDDKàDKð     ¬5´°T·[±[Ó1AØ15·±ó,@öA a     òAñ    AôdkkÓ*ÙÜÐ6°t°fÐ=Ó>Ð>áØ/5°n°t·}±}Ð/EÖF¨!AGGIÒFDLàDLØFà==3v;Ò&ØLLTF d§m¡m´c¸&³kÑ&AÑBÑBLð'ùò+EùòAùòGsÁ%FÃFÄF cóÔtj|j|j|j|j
d«}|t|d}|j|«}||_y)N)r/r.Úoffsetsr0r)r:r;rNr>r?rPÚ_byteorderconvÚnewbyteorder)r-r2r;s   r&r,zformat_parser._createdtype·s^ÜØ[[ØØ}}Øllñ    
óðÐ Ü& y°¡|Ñ4IØ×&Ñ& yÓ1Eà
r4)FN)F)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r3r*r+r,©r4r&rr9sñ9óv%ó
"ò0"CóHr4rcóLeZdZdZdZdZfdZfdZdZdZdZdZ    xZ
S)    r
zEA data-type scalar that allows field access as attribute lookup.
    ÚnumpycóZt«dkr|j«St| «S©Néq)r    Ú__str__ÚsuperÚ__repr__©r-Ú    __class__s r&rbzrecord.__repr__Îs(øÜ!Ó# sÒ*Ø<<>Ð!ÜwÑÓ!Ð!r4cólt«dkrt|j««St|«Sr^)r    rIr$rar`rcs r&r`zrecord.__str__Ós,øÜ!Ó# sÒ*Ütyy{Ó#Ð#ÜwÓ Ð r4có|dvr tjj||«S    tjj||«S#t$rYnwxYwtjj|d«j}|j|d«}|rf|j|dd}    |j}n#t$r|cYSwxYw|j'|j|j|jf«S|Std|d«)N©ÚsetfieldÚgetfieldr;r;éú"'record' object has no attribute 'ú')ÚntÚvoidÚ__getattribute__ÚAttributeErrorr=Úgetrir;r/Úviewrd)r-ÚattrÚ    fielddictÚresÚobjÚdts      r&rozrecord.__getattribute__ØsùØÐ4Ñ4Ü77×+Ñ+¨D°$Ó7Ð7ð    Ü77×+Ñ+¨D°$Ó7Ð7øÜò    Ùð    úäGG×,Ñ,¨T°7Ó;×BÑB    ØmmD $Ó'ÙØ$--  R a Ð)Cð ØYYøÜ!ò à
ð úðxxÐ#Øxx §¡°·±Ð ;Ó<Ð<ØJä Ð#EÀdÀVÈ1Ð!MÓNÐNs#¦AÁ    AÁAÂ&B3Â3CÃCcóJ|dvrtd|d«tjj|d«j}|j|d«}|r|j|g|dd¢St||d«r!tjj|||«Std|d«)NrgzCannot set 'z' attributer;rjrkrl)    rprmrnror=rqrhÚgetattrÚ__setattr__)r-rsÚvalrtrus     r&rzzrecord.__setattr__ðs¤ØÐ4Ñ4Ü  <°¨v°[Ð!AÓBÐBÜGG×,Ñ,¨T°7Ó;×BÑB    ØmmD $Ó'ÙØ 4== Ð/ s¨2¨A wÒ/Ð/Ü T4 Ô &Ü77×&Ñ& t¨T°3Ó7Ð7ä Ð#EÀdÀVÈ1Ð!MÓNÐNr4cóôtjj||«}t|tj«r=|jj
'|j |j|jf«S|Sr))rmrnÚ__getitem__r9r;r/rrrd)r-Úindxrvs   r&r}zrecord.__getitem__üsXÜgg×!Ñ! $¨Ó-ôc277Ô#¨¯    ©    ¯©Ð(CØ88T^^¨S¯Y©YÐ7Ó8Ð8ðJr4c    óÄ|jj}td|D««}d|z}|Dcgc]}||t||«fz}}dj    |«Scc}w)zPretty-print all fields.c3ó2K|]}t|«ywr))r@)Ú.0Únames  r&ú    <genexpr>z record.pprint.<locals>.<genexpr>
sèøÒ1 4SYÑ1ùsz%% %ds: %%sú
)r;r/ÚmaxryÚjoin)r-r/ÚmaxlenÚfmtrÚrowss      r&Úpprintz record.pprintseð

× Ñ ÜÑ1¨5Ô1Ó1ØfÑ$Ø>CÖD°dtW T¨4Ó0Ð1Ó1ÐDÐDØyyÐùòEs²A)rVrWrXrYrbr`rorzr}rÚ __classcell__©rds@r&r
r
Ås4øñð
HØJô"ô
!ò
Oò0
Oòör4r
cóPeZdZdZ            d    dZdZdZdZfdZdZ    d
dZ
xZS)raSConstruct 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', '<f8'), ('y', '<i8')])
    >>> x
    array([(1., 2), (3., 4)], dtype=[('x', '<f8'), ('y', '<i8')])
 
    >>> 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', '<i4'), ('y', '<f8'), ('z', '<i4')])
 
    c    óò|tj|«}nt||||
|    «j}|!tj    ||t
|f|¬«} | Stj    ||t
|f||||¬«} | S)N)Úorder)ÚbufferÚoffsetÚstridesr)r:r;rÚndarrayÚ__new__r
)ÚsubtypeÚshaper;Úbufrrr.r/r0r2r1rÚdescrr-s              r&rzrecarray.__new__sðÐÜHHUOEä!Ø ¨°óçeð ð;Ü??Ø¤¨ °uð#óDðô    ??Ø¤¨ ¸Ø w°eð#óDðr4có|jjtur)|jj|j|_yyyr))r;rGr
r/)r-rvs  r&Ú__array_finalize__zrecarray.__array_finalize__s7Ø::??¤&Ñ(¨T¯Z©Z×-=Ñ-=Ð-IðDJð.JÐ(r4có&    tj||«S#t$rYnwxYwtj|d«j}    ||dd}n&#t
tf$r}td|«|d}~wwxYw|j|}|jjbt|jjtj«r2|j|jj|jf¬«S|S|jt«S)Nr;rjzrecarray has no attribute ©r;)Úobjectrorprr=Ú    TypeErrorÚKeyErrorrir;r/Ú
issubclassrGrmrnrr)r-rsrtruÚervs      r&rozrecarray.__getattribute__sôð    Ü×*Ñ*¨4°Ó6Ð6øÜò    Ùð    úô×,Ñ,¨T°7Ó;×BÑB    ð    MØD/ " 1Ð%CøÜ8Ð$ò    MÜ Ð#=¸d¸VÐ!DÓEÈ1ÐLûð    MúàdmmSÐ!ð99??Ð&Ü#))..¬"¯'©'Ô2Øxx t§z¡z§¡¸¿    ¹    Ð&BxÓCÐCØJà88GÓ$Ð$s$    $£$ÁAÁA4Á A/Á/A4có|dk(rKt|jtj«r'|jtjt|f«}||jv}    tj|||«}tj|d«jxsi}||vr|S|r    tj||«    ||dd}|j&|g|¢S#t$r|cYSwxYw#t$r,tj|d«jxsi}||vrYawxYw#t t"f$r}t%d|«|d}~wwxYw)Nr;rjzrecord array has no attribute )r rGrmrnr/r:r;r
Ú__dict__rrzrror=Ú__delattr__Ú    Exceptionrrrprh)r-rsr{ÚnewattrÚretrtrur¡s        r&rzzrecarray.__setattr__ÁsTð
 GOÜsxx¤§¡Ô)ØIIÐ!ä((F C=Ó)CàdmmÐ+ð    Ü×$Ñ$ T¨4°Ó5Cô ×0Ñ0°°wÓ?×FÑFÒLÈ"IØ9Ñ$Ø
ÙðÜ×&Ñ& t¨TÔ2ð    ØD/ " 1Ð%Cð
t}}SÐ' 3Ò'Ð'øô!òØJðûôò    Ü×0Ñ0°°wÓ?×FÑFÒLÈ"IØ9Ñ$Øñ%ð    ûô"8Ð$ò    Ü Ø0°°Ð7óàð ûð    ús<Á C'Â$CÂ;DÃC$Ã#C$Ã'2DÄDÄEÄ.D=Ä=Ecót||«}t|t«r¨|jj
||j t|««}t|jjtj«r2|j |jj|jf¬«S|S|j t¬«S|S)Nr)rG)rar}r9rr;r/rrrGr rmrn)r-r~rvrds   r&r}zrecarray.__getitem__æsøÜgÑ! $Ó'ôc7Ô#ØyyÐ*Øhht DzÓ*Üciinn¬b¯g©gÔ6Ø88¨4¯:©:¯?©?¸C¿I¹IÐ*F8ÓGÐGØ
àxx¤WxÓ-Ð-ðJr4có$|j}|jjtus.t|jjtj
«s<|jtur%t jtj
|f«}d}d}nd}d}|jdkDs|jdk(rt j|d|d¬    «}nd
t|j«}ddt|«zz}t«d krd|z}||||fzS)Nz
rec.array(zrec.array(%s,%sdtype=%s)zarray(z)array(%s,%sdtype=%s).view(numpy.recarray)r)rz, rF)Ú    separatorÚprefixÚsuffixz
[], shape=rú r_) r;rGr
r rmrnr:ÚsizerÚarray2stringrLr@r    )r-Ú
repr_dtyper«rÚlstÚlfs      r&rbzrecarray.__repr__÷síàZZ
àJJOOvÑ%Ü4::??¬B¯G©GÔ4ð¤&Ñ(ÜXX¤r§w¡w°
Ð&;Ó<
Ø!FØ,Cð
FØ=Cð99q=DJJ¨$Ò.Ü//Ø ¨V¸CôACðt D§J¡JÓ/Ð0Ð1Cà C#f+Ñ%Ñ %Ü!Ó# sÒ*ØrBØc2zÐ*Ñ*Ð*r4có^t|t«r%tj|d«j}||}tj|d«j
}||dd}|<|j|}|jj|S|jt«S|j|g|¢S)Nr;rj)
r9Úintrror/r=rir;rrrh)r-rsr{r/rtrurvs       r&Úfieldzrecarray.fields¢ÜdCÔ Ü×,Ñ,¨T°7Ó;×AÑAEØ;Dä×,Ñ,¨T°7Ó;×BÑB    àobqÐ!à;Ø$-- Ð%CØyyÐ*Ø
Ø88GÓ$Ð$à 4== Ð+ sÒ+Ð+r4)
NNrNNNNNFÚCr))rVrWrXrYrrrorzr}rbrµrrs@r&rrs=øñgðRIMØ15Ø58óò,$ò%òD#(ôJò""+÷H,r4rcóJ|dk(rtjdtd¬«y|S)Nrz¹Passing `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)ÚwarningsÚwarnÚ FutureWarning)rs r&Ú_deprecate_shape_0_as_Noner¾-s,ØzÜ  ð Nô  aõ        )ð
àr4cóÖ|Dcgc]}tj|«}}t|«}||dj}nt    |t
«r|f}|||D    cgc]}    |    j}}    |tj|«}
nt|||||«j}
|
j}t|
«t|«k7rtd«|
dj}t|«} | dkDr|d| }t||
«}t|«D]Q\}}    |
|j} |    jd|    j| z
}||}||k7rtd|d|d«|    ||<S|Scc}wcc}    w)a¨Create 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', '<i4'), ('b', 'S3'), ('c', '<f4')])
    Nrz>mismatch between the number of fields and the number of arrayszarray-shape mismatch in array z ("z"))r:Úasarrayr¾rr9r´r;rr/r@r8rr<Úndim)Ú    arrayListr;rr.r/r0r1r2ÚxrvrrNÚd0ÚnnÚ_arrayÚkÚ    testshapers                  r&r r 9sðb)2Ö2 1AÐ2IÐ2ô ' uÓ-Eà}Ø!×"Ñ"Ü    E3Ô    Øà5=ð)2Ö2 399Ð2Ð2àÐÜäg u¨f°g¸yÓI×OÑOØ [[Fô5zS^Ò#Üð+ó,ð    ,ð
qBÜ    RBØ    AvØdsä eUÓ #FôIÓ&ò3Ø 1X]]ØIInsxx¨"}Ð-    ØayØÒÜÐ=¸a¸SÀÀDÀ6ÈÐLÓMÐMàtððMùòW3ùò3sE!ÁE&c    ó^|z|xtj|t¬«}t|jd«D    cgc]*}    tj|d|    fj««,}
}    t |
||||||¬«S|tjt|f«}nt|||||«j}    tj||¬«}||j|k7r||_    |j-t «}|Scc}    w#ttf$rt|«}|t|«}t|t«r|f}t|«dkDrtd«t!||«} t| j"«D]}t%||«| |<t'j(dt*d¬    «| cYSwxYw)
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='<U3')
    >>> import pickle
    >>> pickle.loads(pickle.dumps(r))
    rec.array([(456, 'dbe', 1.2), (  2, 'de', 1.3)],
              dtype=[('col1', '<i8'), ('col2', '<U3'), ('col3', '<f8')])
    réÿÿÿÿ.)r.rr/r0r1r2rzCan 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 errorrjr¹)r:rrrOrÚtolistr r;r
rrr8r¾r@r9r´rr®rHr»r¼r½rr)ÚrecListr;rr.r/r0r1r2rvr ÚarrlistrÚretvalrÆrÇrus                r&rrsªðX5=Ühhw¤fÔ-ä49¸#¿)¹)ÀB¹-Ó4Hö
Ø/0BHHSa[×'Ñ'Ó)Õ*ð
ð
ô'¨7¸%ÀuØ!'°ÀIôOð    Oð ÐÜ& %Ó)äØUF G¨Yó
ç
%ð    ð!Ü'¨Ô/ð*Ð §¡°Ò!6Ø FLà
++hÓ
CàJùòQ
øô zÐ"òä*¨5Ó1Ø=ÜLEÜeSÔ!ØHEÜu:>ÜÐ<Ó=Ð=Ü% Ó'Üv{{Ó#ò    *AÜg ajÓ)F1Ið    *ô      ð Gä aõ    )ð ð%úsº/C<Â5DÄB(F,Æ+F,c    óü| |td«|tj|«}    nt|||||«j}    |    j}
t|«}|dvrt |«|z
|
z}t||    ||¬«}|S)aÜCreate 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', '<U10'), ('Marks', '<f8'), ('GradeLevel', '<i4')])
 
    >>> 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'
    z2fromstring() needs a 'dtype' or 'formats' argument)NrÊ)rr)rr:r;rÚitemsizer¾r@r)Ú
datastringr;rrr.r/r0r1r2rrÐrÆs            r&rrñsðp }ÜÐLÓMÐMàÐÜäg u¨f°g¸yÓI×OÑOà~~Hô ' uÓ-Eà
ÑÜZ 6Ñ)¨hÑ6ä eU¨
¸6Ô BFØMr4cóÀ|j«}    |jdd«|j«|z
|j|d«S#|j|d«wxYw)Nrrj)ÚtellÚseek)ÚfdÚposs  r&Úget_remaining_sizer×<sGØ
'')CðØ
1 Øwwy3à
QøQús$A    Á    Ac    ó| |td«t|«}|d}nt|t«r|f}t    |d«rt|«}    nt tj|«d«}    |    5}|dkDr|j|d«t|«}
|tj|«}nt|||||«j}|j}tj|«j!t"j$¬«} | |z}|dkrat'|«}|
|z||j)d    «<t+|«}tj|«j!t"j$¬«} | |z}||
kDrt-d
«t/||«}|j1|j2«}||k7rt5d«    ddd«|S#1swYSxYw)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)rÊÚreadintoÚrbrrrrÊz;Not enough bytes left in file for specified shape and type.z%Didn't read as many bytes as expected)rr¾r9r´ÚhasattrrÚopenÚosÚfspathrÔr×r:r;rrÐrÚprodrmÚintpr#ÚindexrHr8rrÙÚdataÚOSError)rÕr;rrr.r/r0r1r2Úctxr®rrÐÚ    shapeprodÚ    shapesizeÚnbytesrÆÚ
nbytesreads                  r&rrEsÆð\ }ÜÐJÓKÐKô ' uÓ-Eà}ØÜ    E3Ô    Øär:Ôô"oô299R= $Ó'à    ð"CØA:ØGGFAÔÜ! "Ó%àÐÜHHUOEä!Ø ¨°óçeð ð>>äHHUO×(Ñ(¬r¯w©wÐ(Ó7    Ø Ñ(    Øq=ÜKEØ%)¨i¨ZÑ%7E%++b/Ñ"Ü%LEÜ ×,Ñ,´2·7±7Ð,Ó;IàXÑ%àD=Üð&óð ô% Ó'Ø[[ §¡Ó-
ØÒÜÐAÓBÐBð ÷C"CðHM÷I"CðHMús Á,E
GÇGcónt|td«tf«st|d«r| |t    d«i}|tj|«}n$|t|||||    «j}n|||||    d}||t    d«t|||||¬«St|t«rt||f||d|¤St|ttf«r7t|dttf«rt|f||d    |¤St|f||d    |¤St|t«r9|!|j|k7r|j|«}n|}|
r|j!«}|St|d«rt#||||¬
«St|t$«rL|!|j|k7r|j|«}n|}|
r|j!«}|jt«St'|dd«} | t| t(«st    d«tj*|«}| |j|k7r|j|«}|jt«S) 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', '<i2'), ('y', '<f2')])
 
    >>> 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='<U3')
 
    >>> r.col2
    array('def', dtype='<U3')
    NrÙzIMust define formats (or dtype) if object is None, string, or an open file)r.r/r0r1r2z"Must define a shape if obj is None)rrr)rrr)r;r)r;rrÚ__array_interface__zUnknown input type)r9rGrIrÛr8r:r;rrÚbytesrr#rHrr rrÚcopyrrryÚdictr)rvr;rrrr.r/r0r1r2rìÚkwdsÚnewÚ    interfaces              r&rr®s8ôl
C$t*¤cÐ*Ô    +¬w°s¸JÔ/GØ?u}Üð9ó:ð    :ðDØÐÜØ    Ð    Üg u¨fØ% yó2ß27±%ñ    ð#ØØ Ø"Ø&ñ    ð{Ø=ÜÐAÓBÐBÜu¨#°fÀgÔNÐNä    CÔ    Ü#uÐI¨E¸&ÑIÀDÑIÐIä    C$¤Ô    'Üc!fu¤dmÔ,ÜsÐE¨%°uÑEÀÑEÐEäcÐD¨°eÑD¸tÑDÐDä    CÔ    "ØÐ #§)¡)¨uÒ"4Ø((5/CàCÙØ((*CØ
ä    jÔ    !Ü 5°¸fÔEÐEä    CÔ    !ØÐ #§)¡)¨uÒ"4Ø((5/CàCÙØ((*CØxxÓ!Ð!ôCÐ!6¸Ó=    ØÐ¤J¨y¼$Ô$?ÜÐ1Ó2Ð2ÜhhsmØÐ #§)¡)¨uÒ"4Ø((5/CØxxÓ!Ð!r4)NNNNNFN)NNrNNNFN)
NNrNNNNFNT)!rYrÝr»ÚcollectionsrÚ
contextlibrÚnumpy._utilsrÚrr:rrmÚ
arrayprintr    Ú__all__rrTÚ
sctypeDictÚnumfmtrrrnr
rr¾r rrr×rrrZr4r&ú<module>rùsðñó
ÛÝÝ"å#åÝ Ý.òð **àØØØØØØØØØØØØØñ ð(
ñKÓñóðñKÓ÷HðHóðHôVHRWWôHñfKÓôQ,wóQ,óðQ,òh    ñKÓØ:>ØAEò[óð[ñ|KÓØEIØ6:òUóðUñpKÓØEIØAEòHóðHòTñKÓØ;?Ø?CòeóðeñPKÓØGKØGKòR"óñR"r4