fume-manage-python.git

U  
P±domã    @s&dZddlmZmZmZmZmZmZmZm    Z    ddlm
Z
ddlZddlZ ddlmZmZmZmZmZddlmZmZe jjjZe
jjZdddd    d
dgZdd ddgZd#ddZddZ GdddeZ!ddZ"e!Z#d$ddZddddddddef    dd    ZddZ$ddZ%d%e j&d d!d
Z'd&d"dZ(dS)'a,:mod:`numpy.ma..mrecords`
 
Defines the equivalent of :class:`numpy.recarrays` for masked arrays,
where fields can be accessed as attributes.
Note that :class:`numpy.ma.MaskedArray` already supports structured datatypes
and the masking of individual fields.
 
.. moduleauthor:: Pierre Gerard-Marchant
 
é)ÚMAErrorÚMaskedArrayÚmaskedÚnomaskÚmasked_arrayÚgetdataÚgetmaskarrayÚfilledN)Úbool_ÚdtypeÚndarrayÚrecarrayÚarray)Ú
fromarraysÚfromrecordsÚ MaskedRecordsÚ    mrecarrayrrÚfromtextfileÚaddfieldÚ_dataÚ_maskÚ
_fieldmaskrc    Csît|}ddt|D}|dkr(|}nXt|ttfr<|}n$t|trR| d¡}ntd|t|}||kr|||d7}g}t|||j    D]P\}}}|t
krÐ|dt
krÄ| ||df¡qâ| |¡q| ||df¡qt  |¡S)zÓ
    Checks that field names ``descr`` are not reserved keywords.
 
    If this is the case, a default 'f%i' is substituted.  If the argument
    `names` is not None, updates the field names to valid names.
 
    cSsg|]}d|qS)úf%i©©Ú.0ÚirrúHd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\numpy/ma/mrecords.pyÚ
<listcomp>6sz_checknames.<locals>.<listcomp>Nú,zillegal input names ré)ÚlenÚrangeÚ
isinstanceÚtupleÚlistÚstrÚsplitÚ    NameErrorÚzipÚdescrÚreserved_fieldsÚappendÚnpr)    r*ÚnamesZndescrÚ default_namesZ    new_namesZnnamesÚnÚdÚtrrrÚ_checknames-s(
r3cCs:dd|jjD}tj|j|d}tdgt||_|S)NcSsg|]}|dfqS)z|b1r©rr0rrrrPsz"_get_fieldmask.<locals>.<listcomp>©rF)rr.r-ÚemptyÚshaper$r!Úflat)ÚselfÚmdescrZfdmaskrrrÚ_get_fieldmaskOsr;c@sÒeZdZdZdddddddddeddddfddZdd    Zed
dZedd Z    ddZ
ddZddZddZ ddZddZddZd,ddZddZd d!Zd"d#Zd-d$d%Zd&d'Zd(d)Zd*d+ZdS).ra
 
    Attributes
    ----------
    _data : recarray
        Underlying data, as a record array.
    _mask : boolean array
        Mask of the records. A record is masked when all its fields are
        masked.
    _fieldmask : boolean recarray
        Record array of booleans, setting the mask of each individual field
        of each record.
    _fill_value : record
        Filling values for each field.
 
    NrFTc stj||||||||||    |
d}t |j¡|tks>t |¡sX|sVtdgt    |_
n´tj||d}|j|jkrÄ|j|j}}|dkrt  ||j¡}n,||kr°t ||j¡}nd}t|||f|sÚ| |¡d|_n2|jkrê|}ntjfdd|Dd    }||_
|S)
N)    rÚbufÚoffsetÚstridesÚformatsr.ÚtitlesÚ    byteorderÚalignedF©Úcopyr z?Mask and data not compatible: data size is %i, mask size is %i.Tcsg|]}t|gtqSr©r$r!©rÚm©Úmdtyperrrsz)MaskedRecords.__new__.<locals>.<listcomp>r5)r Ú__new__ÚmaÚmake_mask_descrrrr-Úsizer$r!rrr7ÚresizeZreshaperÚ__setmask__Ú_sharedmask)Úclsr7rr<r=r>r?r.r@rArBÚmaskZ    hard_maskÚ
fill_valueZ    keep_maskrDÚoptionsr9ZndÚnmÚmsgrrrHrrJhs>ý
 
