o ;Di7@s8ddlmZmZmZddlmZddlmZmZddl m Z m Z m Z m Z ddZee _d$dd Zee _d d Zee _d d Zee _Gddde ZdefdefffddZee _defdefffddZee _Gddde ZddZee _ddZee _Gddde ZddZee _d d!Zee _d"d#Zee _dS)%)absolute_importprint_functiondivision)Counter) string_types maketrans)valuesTabledatawrapcCstddt|DS)z Count the number of data rows in a table. E.g.:: >>> import petl as etl >>> table = [['foo', 'bar'], ['a', 1], ['b', 2]] >>> etl.nrows(table) 2 css|]}dVqdSN).0_rrK/var/www/Datamplify/venv/lib/python3.10/site-packages/petl/util/counting.py sznrows..)sumr )tablerrrnrows s rNcCsDd}d}t|||dD]}|d7}||kr|d7}q |t||fS)a Count the number of occurrences of `value` under the given field. Returns the absolute count and relative frequency as a pair. E.g.:: >>> import petl as etl >>> table = [['foo', 'bar'], ... ['a', 1], ... ['b', 2], ... ['b', 7]] >>> etl.valuecount(table, 'foo', 'b') (2, 0.6666666666666666) The `field` argument can be a single field name or index (starting from zero) or a tuple of field names and/or indexes. rmissingr )rfloat)rfieldvaluertotalvsvrrr valuecountsrc OsP|dd}t}t|||dD]}z ||d7<Wqty%Yqw|S)a3 Find distinct values for the given field and count the number of occurrences. Returns a :class:`dict` mapping values to counts. E.g.:: >>> import petl as etl >>> table = [['foo', 'bar'], ... ['a', True], ... ['b'], ... ['b', True], ... ['c', False]] >>> etl.valuecounter(table, 'foo') Counter({'b': 2, 'a': 1, 'c': 1}) The `field` argument can be a single field name or index (starting from zero) or a tuple of field names and/or indexes. rNrr )getrr IndexError)rrkwargsrcounterrrrr valuecounter:s  r#cOst||fi|S)a Find distinct values for the given field and count the number and relative frequency of occurrences. Returns a table mapping values to counts, with most common values first. E.g.:: >>> import petl as etl >>> table = [['foo', 'bar', 'baz'], ... ['a', True, 0.12], ... ['a', True, 0.17], ... ['b', False, 0.34], ... ['b', False, 0.44], ... ['b']] >>> etl.valuecounts(table, 'foo') +-----+-------+-----------+ | foo | count | frequency | +=====+=======+===========+ | 'b' | 3 | 0.6 | +-----+-------+-----------+ | 'a' | 2 | 0.4 | +-----+-------+-----------+ >>> etl.valuecounts(table, 'foo', 'bar') +-----+-------+-------+-----------+ | foo | bar | count | frequency | +=====+=======+=======+===========+ | 'a' | True | 2 | 0.4 | +-----+-------+-------+-----------+ | 'b' | False | 2 | 0.4 | +-----+-------+-------+-----------+ | 'b' | None | 1 | 0.2 | +-----+-------+-------+-----------+ If rows are short, the value of the keyword argument `missing` is counted. Multiple fields can be given as positional arguments. If multiple fields are given, these are treated as a compound key. )ValueCountsView)rrr!rrr valuecountsZs(r%c@seZdZdddZddZdS)r$NcCs||_||_||_dSN)rrr)selfrrrrrr__init__s zValueCountsView.__init__ccst|jttfrt|jd}n|jddf}|Vt|jg|jRd|ji}|}tdd|D}t |jdkrV|D]}t|d|dt |d|fVq>dS|D]}|d|dt |d|fVqXdS) N)count frequencyr)r*rcs|]}|dVqdSr rrcrrrrz+ValueCountsView.__iter__..r r) isinstancertuplelistr#rr most_commonrlenr)r'outhdrr"countsrr-rrr__iter__s ("zValueCountsView.__iter__r&__name__ __module__ __qualname__r(r6rrrrr$s  r$intrc Cst|ttfr t|}tt}}|D] }d||<d||<qt||D],}t|trR|D] \}}z||Wn ||d7<Yq1||d7<q1q&||fS)ah Count the number of `str` or `unicode` values under the given fields that can be parsed as ints, floats or via custom parser functions. Return a pair of `Counter` objects, the first mapping parser names to the number of strings successfully parsed, the second mapping parser names to the number of errors. E.g.:: >>> import petl as etl >>> table = [['foo', 'bar', 'baz'], ... ['A', 'aaa', 2], ... ['B', u'2', '3.4'], ... [u'B', u'3', u'7.8', True], ... ['D', '3.7', 9.0], ... ['E', 42]] >>> counter, errors = etl.parsecounter(table, 'bar') >>> counter Counter({'float': 3, 'int': 2}) >>> errors Counter({'int': 2, 'float': 1}) The `field` argument can be a field name or index (starting from zero). rr ) r/r1r0dictrkeysrritems) rrparsersr"errorsnrnameparserrrr parsecounters     rDcCst|||dS)a Count the number of `str` or `unicode` values that can be parsed as ints, floats or via custom parser functions. Return a table mapping parser names to the number of values successfully parsed and the number of errors. E.g.:: >>> import petl as etl >>> table = [['foo', 'bar', 'baz'], ... ['A', 'aaa', 2], ... ['B', u'2', '3.4'], ... [u'B', u'3', u'7.8', True], ... ['D', '3.7', 9.0], ... ['E', 42]] >>> etl.parsecounts(table, 'bar') +---------+-------+--------+ | type | count | errors | +=========+=======+========+ | 'float' | 3 | 1 | +---------+-------+--------+ | 'int' | 2 | 2 | +---------+-------+--------+ The `field` argument can be a field name or index (starting from zero). )r?)ParseCountsView)rrr?rrr parsecountssrFc@s,eZdZdefdefffddZddZdS)rEr;rcCs,||_||_t|ttfrt|}||_dSr&)rrr/r1r0r<r?)r'rrr?rrrr(s  zParseCountsView.__init__ccsDt|j|j|j\}}dV|D] \}}||||fVqdS)N)typer)r@)rDrrr?r2)r'r"r@itemrArrrr6s zParseCountsView.__iter__N)r8r9r:r;rr(r6rrrrrEs rEc CsDt}t||D]}z ||jjd7<WqtyYqw|S)a Count the number of values found for each Python type. >>> import petl as etl >>> table = [['foo', 'bar', 'baz'], ... ['A', 1, 2], ... ['B', u'2', '3.4'], ... [u'B', u'3', u'7.8', True], ... ['D', u'xyz', 9.0], ... ['E', 42]] >>> etl.typecounter(table, 'foo') Counter({'str': 5}) >>> etl.typecounter(table, 'bar') Counter({'str': 3, 'int': 2}) >>> etl.typecounter(table, 'baz') Counter({'str': 2, 'int': 1, 'float': 1, 'NoneType': 1}) The `field` argument can be a field name or index (starting from zero). r )rr __class__r8r )rrr"rrrr typecounters rJcCs t||S)a Count the number of values found for each Python type and return a table mapping class names to counts and frequencies. E.g.:: >>> import petl as etl >>> table = [['foo', 'bar', 'baz'], ... [b'A', 1, 2], ... [b'B', '2', b'3.4'], ... ['B', '3', '7.8', True], ... ['D', u'xyz', 9.0], ... ['E', 42]] >>> etl.typecounts(table, 'foo') +---------+-------+-----------+ | type | count | frequency | +=========+=======+===========+ | 'str' | 3 | 0.6 | +---------+-------+-----------+ | 'bytes' | 2 | 0.4 | +---------+-------+-----------+ >>> etl.typecounts(table, 'bar') +-------+-------+-----------+ | type | count | frequency | +=======+=======+===========+ | 'str' | 3 | 0.6 | +-------+-------+-----------+ | 'int' | 2 | 0.4 | +-------+-------+-----------+ >>> etl.typecounts(table, 'baz') +------------+-------+-----------+ | type | count | frequency | +============+=======+===========+ | 'int' | 1 | 0.2 | +------------+-------+-----------+ | 'bytes' | 1 | 0.2 | +------------+-------+-----------+ | 'str' | 1 | 0.2 | +------------+-------+-----------+ | 'float' | 1 | 0.2 | +------------+-------+-----------+ | 'NoneType' | 1 | 0.2 | +------------+-------+-----------+ The `field` argument can be a field name or index (starting from zero). )TypeCountsViewrrrrr typecounts&s 1rMc@seZdZddZddZdS)rKcCs||_||_dSr&rL)r'rrrrrr(_s zTypeCountsView.__init__ccs^t|j|j}dV|}tdd|D}|D]}|d|dt|d|fVqdS)N)rGr)r*csr+r rr,rrrrgr.z*TypeCountsView.__iter__..rr )rJrrr2rr)r'r"r5rr-rrrr6cs"zTypeCountsView.__iter__Nr7rrrrrK]s rKcCsBtdd}t}t||D]}t||}||d7<q |S)zp Profile string patterns in the given field, returning a :class:`dict` mapping patterns to counts. >ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789>AAAAAAAAAAAAAAAAAAAAAAAAAAaaaaaaaaaaaaaaaaaaaaaaaaaa9999999999r )rrrstr translate)rrtransr"rprrrstringpatterncounterlsrTcsNt||}dg}|}tdd|Dfdd|D}||t|S)a  Profile string patterns in the given field, returning a table of patterns, counts and frequencies. E.g.:: >>> import petl as etl >>> table = [['foo', 'bar'], ... ['Mr. Foo', '123-1254'], ... ['Mrs. Bar', '234-1123'], ... ['Mr. Spo', '123-1254'], ... [u'Mr. Baz', u'321 1434'], ... [u'Mrs. Baz', u'321 1434'], ... ['Mr. Quux', '123-1254-XX']] >>> etl.stringpatterns(table, 'foo') +------------+-------+---------------------+ | pattern | count | frequency | +============+=======+=====================+ | 'Aa. Aaa' | 3 | 0.5 | +------------+-------+---------------------+ | 'Aaa. Aaa' | 2 | 0.3333333333333333 | +------------+-------+---------------------+ | 'Aa. Aaaa' | 1 | 0.16666666666666666 | +------------+-------+---------------------+ >>> etl.stringpatterns(table, 'bar') +---------------+-------+---------------------+ | pattern | count | frequency | +===============+=======+=====================+ | '999-9999' | 3 | 0.5 | +---------------+-------+---------------------+ | '999 9999' | 2 | 0.3333333333333333 | +---------------+-------+---------------------+ | '999-9999-AA' | 1 | 0.16666666666666666 | +---------------+-------+---------------------+ )patternr)r*csr+r rr,rrrrr.z!stringpatterns..cs*g|]}|d|dt|dfqS)rr )rr,rrr s*z"stringpatterns..)rTr2rextendr )rrr"outputcntsrrVrstringpatternss % r[cCsDt}t|D] }|t|d7<qdg}||t|S)a Report on row lengths found in the table. E.g.:: >>> import petl as etl >>> table = [['foo', 'bar', 'baz'], ... ['A', 1, 2], ... ['B', '2', '3.4'], ... [u'B', u'3', u'7.8', True], ... ['D', 'xyz', 9.0], ... ['E', None], ... ['F', 9]] >>> etl.rowlengths(table) +--------+-------+ | length | count | +========+=======+ | 3 | 3 | +--------+-------+ | 2 | 2 | +--------+-------+ | 4 | 1 | +--------+-------+ Useful for finding potential problems in data files. r )lengthr))rr r3rXr2r )rr"rowrYrrr rowlengthss  r^r&) __future__rrr collectionsr petl.compatrrpetl.util.baserr r r rrr#r%r$r;rrDrFrErJrMrKrTr[r^rrrrs:  +,4. #