fume-manage-python.git

U  
¬ý°d"¿ã@sLddlmZddlmZmZddlZddlmZddlZddl    Z    ddl
mZmZm Z mZmZmZmZmZmZmZddlZddlmZddlmZmZmZddlmZmZdd    l m!Z!dd
l"m#Z#ddl$m%Z%m&Z&ddl'm(Z(m)Z)erôdd l*m+Z+m,Z,dZ-Gddde(Z.GdddejZ/Gddde.Z0ddddZ1dddddZ2dS)é)Úannotations)ÚabcÚdefaultdictN)ÚStringIO)
ÚIOÚ TYPE_CHECKINGÚDefaultDictÚHashableÚIteratorÚListÚLiteralÚMappingÚSequenceÚcast)Úlib)Ú    ArrayLikeÚ ReadCsvBufferÚScalar)ÚEmptyDataErrorÚParserError)Ú
is_integer)Úis_dict_like)Údedup_namesÚis_potential_multi_index)Ú
ParserBaseÚparser_defaults)ÚIndexÚ
MultiIndexuï»¿cs eZdZdddfddZdddddZdWd
ddd dZdddddZdXd
ddddZdddddZddddZ    d d!d"d d#d$d%Z
d&dd'd(Zd&d&d)d*d+Zd&d,d-d.d/Z d&dd0d1Zd2d"dd3d4d5Zd"d6d7d8d9Zd:d:d;d<d=Zd:d:d;d>d?Zd:d:d;d@dAZd:d2d2d:dBdCdDZd:d:d;dEdFZdddGdHZdIZdJdKdLdMdNZd:ddOdPdQZdYd
d:ddRdSZd:d:dTdUdVZZS)ZÚPythonParserzReadCsvBuffer[str] | listÚNone©ÚfÚreturnc
s~t |¡d_g_d_d_|d_tjrBj_nfdd_t    |d_
|d_|d_t jtrtj_|d    _|d
_|d_|d_|d _|d_|dpÐd_d_d|krì|d_|d_|d_|d_|d_t |tr2ttt|_nt|dsBt  |¡d_! "¡\}_#_$ %|j&¡\_'_&_(}tj'_)j*sÂ +j'¡\}_)_'d_,j&dkrÂ|_&j!dkrâtt-t.j'_! /j'¡_0d}j1r 2j!j'¡}|_3t.jdkr*t4dt5 6j¡}jdkrPd|d}nt5 6j¡}    d|    d|d}t5 7|¡_8dS)zN
        Workhorse function for processing nested list into DataFrame
        NrÚskiprowscs
|jkS©N)r#)Úx©Úself©úVd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/io/parsers/python_parser.pyÚ<lambda>Oóz'PythonParser.__init__.<locals>.<lambda>Ú
skipfooterÚ    delimiterÚ    quotecharÚ
escapecharÚdoublequoteÚskipinitialspaceÚlineterminatorÚquotingÚskip_blank_linesÚnamesFÚhas_index_namesÚverboseÚ    thousandsÚdecimalÚcommentÚreadlineTéz'Only length-1 decimal markers supportedz^[\-\+]?[0-9]*(z [0-9]*)?([0-9]?(E|e)\-?[0-9]+)?$z^[\-\+]?([0-9]+z    |[0-9])*()9ÚsuperÚ__init__ÚdataÚbufÚposÚline_posr#ÚcallableÚskipfuncÚ_validate_skipfooter_argr,r-r.Ú
isinstanceÚstrr/r0r1r2r3r4Znames_passedr6r7r8r9r:Úlistrr
ÚhasattrÚAssertionErrorÚ_make_readerÚ_col_indicesÚ_infer_columnsÚnum_original_columnsÚunnamed_colsZ_extract_multi_indexer_columnsÚindex_namesÚcolumnsÚ    col_namesÚ
orig_namesZ_has_complex_date_colÚ_get_index_nameZ_name_processedÚrangeÚlenZ_validate_parse_dates_presenceZ_parse_date_colsZparse_datesZ_set_noconvert_dtype_columnsÚ_no_thousands_columnsÚ
ValueErrorÚreÚescapeÚcompileÚnum)
r'r!ÚkwdsrQÚ_rPZno_thousands_columnsr9Úregexr8©Ú    __class__r&r)r>?s
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
üþûÿÿÿzPythonParser.__init__úIO[str] | ReadCsvBuffer[str]csBjdkstdkr$jr*tdGfdddtj}|}dk    rT|_n¾ ¡} |gg¡d} j    ¡s~|s¨j    d7_     ¡} |gg¡d}qnt
tt|}|d}j    d7_    j d7_ t ¡ |¡}|j|_tjt||d}j t|¡tj|dd}    nfd    d
}
|
}    |    _dS)Nr<z<Custom line terminators not supported in python parser (yet)cs4eZdZjZjZjZjZjZjZdZ    dS)z,PythonParser._make_reader.<locals>.MyDialectÚ
N)
Ú__name__Ú
__module__Ú__qualname__r-r.r/r0r1r3r2r(r&r(r)Ú    MyDialect»srgr)ÚdialectT)rhÚstrictc3s@ ¡}t ¡}| | ¡¡VD]}| | ¡¡Vq&dSr$)r;rYr[ÚsplitÚstrip)ÚlineÚpat)r!Úsepr(r)Ú_readås
 