ÿzMaskedRecords.__new__cs¤t|dd}|dkrpt|dt}t |d¡}|tkrFtj|j|d}n*t |¡tfdd|Dd     t
¡}|j}|j|d|  |¡|dtkr t
|d<dS)Nrrr5csg|]}t|gtqSrrErF©r:rrrsz4MaskedRecords.__array_finalize__.<locals>.<listcomp>©rÚ
_baseclass)ÚgetattrrrÚ__getattribute__rKZmake_mask_noner7rLÚnarrayÚviewr Ú__dict__ÚupdateÚ_update_from)r9ÚobjrZobjmaskZ_dtypeÚ_dictrrWrÚ__array_finalize__s$
ÿÿ
z MaskedRecords.__array_finalize__cCst |t¡S)z2
        Returns the data as a recarray.
 
        )rr]r ©r9rrrr¤szMaskedRecords._datacCs|jS)z!
        Alias to mask.
 
        rXrdrrrr¬szMaskedRecords._fieldmaskcCs|jrt|jSt|jS)z%
        Returns the length
 
        )Úndimr!rrrdrrrÚ__len__´s
zMaskedRecords.__len__c
Cszt ||¡WStk
r"YnXt |d¡j}z||dd}Wn6ttfk
r|}ztd||W5d}~XYnXt |d¡}t ||d¡}|j|}|j    j
dk    r¸tdd}| dd¡}    |    dk    rz|    |}    Wnt k
ròYnXt|    j    }
|     t|
r|
fnd    f¡ ¡}|js*|r| t¡}t|_d
|_|    |_| dd¡}|dk    rz|||_Wntk
rd|_YnXn| ¡}|S)Nréúrecord array has no attribute r^rYz4MaskedRecords is currently limited tosimple records.FrrTÚ_fill_value)Úobjectr[ÚAttributeErrorrÚfieldsÚ    TypeErrorÚKeyErrorr]Úgetfieldrr.ÚNotImplementedErrorÚgetÚ
IndexErrorr!ÚboolÚanyr7rrYZ_isfieldrriÚ
ValueErrorÚitem)r9ÚattrÚ    fielddictÚresÚeÚ
_localdictrraZ    hasmaskedrZtp_lenrirrrr[¿sPÿÿ
 
 
 
 
zMaskedRecords.__getattribute__c
Cs|dkr| |¡dSt |d¡}||k}zt |||¡}WnHtk
rt |d¡jp\i}t |d¡pli}||ks||ksYnNXt |d¡jpi}||kr¤|S|rÒzt ||¡Wntk
rÐ|YSXz||dd}Wn8tt    fk
r}    zt
d||    W5d}    ~    XYnX|tkrT|d}
|
dk    rJ|d|}n|}d    }nt|}t |}t |d
¡j|f|} |d ||¡| S)z<
        Sets the attribute attr to the value val.
 
        )rRZ    fieldmaskNr^rZ_optinforgrhriTrr)rOrjr[Ú__setattr__Ú    ExceptionrrlÚ__delattr__rmrnrkrr    rÚsetfieldÚ__setitem__)r9rwÚvalr{ZnewattrÚretrxZoptinforyrzriÚdvalZmvalrarrrr|îsN
 
ÿÿ
 
zMaskedRecords.__setattr__cCs®|j}t |d¡}t ||d¡}t|trx|| t¡}|||_d|_|d}|dk    rd|||_    |j
st|jrttS|Stj ||dd t¡}tj ||dd t¡|_|S)z
        Returns all the fields sharing the same fieldname base.
 
        The fieldname base is either `_data` or `_mask`.
 
        rrYTriNFrC)r^rr[r]r#r&rrrPrirerr-rrr )r9Úindxr{rrraZfvalrrrÚ__getitem__&s 
 
 
zMaskedRecords.__getitem__cCs,t |||¡t|tr(t |¡|j|<dS)z2
        Sets the given record to value.
 
        N)rrr#r&rKrr)r9rÚvaluerrrrFs
