Viu ~ S r SSKJr SSKrSSKJrJr " S S\5 r " S S\5 r SS jr
S
r \ " \ R R 5 5 H_ u rr\" \\5 ( d M \S ; a M \S ; a M& \ " \5 r\R$ R \l \\" 5 \' \" \ S
\- 5 Ma CCCSS jrg)aE ``statsutils`` provides tools aimed primarily at descriptive
statistics for data analysis, such as :func:`mean` (average),
:func:`median`, :func:`variance`, and many others,
The :class:`Stats` type provides all the main functionality of the
``statsutils`` module. A :class:`Stats` object wraps a given dataset,
providing all statistical measures as property attributes. These
attributes cache their results, which allows efficient computation of
multiple measures, as many measures rely on other measures. For
example, relative standard deviation (:attr:`Stats.rel_std_dev`)
relies on both the mean and standard deviation. The Stats object
caches those results so no rework is done.
The :class:`Stats` type's attributes have module-level counterparts for
convenience when the computation reuse advantages do not apply.
>>> stats = Stats(range(42))
>>> stats.mean
20.5
>>> mean(range(42))
20.5
Statistics is a large field, and ``statsutils`` is focused on a few
basic techniques that are useful in software. The following is a brief
introduction to those techniques. For a more in-depth introduction,
`Statistics for Software
`_,
an article I wrote on the topic. It introduces key terminology vital
to effective usage of statistics.
Statistical moments
-------------------
Python programmers are probably familiar with the concept of the
*mean* or *average*, which gives a rough quantitiative middle value by
which a sample can be can be generalized. However, the mean is just
the first of four `moment`_-based measures by which a sample or
distribution can be measured.
The four `Standardized moments`_ are:
1. `Mean`_ - :func:`mean` - theoretical middle value
2. `Variance`_ - :func:`variance` - width of value dispersion
3. `Skewness`_ - :func:`skewness` - symmetry of distribution
4. `Kurtosis`_ - :func:`kurtosis` - "peakiness" or "long-tailed"-ness
For more information check out `the Moment article on Wikipedia`_.
.. _moment: https://en.wikipedia.org/wiki/Moment_(mathematics)
.. _Standardized moments: https://en.wikipedia.org/wiki/Standardized_moment
.. _Mean: https://en.wikipedia.org/wiki/Mean
.. _Variance: https://en.wikipedia.org/wiki/Variance
.. _Skewness: https://en.wikipedia.org/wiki/Skewness
.. _Kurtosis: https://en.wikipedia.org/wiki/Kurtosis
.. _the Moment article on Wikipedia: https://en.wikipedia.org/wiki/Moment_(mathematics)
Keep in mind that while these moments can give a bit more insight into
the shape and distribution of data, they do not guarantee a complete
picture. Wildly different datasets can have the same values for all
four moments, so generalize wisely.
Robust statistics
-----------------
Moment-based statistics are notorious for being easily skewed by
outliers. The whole field of robust statistics aims to mitigate this
dilemma. ``statsutils`` also includes several robust statistical methods:
* `Median`_ - The middle value of a sorted dataset
* `Trimean`_ - Another robust measure of the data's central tendency
* `Median Absolute Deviation`_ (MAD) - A robust measure of
variability, a natural counterpart to :func:`variance`.
* `Trimming`_ - Reducing a dataset to only the middle majority of
data is a simple way of making other estimators more robust.
.. _Median: https://en.wikipedia.org/wiki/Median
.. _Trimean: https://en.wikipedia.org/wiki/Trimean
.. _Median Absolute Deviation: https://en.wikipedia.org/wiki/Median_absolute_deviation
.. _Trimming: https://en.wikipedia.org/wiki/Trimmed_estimator
Online and Offline Statistics
-----------------------------
Unrelated to computer networking, `online`_ statistics involve
calculating statistics in a `streaming`_ fashion, without all the data
being available. The :class:`Stats` type is meant for the more
traditional offline statistics when all the data is available. For
pure-Python online statistics accumulators, look at the `Lithoxyl`_
system instrumentation package.
.. _Online: https://en.wikipedia.org/wiki/Online_algorithm
.. _streaming: https://en.wikipedia.org/wiki/Streaming_algorithm
.. _Lithoxyl: https://github.com/mahmoud/lithoxyl
)print_functionN)floorceilc $ \ rS rSrS rSS jrSrg)_StatsProperty c Xl X l SU- U l UR =( d SnUR S5 u n nX@l g )N_ z>>>)namefunc
internal_name__doc__ partition)selfr r
docpre_doctest_docr
s e/home/james-whalen/.local/share/pipx/venvs/semgrep/lib/python3.13/site-packages/boltons/statsutils.py__init___StatsProperty.__init__ s@ 4Zll b #
e 4 A& Nc Uc U $ UR ( d UR $ [ XR 5 $ ! [ a= [ XR U R
U5 5 [ XR 5 s $ f = fN)datadefaultgetattrr AttributeErrorsetattrr
)r objobjtypes r __get___StatsProperty.__get__ sk ;Kxx;; 43 2 23 3 4 C++TYYs^ <3 2 23 3 4s 9 AB ?B )r r
r r r )__name__
__module__ __qualname____firstlineno__r r! __static_attributes__ r r r r s ' 4r r c \ rS rSrSrS/S jrS rS rS rS r S r
\ " S \
5 r S
r
\ " S \
5 rS r\ " S
\5 rS r\ " S\5 rS r\ " S\5 rS r\ " S\5 rS r\ " S\5 rS r\ " S\5 rS r\ " S\5 r S r \ " S\ 5 r \ r S r \ " S \ 5 r!S r"\ " S \"5 r#S r$\ " S!\$5 r%S" r&\ " S#\&5 r'\(S$ 5 r)S% r*S& r+S0S' jr,S( r-S1S* jr.S2S+ jr/S2S, jr0S3S- jr1S.r2g))4Stats a The ``Stats`` type is used to represent a group of unordered
statistical datapoints for calculations such as mean, median, and
variance.
Args:
data (list): List or other iterable containing numeric values.
default (float): A value to be returned when a given
statistical measure is not defined. 0.0 by default, but
``float('nan')`` is appropriate for stricter applications.
use_copy (bool): By default Stats objects copy the initial
data into a new list to avoid issues with
modifications. Pass ``False`` to disable this behavior.
is_sorted (bool): Presorted data can skip an extra sorting
step for a little speed boost. Defaults to False.
c
X0l X@l U( a [ U5 U l OXl X l U R
n[
U 5 Vs/ s H& n[ [ XVS 5 [ 5 ( d M$ UPM( snU l
SU l g s snf )Nr ) _use_copy
_is_sortedlistr r __class__dir
isinstancer r _prop_attr_names_pearson_precision)r r r use_copy is_sortedclsas r r Stats.__init__ su !# T
DI I nn,/I !@Iq$.wst/D/=%? "#I !@ #$ !@s
#B1Bc , [ U R 5 $ r lenr r s r __len__
Stats.__len__ s 499~ r c , [ U R 5 $ r )iterr r= s r __iter__Stats.__iter__ s DII r c U R ( d [ U R 5 $ U R ( d U R R 5 U R $ )a When using a copy of the data, it's better to have that copy be
sorted, but we do it lazily using this method, in case no
sorted measures are used. I.e., if median is never called,
sorting would be a waste.
When not using a copy, it's presumed that all optimizations
are on the user.
)r- sortedr r. sortr= s r _get_sorted_dataStats._get_sorted_data s9 ~~$))$ $ IINN yyr c U R H@ n[ U R U5 R n[ X5 ( d M5 [ X5 MB g)a\ ``Stats`` objects automatically cache intermediary calculations
that can be reused. For instance, accessing the ``std_dev``
attribute after the ``variance`` attribute will be
significantly faster for medium-to-large datasets.
If you modify the object by adding additional data points,
call this function to have the cached statistics recomputed.
N)r3 r r0 r hasattrdelattr)r attr_names r clear_cacheStats.clear_cache sE ..I :HHI4++ D $ /
r c , [ U R 5 $ )zThe number of items in this Stats object. Returns the same as
:func:`len` on a Stats object, but provided for pandas terminology
parallelism.
>>> Stats(range(20)).count
20
r; r= s r _calc_countStats._calc_count s 499~ r countc Z [ U R S5 [ U R 5 - $ )z
The arithmetic mean, or "average". Sum of the values divided by
the number of values.
>>> mean(range(20))
9.5
>>> mean(list(range(19)) + [949]) # 949 is an arbitrary outlier
56.0
)sumr r< r= s r
_calc_meanStats._calc_mean s" 499c"S^33r meanc l U R ( a U R S $ [ U R 5 $ )zD
The maximum value present in the data.
>>> Stats([2, 1, 3]).max
3
)r. r maxr= s r _calc_maxStats._calc_max s' ??99R= 499~ r r[ c l U R ( a U R S $ [ U R 5 $ )zD
The minimum value present in the data.
>>> Stats([2, 1, 3]).min
1
r )r. r minr= s r _calc_minStats._calc_min s' ??99Q< 499~ r r_ c B U R U R 5 S5 $ )a5
The median is either the middle value or the average of the two
middle values of a sample. Compared to the mean, it's generally
more resilient to the presence of outliers in the sample.
>>> median([2, 1, 3])
2
>>> median(range(97))
48
>>> median(list(range(96)) + [1066]) # 1066 is an arbitrary outlier
48
?)
_get_quantilerG r= s r _calc_medianStats._calc_median s !!$"7"7"93??r medianc H U R S5 U R S5 -
$ )a Inter-quartile range (IQR) is the difference between the 75th
percentile and 25th percentile. IQR is a robust measure of
dispersion, like standard deviation, but safer to compare
between datasets, as it is less influenced by outliers.
>>> iqr([1, 2, 3, 4, 5])
2
>>> iqr(range(1001))
500
? ?) get_quantiler= s r _calc_iqrStats._calc_iqr% s% &):):4)@@@r iqrc t ^ ^ T R 5 mU U4S jnU" S5 SU" S5 - - U" S5 - S- $ )a The trimean is a robust measure of central tendency, like the
median, that takes the weighted average of the median and the
upper and lower quartiles.
>>> trimean([2, 1, 3])
2.0
>>> trimean(range(97))
48.0
>>> trimean(list(range(96)) + [1066]) # 1066 is an arbitrary outlier
48.0
c ( > TR TU 5 $ r )rd )qr sorted_datas r %Stats._calc_trimean..A s t))+q9r rj rc ri g @)rG )r gqrr s ` @r
_calc_trimeanStats._calc_trimean3 s= ++-
94A3K(2d83s::r trimeanc 6 [ U R S5 5 $ )zyVariance is the average of the squares of the difference between
each value and the mean.
>>> variance(range(97))
784.0
ru )rX _get_pow_diffsr= s r _calc_varianceStats._calc_varianceE s D''*++r variancec U R S- $ )zNStandard deviation. Square root of the variance.
>>> std_dev(range(97))
28.0
rc )r~ r= s r
_calc_std_devStats._calc_std_devQ s }}##r std_devc [ U R 5 n[ [ U5 5 n[ U Vs/ s H n[ X#-
5 PM sn5 $ s snf )zMedian Absolute Deviation is a robust measure of statistical
dispersion: http://en.wikipedia.org/wiki/Median_absolute_deviation
>>> median_abs_dev(range(97))
24.0
)rE r floatrg abs)r sorted_valsxvs r _calc_median_abs_devStats._calc_median_abs_dev[ sD TYY' &% &;7;as15z;7887s Amedian_abs_devc p [ U R 5 nU( a U R U- $ U R $ )zStandard deviation divided by the absolute value of the average.
http://en.wikipedia.org/wiki/Relative_standard_deviation
>>> print('%1.3f' % rel_std_dev(range(97)))
0.583
)r rX r r )r abs_means r _calc_rel_std_devStats._calc_rel_std_devj s- tyy> <<(* *<< r rel_std_devc U R U R p![ U5 S: a> US: a8 [ U R S5 5 [ [ U5 S-
US- - 5 - $ U R $ )a Indicates the asymmetry of a curve. Positive values mean the bulk
of the values are on the left side of the average and vice versa.
http://en.wikipedia.org/wiki/Skewness
See the module docstring for more about statistical moments.
>>> skewness(range(97)) # symmetrical around 48.0
0.0
>>> left_skewed = skewness(list(range(97)) + list(range(10)))
>>> right_skewed = skewness(list(range(97)) + list(range(87, 97)))
>>> round(left_skewed, 3), round(right_skewed, 3)
(0.114, -0.114)
r )r r r< rU r{ r r r r s_devs r _calc_skewnessStats._calc_skewnessz sf ii e t9q=UQY++A./3t9q=UaZ89:
; << r skewnessc U R U R p![ U5 S: a> US: a8 [ U R S5 5 [ [ U5 S-
US- - 5 - $ g)a Indicates how much data is in the tails of the distribution. The
result is always positive, with the normal "bell-curve"
distribution having a kurtosis of 3.
http://en.wikipedia.org/wiki/Kurtosis
See the module docstring for more about statistical moments.
>>> kurtosis(range(9))
1.99125
With a kurtosis of 1.99125, [0, 1, 2, 3, 4, 5, 6, 7, 8] is more
centrally distributed than the normal curve.
r r rT )r r r< rU r{ r r s r _calc_kurtosisStats._calc_kurtosis s_ ii e t9q=UQY++A./3t9q=UaZ89:
; r kurtosisc Z U R nU R nU R nUS- nUS- nSU- SU- -
nX%S- - nSU- SU- -
S-
n[ Xq5 S:X a [ XQ5 S:X a gUS: a gUS: a gO%[ X5 S:X a gUS- SU- U- - n U S: a g [ S
5 e) Ng @ ?r r ru r r z
missed a spot)r4 r r round RuntimeError)
r precisionr r beta1beta2c0c1c2ks
r _calc_pearson_typeStats._calc_pearson_type s ++ ====C3 %iAI
&
#%iAI
&
* 1 $U&!+19 QY
2
!Q
&a1r6B;'A1u?++r pearson_typec U [ U 5 p2US- US-
- n[ [ U5 5 [ [ U5 5 peXV:X a X% $ X% Xd-
- X& XE-
- - $ )Nr r )r< intr r )rr rq r nidxidx_fidx_cs r rd Stats._get_quantile sa s; /a#gQ 5:DIu >; u{+ s{0KLLr c [ U5 nSUs=:: a S:: d O [ SU- 5 eU R ( d U R $ U R U R 5 U5 $ )a Get a quantile from the dataset. Quantiles are floating point
values between ``0.0`` and ``1.0``, with ``0.0`` representing
the minimum value in the dataset and ``1.0`` representing the
maximum. ``0.5`` represents the median:
>>> Stats(range(100)).get_quantile(0.5)
49.5
rT r z&expected q between 0.0 and 1.0, not %r)r
ValueErrorr r rd rG )r rq s r rk Stats.get_quantile sV
!Ha3 E IJ J<< !!$"7"7"91==r c U R nU R S:X a& X:X a gX: a [ S5 $ X: a [ S5 $ [ U5 U-
U R - $ )zGet the z-score for *value* in the group. If the standard deviation
is 0, 0 inf or -inf will be returned to indicate whether the value is
equal to, greater than or below the group's mean.
r infz-inf)rX r r )r valuerX s r
get_zscoreStats.get_zscore sW
yy <<1 }| U|#| V}$e t#t||33r c [ U5 nSUs=:: a S: d O [ SU- 5 e[ U R 5 n[ X2- 5 nUS:X a gU R 5 XD* U l U R
5 g)aW A utility function used to cut a proportion of values off each end
of a list of values. This has the effect of limiting the
effect of outliers.
Args:
amount (float): A value between 0.0 and 0.5 to trim off of
each side of the data.
.. note:
This operation modifies the data in-place. It does not
make or return a copy.
rT rc z+expected amount between 0.0 and 0.5, not %rN)r r r< r r rG rM )r amounttrimsize size_diffs r
trim_relativeStats.trim_relative sy V}d S J # $ %
%499~ $ ))+IjA r c h U R nU R Vs/ s H
o3U-
U- PM sn$ s snf )z>
A utility function used for calculating statistical moments.
)rX r )r powermr s r r{ Stats._get_pow_diffs
s0
II*.))4)QQ5 )444s /Nc U R ( d S/$ U R n[ U5 [ U5 [ U5 penUS: a9 U( d UnXe-
[ U5 - n[ U5 Vs/ s H oXx- - PM n nOUc U R
S5 U R
S5 pSX-
- US- - n[ S[ [ Xe-
U- 5 5 5 n [ U S- 5 Vs/ s H oXx- - PM n nU V
s/ s H oU: d M
U
PM n n
O/Xe-
[ U5 - n[ U5 Vs/ s H oXx- - PM n nU( a U R [ U5 5 U $ s snf s snf s sn
f s snf )NrT r rj ri ru gUUUUUU?r )
r r< r_ r[ r rangerk r r append)r rR with_maxr len_datamin_datamax_datadxibinsq25q75 bin_countbs r _get_bin_boundsStats._get_bin_bounds s[ yy5Lyy'*4y#d)SYH a< %u 5B16u > A' D>D
]((.0A0A$0Gci H$9:BAs4)<(B#C DEI16y1}1EF1EA'1EDF #4t!8|AtD4D%u 5B16u > A' D> KKh ( ? G4 ?s -E"$E': E,E,-E1c [ UR SS5 5 nU( a [ SUR 5 - 5 eU( d U R 5 nO [ U5 nU R U5 nSU- nU Vs/ s H n[ Xv- 5 U- PM nn[ [ U5 5 nU R Vs/ s H n[ R " X5 S-
PM n n0 n
U H n X== S-
ss' M [ U5 V Vs/ s H u pXzR! U S5 4PM n
n nU
$ ! [ af U Vs/ s H n[ U5 PM Os snf nnO ! [ a [ SU- 5 ef = fU R US : a U R /U- n GN%f = fs snf s snf ! [ a SX' M f = fs snn f )a Produces a list of ``(bin, count)`` pairs comprising a histogram of
the Stats object's data, using fixed-width bins. See
:meth:`Stats.format_histogram` for more details.
Args:
bins (int): maximum number of bins, or list of
floating-point bin boundaries. Defaults to the output of
Freedman's algorithm.
bin_digits (int): Number of digits used to round down the
bin boundaries. Defaults to 1.
The output of this method can be stored and/or modified, and
then passed to :func:`statsutils.format_histogram_counts` to
achieve the same text formatting as the
:meth:`~Stats.format_histogram` method. This can be useful for
snapshotting over time.
bin_digitsr z unexpected keyword arguments: %rzGbins expected integer bin count or list of float bin boundaries, not %rr g $@)r pop TypeErrorkeysr r Exceptionr r_ r rE setr bisectKeyError enumerateget)r r kwr r r round_factorr didxs count_mapr r
bin_countss r get_histogram_countsStats.get_histogram_counts- s $ a01
> JK K'')D
7 I ++I6 z) @DE1a&',6Ec$i 48II>Iq
d&*I> C
#!# >> data = list(range(20)) + list(range(5, 15)) + [10]
>>> print(Stats(data).format_histogram(width=30))
0.0: 5 #########
4.4: 8 ###############
8.9: 11 ####################
13.3: 5 #########
17.8: 2 ####
In this histogram, five values are between 0.0 and 4.4, eight
are between 4.4 and 8.9, and two values lie between 17.8 and
the max.
You can specify the number of bins, or provide a list of
bin boundaries themselves. If no bins are provided, as in the
example above, `Freedman's algorithm`_ for bin selection is
used.
Args:
bins (int): Maximum number of bins for the
histogram. Also accepts a list of floating-point
bin boundaries. If the minimum boundary is still
greater than the minimum value in the data, that
boundary will be implicitly added. Defaults to the bin
boundaries returned by `Freedman's algorithm`_.
bin_digits (int): Number of digits to round each bin
to. Note that bins are always rounded down to avoid
clipping any data. Defaults to 1.
width (int): integer number of columns in the longest line
in the histogram. Defaults to console width on Python
3.3+, or 80 if that is not available.
format_bin (callable): Called on each bin to create a
label for the final output. Use this function to add
units, such as "ms" for milliseconds.
Should you want something more programmatically reusable, see
the :meth:`~Stats.get_histogram_counts` method, the output of
is used by format_histogram. The :meth:`~Stats.describe`
method is another useful summarization method, albeit less
visual.
.. _Freedman's algorithm: https://en.wikipedia.org/wiki/Freedman%E2%80%93Diaconis_rule
widthN
format_binr )r r r( )r r format_histogram_counts)r r r r r r s r format_histogramStats.format_histogramd sR \ w%VVL$/
..?D?B?
&z-22<> >r c t Uc SnOUS; a [ SU- 5 eU=( d / SQn/ nU H0 nU R U5 nUR [ U5 U45 M2 SU R 4SU R
4SU R 4SU R 4S U R 4/nUR U5 UR S
U R 45 US:X a
[ U5 nU$ US :X a UnU$ US :X a> S
R U VV s/ s H u pUS- R S5 < U < 3PM! sn n5 nW$ s sn nf )a Provides standard summary statistics for the data in the Stats
object, in one of several convenient formats.
Args:
quantiles (list): A list of numeric values to use as
quantiles in the resulting summary. All values must be
0.0-1.0, with 0.5 representing the median. Defaults to
``[0.25, 0.5, 0.75]``, representing the standard
quartiles.
format (str): Controls the return type of the function,
with one of three valid values: ``"dict"`` gives back
a :class:`dict` with the appropriate keys and
values. ``"list"`` is a list of key-value pairs in an
order suitable to pass to an OrderedDict or HTML
table. ``"text"`` converts the values to text suitable
for printing, as seen below.
Here is the information returned by a default ``describe``, as
presented in the ``"text"`` format:
>>> stats = Stats(range(1, 8))
>>> print(stats.describe(format='text'))
count: 7
mean: 4.0
std_dev: 2.0
mad: 2.0
min: 1
0.25: 2.5
0.5: 4
0.75: 5.5
max: 7
For more advanced descriptive statistics, check out my blog
post on the topic `Statistics for Software
`_.
dict)r r/ textzIinvalid format for describe, expected one of "dict"/"list"/"text", not %r)rj rc ri rR rX r madr_ r[ r/ r
:
)r rk r strrR rX r r r_ extendr[ r joinljust)
r quantilesformatq_itemsrq q_valitemsretlabelvals
r describeStats.describe s\ L >F
3
3 M % & '
' 2!2 A%%a(E NNCFE? + 4::&$))$T\\*"" $ W
eTXX&' V u+C
v
C
v
))/4 6/4 ). ':':2'> D/4 6 7C
6s &D4
)r. r4 r3 r- r r )rT TF)g333333?)NFr NN)3r# r$ r% r& r r r> rB rG rM rP r rR rV rX r\ r[ r` r_ re rg rl rn rw ry r| r~ r r r r r r r r r r r r r staticmethodrd rk r r r{ r r r r r' r( r r r* r* st "
$
"
7K 0E
4 &* -D
*C
*C
@ Hl
3F A
*C; Y
6G , j.9H$ Y
6G 9 $$46JKN
C
! 0ABK , j.9H, j.9H,8 ".2DELM M>
4 4585n3>jAr r* c 2 [ U 5 R XS9$ )a A convenience function to get standard summary statistics useful
for describing most data. See :meth:`Stats.describe` for more
details.
>>> print(describe(range(7), format='text'))
count: 7
mean: 3.0
std_dev: 2.0
mad: 2.0
min: 0
0.25: 1.5
0.5: 3
0.75: 4.5
max: 6
See :meth:`Stats.format_histogram` for another very useful
summarization that uses textual visualization.
)r r )r* r )r r r s r r r s & ; ) CCr c ^ SU 4S jjnU$ )Nc , > [ [ XSS9T5 $ )NF)r r5 )r r* )r r rL s r stats_helper$_get_conv_func..stats_helper s uTUC " "r )rT r( )rL r s ` r _get_conv_funcr
s " r )r[ r_ rR )r _calc_c / nU( d S nU( d SSK nUR 5 S nU VVs/ s H u pVUPM nnn[ U VVs/ s H u phUPM snn5 n [ [ U 5 5 n
U Vs/ s H nSU" U5 - PM n n[ U V s/ s H n [ U 5 PM sn 5 n
SU
- < SU < S3n[ U[ U5 -
S 5 n[
U5 U - nS
n[ X5 HR u nu nn[ [ UU- 5 5 nS U- =( d S nUR UU
UU
US
9nUR U5 MT SR U5 $ ! [ a Sn GN@f = fs snnf s snnf s snf s sn f )a The formatting logic behind :meth:`Stats.format_histogram`, which
takes the output of :meth:`Stats.get_histogram_counts`, and passes
them to this function.
Args:
bin_counts (list): A list of bin values to counts.
width (int): Number of character columns in the text output,
defaults to 80 or console width in Python 3.3+.
format_bin (callable): Used to convert bin values into string
labels.
c U $ r r( )r s r rs )format_histogram_counts.. s qr r NP z%sr z: z #r z2{label:>{label_cols}}: {count:>{count_cols}} {bar}#|)r
label_colsrR
count_colsbarr )
shutilget_terminal_sizer r[ r< r r zipr r r r r )r r r linesr r r
r rR count_maxr labelslr tmp_linebar_colsline_ktmplr bin_valbar_lenr lines r r r
s
E
,,.q1E % %*$!A*D %:6:xqU:67IS^$J,0
1DqdZ]"DF
1f-fc!ff-.J : -y9H53x=(!,H
8_y
(F ?D#&v#: eEFN+,W}${{&0!&&0 " $
T $; 99U 1 E &6 2-s( E E0 E6
:E<F E-,E-r )r
__future__r r mathr r objectr r* r r
r/ __dict__r rL attrr2 r
globalsrK r r( r r r, s B_B &
4V 4,|F |~D, ENN 0 0 23OIt$'' / / i(yy(( # ) x)+, 4
+ r