z(PythonParser._make_reader.<locals>._read)r-rVr2rXÚcsvÚDialectr;Ú_check_commentsrDrArrrGrBÚSnifferÚsniffÚreaderrr@ÚextendrHr?)r'r!rgZdiarlÚlinesZ    lines_strÚsniffedZline_rdrruror()r!r'rnr)rK²s8ÿ        zPythonParser._make_readerNz
int | NonezRtuple[Index | None, Sequence[Hashable] | MultiIndex, Mapping[Hashable, ArrayLike]])Úrowsr"cCs"z| |¡}Wn*tk
r8|jr*g}n
| ¡YnXd|_t|j}t|st|jt|j|j    }| 
||j    |j|j¡\}}}|  ||j¡}|||fSt|d}d}    |jrÒ|t|krÒ|d}    |dd}| |¡}
| |
¡\}}| |¡}| ||¡\}}| ||
||    ¡\}} || |fS)NFrr<)Ú
_get_linesÚ StopIterationZ_first_chunkÚcloserHrSrVrrÚ    index_colZ_get_empty_metarPÚdtypeZ_maybe_make_multi_index_columnsrRÚcount_empty_valsr6Ú _rows_to_colsÚ_exclude_implicit_indexÚ _convert_dataZ_do_date_conversionsZ_make_index)r'ryÚcontentrQr5ÚindexZcol_dictZconv_columnsZcount_empty_content_valsZindexnamerowÚalldatar?Z    conv_dataZresult_columnsr(r(r)ÚreadõsR
þþü
 
 
 