zMaskedRecords.__setitem__cszjdkr@ddtfddjjDD}dd |¡dSddtfd    djjDD}d
d |¡dSdS) z8
        Calculates the string representation.
 
        r cSs(g|] }dd dd|D¡dqS)ú(rcSsg|]}t|qSr©r&rrrrrUsú4MaskedRecords.__str__.<locals>.<listcomp>.<listcomp>ú)©Újoin©rÚsrrrrUsÿz)MaskedRecords.__str__.<locals>.<listcomp>csg|]}t|qSr©rZ©rÚfrdrrrVsú[z, ú]cSs"g|]}d dd|D¡qS)rcSsg|]}t|qSrrrrrrrYsrrrrrrrYsÿcsg|]}t|qSrrrrdrrrZsrrN)rMr)rr.r)r9ZmstrrrdrÚ__str__Os
ÿÿzMaskedRecords.__str__csnjj}dtdd|DdffddjjD}| dd¡| djfd    g¡td
 |¡S)z6
        Calculates the repr representation.
 
        z%%%is : %%scSsg|]}t|qSr)r!r4rrrrcsz*MaskedRecords.__repr__.<locals>.<listcomp>écsg|]}|t|fqSrrr©Úfmtr9rrrdsrzmasked_records(z    fill_valuez              )Ú
)rr.ÚmaxÚinsertÚextendrSr&r)r9Z_namesZreprstrrrrÚ__repr__]sÿzMaskedRecords.__repr__cCs
|dkr*|dkrt |¡}qÎt ||¡}n¤|dkrÀz(t|trLt ||¡}nt ||¡}WqÎtk
r¼t |¡}|jdkr¦|jjd}|     ¡ ||¡}| 
|¡nt ||¡}d|_YqÎXnt |||¡}t|dt t k    rt |j¡}|j |t¡|_|j|j_|S)z3
        Returns a view of the mrecarray.
 
        Nrr)rr]Ú