ÿzPythonParser.readzlist[np.ndarray]z8tuple[Mapping[Hashable, np.ndarray], Sequence[Hashable]])rr"cs\t|jt|j|j}d|jr*t|jt| |¡fddt|D|fS)Nrcs&i|]\}}|kr||qSr(r()Ú.0ÚiÚname©rZlen_alldataÚoffsetr(r)Ú
<dictcomp>Csz8PythonParser._exclude_implicit_index.<locals>.<dictcomp>)rrSrr}Ú_implicit_indexrVZ_check_data_lengthÚ    enumerate)r'rr5r(rr)r.s"þþ
ÿþz$PythonParser._exclude_implicit_index)Úsizer"cCs|dkr|j}|j|dS)N)ry)Ú    chunksizer)r'rr(r(r)Ú    get_chunkHszPythonParser.get_chunkzMapping[Hashable, np.ndarray]zMapping[Hashable, ArrayLike])r?r"c    Cs| |j¡}| |j¡}i}i}t|jtr||jD]F}|j|}|j|}t|trh||jkrh|j|}|||<|||<q2n|j}|j}|     ||||j
||¡Sr$)Z_clean_mappingÚ
convertersr~rFÚ    na_valuesÚdictZ
na_fvaluesÚintrSZ_convert_to_ndarraysr7)    r'r?Z
clean_convZclean_dtypesZclean_na_valuesZclean_na_fvaluesÚcolZna_valueZ    na_fvaluer(r(r)rRs,
 
 
 
úzPythonParser._convert_dataz9tuple[list[list[Scalar | None]], int, set[Scalar | None]]©r"csü|jd}d}t}d|_|jdk    rô|j}t|tttjfrft    |dk}|rpt||ddg}n
d}|g}g}t
|D]`\}}z"| ¡}    |j|kr¤|  ¡}    qWntk
r¼}
zôd|jkrÔ|kr@nnh|rê||dkr@ttt|r|ddn|}dd |¡dt    |d    }td
|d|jd|
|r|dkr|r^| ¡| dgt    |d¡|||fWY¢*S|jstd |
|jdd}    W5d}
~
XYnXggt
|    D]V\} }|dkr|rød| d|}n
d| } | ¡ |¡n
 |¡qÎ|s*tt}fddtt    D}|D]Ð} | }|}||}|dkr|dkr¼|d||<|d|}|kr°|d7}n||}qx|jdk    rt|jr|j |¡dk    r|j |¡dkr|j ||j |¡i¡|| <|d||<qVn~|r¨||dkr¨t    }|j}|dk    r^t    |nd}t    }||kr|||ks|dkr¨d}dg||jdg|_| ¡| fddD¡t    |dkr|t    }q||rî| ¡dk    ràz|  ¡}Wntk
rd}YnX|dkr.dnt    |}t    t    |dkrbt    |krbtdt    |dkrxtd|j dk    r| !||¡nt    }|j"dk    rØt    t    |j"krØfddt#|j"Dg}ng}n| !||d|¡}nþz| ¡}    Wn@tk
r@}
z s$td |
dd}    W5d}
~
XYnX|    |_t    |    }|}s|tt|g}| !||d|¡}nv|j dkst    |kr°| !g|¡}t    }nBt$|j sØt    t    |j krØtd| !g|¡g}|}|||fS)NrTr<éÿÿÿÿFú[ú,z
], len of z, zPassed header=z    but only z lines in filezNo columns to parse from fileÚz    Unnamed: Z_level_csg|]}|kr|qSr(r(©rr)Úthis_unnamed_colsr(r)Ú
<listcomp>Àsþz/PythonParser._infer_columns.<locals>.<listcomp>Ú.csh|]}|qSr(r(r)Úthis_columnsr(r)Ú    <setcomp>ðsz.PythonParser._infer_columns.<locals>.<setcomp>zHNumber of passed names did not match number of header fields in the filez*Cannot pass names with multi-index columnscsg|]}|qSr(r(r)r5r(r)rs)%r5ÚsetÚ_header_lineÚheaderrFrHÚtupleÚnpZndarrayrVrÚ_buffered_linerBÚ
_next_liner{ÚmaprGÚjoinrXÚ _clear_bufferÚappendrrrrUr~rÚgetÚupdater}r@Ú    TypeErrorÚusecolsÚ_handle_usecolsrLÚsortedrC)r'rNZclear_bufferrOr¤Zhave_mi_columnsrQÚlevelÚhrrlÚerrZjoiÚmsgrÚcZcol_nameÚcountsZcol_loop_orderrZold_colZ    cur_countÚlcZsicZicZ unnamed_countÚ
first_lineZlen_first_data_rowZncolsr()r5r rr)rMus&
ÿ
ÿ ÿý
 
 
 
 
 
þü
 
 
 
ÿþýü"
 
 
 
 
$ÿÿÿ
ÿ
 ÿzPythonParser._infer_columnszlist[list[Scalar | None]]zlist[Scalar | None]r)rQÚusecols_keyrNr"c    sú|jdk    röt|jr$| |j|¡n¶tdd|jDr¬t|dkrLtdg|jD]R}t|trz |     |¡¡Wq¨tk
r| 
|j|¡Yq¨XqV |¡qVn.fdd|jD}|rÔtd|d    |jfd
d|D}t|_ |S)zb
        Sets self._col_indices
 
        usecols_key is used if there are string usecols.
        Ncss|]}t|tVqdSr$)rFrG)rÚur(r(r)Ú    <genexpr>Nsz/PythonParser._handle_usecols.<locals>.<genexpr>r<z4If using multiple headers, usecols must be integers.csg|]}|kr|qSr(r()rr)rNr(r)r^sz0PythonParser._handle_usecols.<locals>.<listcomp>z;Defining usecols without of bounds indices is not allowed. z are out of bounds.cs"g|]}fddt|DqS)csg|]\}}|kr|qSr(r()rrÚn©Úcol_indicesr(r)risz;PythonParser._handle_usecols.<locals>.<listcomp>.<listcomp>)r)rÚcolumnr¿r(r)rhsÿ)r°rCZ_evaluate_usecolsÚanyrVrXrFrGr¬rZ_validate_usecols_namesrr²rL)r'rQr»rNrZmissing_usecolsr()rÀrNr)r±?s:
 
ÿ
 
 
ÿ
ÿ
þ
zPythonParser._handle_usecolszlist[Scalar]cCs$t|jdkr|jdS| ¡SdS)zH
        Return a line from buffer, filling buffer if required.
        rN)rVr@r¨r&r(r(r)r§os
zPythonParser._buffered_line)Ú    first_rowr"c    CsÖ|s|St|dts|S|ds&|S|dd}|tkr>|S|d}t|dkr´|d|jkr´d}|d}|dd |¡d}|||}t||dkrÀ|||dd7}n|dd}|g}||ddS)a-
        Checks whether the file begins with the BOM character.
        If it does, remove it. In addition, if there is quoting
        in the field subsequent to the BOM, remove it as well
        because it technically takes place at the beginning of
        the name, not the middle of it.
        rr<éN)rFrGÚ_BOMrVr.r)    r'rÃZ    first_eltZ first_row_bomÚstartÚquoteÚendÚnew_rowZnew_row_listr(r(r)Ú_check_for_bomxs(
zPythonParser._check_for_bomÚbool)rlr"cCs|ptdd|DS)zô
        Check if a line is empty or not.
 
        Parameters
        ----------
        line : str, array-like
            The line of data to check.
 
        Returns
        -------
        boolean : Whether or not the line is empty.
        css|]}|VqdSr$r(©rr%r(r(r)r½ºsz.PythonParser._is_line_empty.<locals>.<genexpr>)Úall)r'rlr(r(r)Ú_is_line_emptys zPythonParser._is_line_emptycCs¦t|jtrÈ| |j¡r:|jt|jkr*q:|jd7_qzp| |j|jg¡d}|jd7_|js| |j|jd¡s|rWqÆ|jr¨|     |g¡}|r¨|d}WqÆWq:t
k
rÂtYq:Xq:nª| |j¡rü|jd7_|jdk    sðtt |jqÈ|j|jdd}|jd7_|dk    rü| |g¡d}|jr\|     |g¡}|rp|d}qrqü| |¡sr|rüqrqü|jdkr| |¡}|jd7_|j |¡|S)Nr<r©Úrow_num)rFr?rHrDrArVrrr4rÎÚ_remove_empty_linesÚ
IndexErrorr{rJÚnextÚ_next_iter_linerÊrBr@r¬)r'rlÚretZ    orig_liner(r(r)r¨¼sRÿÿ
zPythonParser._next_linerG)r¶rÐr"cCsH|j|jjkrt||j|jjkrDd|d}tj ||d¡dS)a 
        Alert a user about a malformed row, depending on value of
        `self.on_bad_lines` enum.
 
        If `self.on_bad_lines` is ERROR, the alert will be `ParserError`.
        If `self.on_bad_lines` is WARN, the alert will be printed out.
 
        Parameters
        ----------
        msg: str
            The error message to display.
        row_num: int
            The row number where the parsing error occurred.
            Because this row number is displayed, we 1-index,
            even though we 0-index internally.
        zSkipping line z: rcN)Úon_bad_linesÚBadLineHandleMethodÚERRORrÚWARNÚsysÚstderrÚwrite)r'r¶rÐÚbaser(r(r)Ú_alert_malformedôs
zPythonParser._alert_malformedzlist[Scalar] | None)rÐr"c
Cs´z,|jdk    stt|j}t|ts(t|WStjk
r®}zb|j|jj    |jj
fkrt|}d|ksnd|krrd}|jdkrd}|d|7}|  ||¡WY¢dSd}~XYnXdS)a[
        Wrapper around iterating through `self.data` (CSV source).
 
        When a CSV error is raised, we check for specific
        error messages that allow us to customize the
        error message displayed to the user.
 
        Parameters
        ----------
        row_num: int
            The row number of the line being parsed.
        Nz    NULL bytezline contains NULzNULL byte detected. This byte cannot be processed in Python's native csv library at the moment, so please pass in engine='c' insteadrz¡Error could possibly be due to parsing errors in the skipped footer rows (the skipfooter keyword is only applied after Python's csv library has parsed all rows).ú. )r?rJrÓrFrHrpÚErrorrÖr×rØrÙrGr,rÞ)r'rÐrlÚer¶Úreasonr(r(r)rÔs( 
þÿ
ÿzPythonParser._next_iter_lineúlist[list[Scalar]]©rwr"cCs|jdkr|Sg}|D]t}g}|D]\}t|trD|j|ksD||jkrP| |¡q"|d| |j¡}t|dkrz| |¡qq"| |¡q|S)Nr)r:rFrGrr¬ÚfindrV)r'rwrÕrlÚrlr%r(r(r)rr;s&
ÿþý
zPythonParser._check_commentscCsNg}|D]@}t|dks>t|dkrt|dtr>|d ¡r| |¡q|S)a
        Iterate through the lines and remove any that are
        either empty or contain only one whitespace value
 
        Parameters
        ----------
        lines : list of list of Scalars
            The array of lines that we are to filter.
 
        Returns
        -------
        filtered_lines : list of list of Scalars
            The same array of lines with the "empty" ones removed.
        r<r)rVrFrGrkr¬)r'rwrÕrlr(r(r)rÑPs
ÿ
þý
ýz PythonParser._remove_empty_linescCs |jdkr|S|j||jddS)Nr©rwÚsearchÚreplace)r8Ú_search_replace_num_columns©r'rwr(r(r)Ú_check_thousandsjs
ÿzPythonParser._check_thousands)rwrèrér"c    Csg}|D]t}g}t|D]X\}}t|trR||ksR|jrB||jksR|j | ¡¡s^| |¡q| | ||¡¡q| |¡q|Sr$)    rrFrGrWr\rèrkr¬ré)    r'rwrèrérÕrlrærr%r(r(r)rêrs$ÿþýýüz(PythonParser._search_replace_num_columnscCs$|jtdkr|S|j||jddS)Nr9rrç)r9rrêrër(r(r)Ú_check_decimalsÿzPythonParser._check_decimalcCs
g|_dSr$)r@r&r(r(r)r«szPythonParser._clear_bufferFzSequence[Hashable]z@tuple[Sequence[Hashable] | None, list[Hashable], list[Hashable]])rQr"c
Csxt|}t|}|jdk    r"|j}n&z| ¡}Wntk
rFd}YnXz| ¡}Wntk
rld}YnXd}|dk    r(|j}|dk    rt||j}|dk    r(|jdk    r(|dk    r(t|t||jkr(ttt||_|j    dd|_    t
|D]}| d|¡qút|}t||_|||fS|dkrXd|_|jdkrRtt||_d}n|  ||j¡\}}    |_|||fS)aÐ
        Try several cases to get lines:
 
        0) There are headers on row 0 and row 1 and their
        total summed lengths equals the length of the next line.
        Treat row 0 as columns and row 1 as indices
        1) Look for implicit index: there are more columns
        on row 1 than row 0. If this is true, assume that row
        1 lists index columns and row 0 lists normal columns.
        2) Get index from the columns if it was listed.
        NrFr<T)rHr£r¨r{r}rVrNr¤rUr@ÚreversedÚinsertrZ_clean_index_names)
r'rQrSrlZ    next_lineZimplicit_first_colsr}r·Z
index_namer^r(r(r)rTsR
 
 
 
ÿþý
 
 
ÿzPythonParser._get_index_name)rr"csöj}jr|tj7}tdd|D}||krjdk    rjdkrjrZjnd}g}t|}t|}g}|D]\}}    t|    }
|
|krtj    r¼     |    ¡}|dk    rº| 
|¡nNj    jjjj fkrj|||}| 
||
f¡j    jjkrqqz| 
|    ¡qz|D]j\}}
d|d|dd|
} jrttjdkrtjtjkrtd    }| d
|7}  | |d¡qttj||dj}jròjdk    s´tjjrÜfdd t|D}nfdd t|D}|S)Ncss|]}t|VqdSr$)rV©rÚrowr(r(r)r½åsz-PythonParser._rows_to_cols.<locals>.<genexpr>Frz    Expected z fields in line r<z, saw zXError could possibly be due to quotes being ignored when a multi-char delimiter is used.rß)Z    min_widthcs4g|],\}}|tjks,|tjkr|qSr()rVr}©rrÚa©rÀr'r(r)r'süz.PythonParser._rows_to_cols.<locals>.<listcomp>csg|]\}}|kr|qSr(r(ròr¿r(r)r0s)rNrrVr}Úmaxr°r,rrCrÖr¬r×rØrÙrAr-r3rpÚ
QUOTE_NONErÞrHrZto_object_arrayÚTrLrJ)r'rZcol_lenÚmax_lenZfootersZ    bad_linesÚiter_contentZcontent_lenrÚ_contentZ
actual_lenZnew_lrÐr¶râZzipped_contentr(rôr)rßspÿþý
 
 
þÿÿþ
ýÿþ    
ÿzPythonParser._rows_to_colsc    Cs`|j}d}|dk    rPt|j|krB|jd||j|d}|_n|t|j8}|dkrt|jtrÜ|jt|jkrzt|dkr|j|jd}t|j}n |j|j|j|}|j|}| |¡}| |¡||_n0g}zÚ|dk    rvd}|j    dk    r$|jdk    r$tt
|j    t
t|j}t||D]&}|jdk    sDt|  t|j¡q0t|}| |¡}| |¡nBd}|j|j|dd}|d7}|dk    rz|  |¡qzt|}WnBtk
rüt|}| |¡}| |¡t|dkrøYnX|j|7_g|_n|}|jr0|d|j}| |¡}|jrL| |¡}| |¡}| |¡S)Nrr<rÏ)r@rVrFr?rHrAr{Ú_remove_skipped_rowsrvr#r¢rUrJr¬rÓrÔr,rrr4rÑrìrí)    r'ryrwÚnew_rowsÚnew_posZrows_to_skipr^Zlen_new_rowsrÉr(r(r)rz5sl"
 
 
 
 
 
ÿ
 
 
 
 
 
 
zPythonParser._get_lines)rür"cs jrfddt|DS|S)Ncs$g|]\}} |j¡s|qSr()rDrA)rrrñr&r(r)rsz5PythonParser._remove_skipped_rows.<locals>.<listcomp>)r#r)r'rür(r&r)rûs
 