issubclassrmr-rrlÚ    __class__Ú    __bases__Z    __array__r`rirZrrKrLrr7)r9rÚtypeÚoutputÚbasetyperIrrrr]js.
 
 
 
zMaskedRecords.viewcCs
d|_dS)z+
        Forces the mask to hard.
 
        TN©Z    _hardmaskrdrrrÚharden_maskszMaskedRecords.harden_maskcCs
d|_dS)z*
        Forces the mask to soft
 
        FNr£rdrrrÚsoften_maskszMaskedRecords.soften_maskcCs$|j ¡ t|¡}|j ¡|_|S)z7
        Returns a copy of the masked record.
 
        )rrDr]r r)r9ÚcopiedrrrrD szMaskedRecords.copycCsH|dk    r| |¡ ¡St| ¡ ¡td}t|j ¡}d||<| ¡S)a
        Return the data portion of the array as a list.
 
        Data items are converted to the nearest compatible Python type.
        Masked values are converted to fill_value. If fill_value is None,
        the corresponding entries in the output list will be ``None``.
 
        Nr5)r    Útolistr\rjr)r9rSÚresultrRrrrr§©s    zMaskedRecords.tolistcCs,d|j|j|jj|j ¡|j ¡|jf}|S)zWReturn the internal state of the masked array.
 
        This is for pickling.
 
        r )r7rÚflagsZfncrÚtobytesrri)r9ÚstaterrrÚ__getstate__¹súzMaskedRecords.__getstate__c
Cs^|\}}}}}}}t |||||f¡tdd|jjD}    |jd ||    ||f¡||_dS)at
        Restore the internal state of the masked array.
 
        This is for pickling.  ``state`` is typically the output of the
        ``__getstate__`` output, and is a 5-tuple:
 
        - class name
        - a tuple giving the shape of the data
        - a typecode for the data
        - a binary string for the data
        - a binary string for the mask.
 
        cSsg|]\}}|tfqSr©r
)rÚkÚ_rrrrÙsz.MaskedRecords.__setstate__.<locals>.<listcomp>rN)rÚ__setstate__rr*r^rS)
r9r«ÚverZshpÚtypZisfÚrawZmskZflvrIrrrr°És
zMaskedRecords.__setstate__cCst|j|jddf| ¡fS)z?
        Return a 3-tuple for pickling a MaskedArray.
 
        )rÚb)Ú_mrreconstructrrYr¬rdrrrÚ
__reduce__ÝsþzMaskedRecords.__reduce__)NN)N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rrJrcÚpropertyrrrfr[r|rrrrr]r¤r¥rDr§r¬r°r¶rrrrrVsBü
(
 
/8      
(    
cCs4t |||¡ |¡}t t|d¡}|j||||dS)zK
    Build a new MaskedArray from the information stored in a pickle.
 
    Zb1)rRr)rrJr])ÚsubtypeZ    baseclassZ    baseshaper¢rrrrrrµçsrµFc    
Cs\dd|D}    dd|D}
t|    |||||||d t¡}tt|
|j_|dk    rX||_|S)a 
    Creates a mrecarray from a (flat) list of masked arrays.
 
    Parameters
    ----------
    arraylist : sequence
        A list of (masked) arrays. Each element of the sequence is first converted
        to a masked array if needed. If a 2D array is passed as argument, it is
        processed line by line
    dtype : {None, dtype}, optional
        Data type descriptor.
    shape : {None, integer}, optional
        Number of records. If None, shape is defined from the shape of the
        first array in the list.
    formats : {None, sequence}, optional
        Sequence of formats for each individual field. If None, the formats will
        be autodetected by inspecting the fields and selecting the highest dtype
        possible.
    names : {None, sequence}, optional
        Sequence of the names of each field.
    fill_value : {None, sequence}, optional
        Sequence of data to be used as filling values.
 
    Notes
    -----
    Lists of tuples should be preferred over lists of lists for faster processing.
 
    cSsg|]}t|qSr)r©rÚxrrrrszfromarrays.<locals>.<listcomp>cSsg|]}t t|¡qSr)r-Z
atleast_1drr½rrrrs©rr7r?r.r@rBrAN)Ú recfromarraysr]rr%r)rr8rS)Z    arraylistrr7r?r.r@rBrArSZdatalistZmasklistZ_arrayrrrrøs"ýýc
 
Csàt|dd}
t|trDt|tr.| ¡ t¡}|dkr<|j}| ¡}t||||||||d t    ¡}|dk    rp||_
|    tk    rÆtj |    dd}    t|    j}|r|    |j_n(|    jdkr¼dd|    D|j_n
| |    ¡|
dk    rÜ|
|jdd<|S)    aN
    Creates a MaskedRecords from a list of records.
 
    Parameters
    ----------
    reclist : sequence
        A list of records. Each element of the sequence is first converted
        to a masked array if needed. If a 2D array is passed as argument, it is
        processed line by line
    dtype : {None, dtype}, optional
        Data type descriptor.
    shape : {None,int}, optional
        Number of records. If None, ``shape`` is defined from the shape of the
        first array in the list.
    formats : {None, sequence}, optional
        Sequence of formats for each individual field. If None, the formats will
        be autodetected by inspecting the fields and selecting the highest dtype
        possible.
    names : {None, sequence}, optional
        Sequence of the names of each field.
    fill_value : {None, sequence}, optional
        Sequence of data to be used as filling values.
    mask : {nomask, sequence}, optional.
        External mask to apply on the data.
 
    Notes
    -----
    Lists of tuples should be preferred over lists of lists for faster processing.
 
    rNr¿FrCrgcSsg|]}t|qSr)r$rFrrrr\szfromrecords.<locals>.<listcomp>)rZr#rrr    r]rr§ÚrecfromrecordsrrSrr-rr!rr8rerO) Zreclistrr7r?r.r@rBrArSrRrZmrecZmaskrecordlengthrrrr#s8"
 
 
þþ
 
 
 
cCsðg}t |¡}|jdkr"|d}n|jdkr4td|D]²}zt|Wnttfk
rØzt|WnZttfk
rÂzt|Wn$ttfk
r¬| |j    ¡YnX| t     t¡¡YnX| t     t¡¡Yq8X| t     t¡¡q8|S)a.
    Tries to guess the dtypes of the str_ ndarray `arr`.
 
    Guesses by testing element-wise conversion. Returns a list of dtypes.
    The array is first converted to ndarray. If the array is 2D, the test
    is performed on the first line. An exception is raised if the file is
    3D or more.
 
    rgrzThe array should be 2D at most!)
r-ZasarrayreruÚintrmÚfloatÚcomplexr,r)ZarrÚvartypesrrrrÚ_guessvartypesds*
 
 
 
 
rÆc
Cst|dr|Szt|}Wn4tk
rN}ztd|d|W5d}~XYnX| ¡dddkrt| dd¡|S| ¡tddS)    z1
    Opens the file handle of file `fname`.
 
    ÚreadlinezNo such file: 'ú'Nrgz\xrzWow, binary file)ÚhasattrÚopenÚFileNotFoundErrorrÇÚseekÚcloserp)ÚfnamerrzrrrÚopenfiles
$rÏú#Ú)Ú    delimitorcsZ|tjk    r.dk    rtdtjdtdd|t|}| ¡}|d| ¡     ¡}    |     
¡}
t|
dkr6qnq6|dkrz|
}tfdd|D}|j \}} | ¡|dkrºt|d    }nNd
d|D}t|| krd}|d7}tj|t|| fddt|d    }d dt||D}dd|D}|j|k}ddt|j|||D}t||dS)a®
    Creates a mrecarray from data stored in the file `filename`.
 
    Parameters
    ----------
    fname : {file name/handle}
        Handle of an opened file.
    delimiter : {None, string}, optional
        Alphanumeric character used to separate columns in the file.
        If None, any (group of) white spacestring(s) will be used.
    commentchar : {'#', string}, optional
        Alphanumeric character used to mark the start of a comment.
    missingchar : {'', string}, optional
        String indicating missing data, and used to create the masks.
    varnames : {None, sequence}, optional
        Sequence of the variable names. If None, a list will be created from
        the first non empty line of the file.
    vartypes : {None, sequence}, optional
        Sequence of the variables dtypes. If None, it will be estimated from
        the first non-commented line.
 
 
    Ultra simple: the varnames are in the header, one lineNz;fromtextfile() got multiple values for argument 'delimiter'zThe 'delimitor' keyword argument of numpy.ma.mrecords.fromtextfile() is deprecated since NumPy 1.22.0, use 'delimiter' instead.rg)Ú
stacklevelr cs2g|]*}|dkrt|dkr| ¡ ¡qS)rr )r!Ústripr')rÚline©ÚcommentcharÚ    delimiterrrrÐsÿz fromtextfile.<locals>.<listcomp>rcSsg|]}t |¡qSr)r-r)rÚvrrrrÙsz&Attempting to %i dtypes for %i fields!z Reverting to default.cSsg|]\}}||fqSrr)rr0rrrrráscSsg|]}t |¡qSr)rKZdefault_fill_valuerrrrrâscSs$g|]\}}}}t||||dqS))rRrrS)r)rÚarGr2rrrrrçs
ÿr5)r-Ú_NoValuermÚwarningsÚwarnÚDeprecationWarningrÏrÇÚfindrÔr'r!rr7rÍrÆr)ÚTr)rÎrØr×ZmissingcharÚvarnamesrÅrÒZftextrÕÚ    firstlineZ    _varnamesZ
_variablesr¯ZnfieldsrVr:ZmfillvrZ    _datalistrrÖrrsD
ý
 
 
ÿcsþ|j|j|dks|tkr*dtj}t |¡}t jj||jfg¡}t    j
|fddjj ¡Dj |jfjj| t¡t dd|jD¡}t    j
|fddjj ¡Dj t|fjj|_S)zÜAdds a new field to the masked record array
 
    Uses `newfield` as data and `newfieldname` as name. If `newfieldname`
    is None, the new field name is set to 'fi', where `i` is the number of
    existing fields.
 
    Nrcs"g|]}jj|f|qSr©rror)rÚnewdatarrrÿsÿzaddfield.<locals>.<listcomp>cSsg|]}|tfqSrrr4rrrrscs"g|]}jj|f|qSrrãr)rÚnewmaskrrr    sÿ)rrr+r!rrKrr-r*r r7rlÚvaluesrr]rr.r)ZmrecordZnewfieldZnewfieldnameZnewdtypeZ    newmdtyper)rrrärårrís,
 
ÿ
 
ÿ
ÿ)N)NNNNNFNN)NrÐrÑNN)N))rºZnumpy.marrrrrrrr    rKrÜÚnumpyr-r
rrr rr\Znumpy.core.recordsrrÀrrÁÚcoreÚrecordsZ_byteorderconvZ_check_fill_valueÚ__all__r+r3r;rrµrrÆrÏrÛrrrrrrÚ<module>s^(
þ
"    þ
+þ
A%ÿþP