ÿz!PythonParser._remove_skipped_rows)N)N)N)rdrerfr>rKrrrrrMr±r§rÊrÎr¨rÞrÔrrrÑrìrêrír«rrTrrzrûÚ __classcell__r(r(r`r)r>s8sDÿ9ÿ
#K0    580MVQrc    @sbeZdZdZdddddddd    d
ddZdddd dddZdddddddZd dddZdS)ÚFixedWidthReaderz(
    A reader of fixed-width lines.
    Nédrbz(list[tuple[int, int]] | Literal['infer']z
str | Nonezset[int] | Nonerr)r!Úcolspecsr-r:r#Úinfer_nrowsr"cCsÎ||_d|_|rd|nd|_||_|dkr>|j||d|_n||_t|jttfsht    dt
|j|jD]Z}t|ttfrÀt|dkrÀt|dt tjt
dfrÀt|dt tjt
dfsnt    d    qndS)
Nz 
z
      Zinfer)rr#z;column specifications must be a list or tuple, input was a rÄrr<zEEach column specification must be 2 element tuple or list of integers)r!Úbufferr-r:Údetect_colspecsrrFr¥rHr¯ÚtyperdrVrr¦Úinteger)r'r!rr-r:r#rZcolspecr(r(r)r>s4    ÿ
ÿ
ÿ
þýüÿzFixedWidthReader.__init__z    list[str])rr#r"cCsd|dkrt}g}g}t|jD]4\}}||kr:| |¡| |¡t||kr qVq t||_|S)aÉ
        Read rows from self.f, skipping as specified.
 
        We distinguish buffer_rows (the first <= infer_nrows
        lines) from the rows returned to detect_colspecs
        because it's simpler to leave the other locations
        with skiprows logic alone than to modify them to
        deal with the fact we skipped some rows here as
        well.
 
        Parameters
        ----------
        infer_nrows : int
            Number of rows to read from self.f, not counting
            rows that are skipped.
        skiprows: set, optional
            Indices of rows to skip.
 
        Returns
        -------
        detect_rows : list of str
            A list containing the rows to read.
 
        N)r¢rr!r¬rVÚiterr)r'rr#Zbuffer_rowsZdetect_rowsrrñr(r(r)Úget_rows¹s
 
 
zFixedWidthReader.get_rowszlist[tuple[int, int]]c súd ddjD¡}t d|d¡} ||¡}|s@tdttt|}t    j
|dtd}jdk    r|fd    d|D}|D](}|  |¡D]}    d||     ¡|     ¡<qqt     |d¡}
d
|
d
<t     ||
Adk¡d
}tt|ddd|ddd}|S)NrcSsg|]}d|qS)ú\r(rÌr(r(r)rãsz4FixedWidthReader.detect_colspecs.<locals>.<listcomp>z([^z]+)z(No rows from which to infer column widthr<)r~csg|]}| j¡dqS)r)Ú    partitionr:rðr&r(r)rësrrÄ)rªr-rYr[rrrõr©rVr¦Úzerosrr:ÚfinditerrÆrÈZrollÚwhererHÚzip) r'rr#Ú
delimitersÚpatternryrøÚmaskrñÚmZshiftedÚedgesZ
edge_pairsr(r&r)rßs"
"z FixedWidthReader.detect_colspecsrcs`jdk    r@ztjWqJtk
r<d_tjYqJXn
tjfddjDS)Ncs$g|]\}}|| j¡qSr()rkr-)rÚfrom_Úto©rlr'r(r)rsz-FixedWidthReader.__next__.<locals>.<listcomp>)rrÓr{r!rr&r(rr)Ú__next__õs
 
zFixedWidthReader.__next__)Nr)N)rN)rdrerfÚ__doc__r>rrrr(r(r(r)rÿs
ù&'ÿrÿc@s@eZdZdZdddddZddddd    Zd
d
ddd ZdS)ÚFixedWidthFieldParserzl
    Specialization that Converts fixed-width fields into DataFrames.
    See PythonParser for details.
    zReadCsvBuffer[str]rr cKs,| d¡|_| d¡|_tj||f|dS)Nrr)Úpoprrrr>)r'r!r]r(r(r)r>
szFixedWidthFieldParser.__init__rbcCs"t||j|j|j|j|j|_dSr$)rÿrr-r:r#rr?)r'r!r(r(r)rKsúz"FixedWidthFieldParser._make_readerrãräcCsdd|DS)z¿
        Returns the list of lines without the empty ones. With fixed-width
        fields, empty lines become arrays of empty strings.
 
        See PythonParser._remove_empty_lines.
        cSs"g|]}tdd|Dr|qS)css"|]}t|tp| ¡VqdSr$)rFrGrk)rrár(r(r)r½$szGFixedWidthFieldParser._remove_empty_lines.<locals>.<listcomp>.<genexpr>)rÂ)rrlr(r(r)r!sþz=FixedWidthFieldParser._remove_empty_lines.<locals>.<listcomp>r(rër(r(r)rÑsþz)FixedWidthFieldParser._remove_empty_linesN)rdrerfrr>rKrÑr(r(r(r)rs
rrrcCstdd|DS)Ncss"|]}|dks|dkrdVqdS)rNr<r()rÚvr(r(r)r½)sz#count_empty_vals.<locals>.<genexpr>)Úsum)Úvalsr(r(r)r(sr)r,r"cCs$t|std|dkr td|S)að
    Validate the 'skipfooter' parameter.
 
    Checks whether 'skipfooter' is a non-negative integer.
    Raises a ValueError if that is not the case.
 
    Parameters
    ----------
    skipfooter : non-negative integer
        The number of rows to skip at the end of the file.
 
    Returns
    -------
    validated_skipfooter : non-negative integer
        The original input if the validation succeeds.
 
    Raises
    ------
    ValueError : 'skipfooter' was not a non-negative integer.
    zskipfooter must be an integerrzskipfooter cannot be negative)rrX)r,r(r(r)rE,s
rE)3Ú
__future__rÚcollectionsrrrpÚiorrYrÚÚtypingrrrr    r
rrr rrÚnumpyr¦Zpandas._libsrZpandas._typingrrrZ pandas.errorsrrZpandas.core.dtypes.commonrZpandas.core.dtypes.inferencerZpandas.io.commonrrZpandas.io.parsers.base_parserrrZpandasrrrÅrrÿrrrEr(r(r(r)Ú<module>s<0     Xv$