Ñò
qì©Uc@@s²dd
kl
Z

yddklZ
Wn‡ej
o{



ddklZ
ddklZ
ddk	l
Z
lZ
def
d„ƒYZe
djo
dd	kZeiƒGHn

n
Xd	S(
i(
tabsolute_import(
tCounter(
t
itemgetter(
tnlargest(trepeattifilterR
cB@sªeZ
dZdd
„
Zd„Zdd„
Zd„Zedd„
ƒ
Z	dd„
Z
dd„
Zd„Zd	„Z
d
„Zd„Zd„Zd
„Zd„Zd„ZRS(s'Dict subclass for counting hashable items.  Sometimes called a bag
        or multiset.  Elements are stored as dictionary keys and their counts
        are stored as dictionary values.

        >>> c = Counter('abcdeabcdabcaba')  # count elements from a string

        >>> c.most_common(3)                # three most common elements
        [('a', 5), ('b', 4), ('c', 3)]
        >>> sorted(c)                       # list all unique elements
        ['a', 'b', 'c', 'd', 'e']
        >>> ''.join(sorted(c.elements()))   # list elements with repetitions
        'aaaaabbbbcccdde'
        >>> sum(c.values())                 # total of all counts
        15

        >>> c['a']                          # count of letter 'a'
        5
        >>> for elem in 'shazam':           # update counts from an iterable
        ...     c[elem] += 1                # by adding 1 to each element's count
        >>> c['a']                          # now there are seven 'a'
        7
        >>> del c['b']                      # remove all 'b'
        >>> c['b']                          # now there are zero 'b'
        0

        >>> d = Counter('simsalabim')       # make another counter
        >>> c.update(d)                     # add in the second counter
        >>> c['a']                          # now there are nine 'a'
        9

        >>> c.clear()                       # empty the counter
        >>> c
        Counter()

        Note:  If a count is set to zero or reduced to zero, it will remain
        in the counter until the entry is deleted or the counter is cleared:

        >>> c = Counter('aaabbc')
        >>> c['b'] -= 2                     # reduce the count of 'b' by two
        >>> c.most_common()                 # 'b' is still in, but its count is zero
        [('a', 3), ('c', 1), ('b', 0)]

        cK@s|i|
|

d
S(s%Create a new, empty Counter object.  And if given, count elements
            from an input iterable.  Or, initialize the count from another mapping
            of elements to their counts.

            >>> c = Counter()                           # a new, empty counter
            >>> c = Counter('gallahad')                 # a new counter from an iterable
            >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping
            >>> c = Counter(a=4, b=2)                   # a new counter from keyword args

            N(
tupdate(tselftiterabletkwds((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyt__init__Vsc
C@sd
S(s1The count of elements not in the Counter is zero.i((Rtkey((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyt__missing__cscC@sO|
djo#
t
|iƒd
tdƒ
dtƒ
S
t|
|iƒd
tdƒ
ƒ
S(s
List the n most common elements and their counts from the most
            common to the least.  If n is None, then list all element counts.

            >>> Counter('abcdeabcdabcaba').most_common(3)
            [('a', 5), ('b', 4), ('c', 3)]

            Ri
treverseN(tNonetsortedt	iteritemsRtTrueR(Rt
n((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pytmost_commonhs	

#
c
c@s@x9|iƒD]+\}
}xt
d
|ƒD]}|
V
q)Wq
Wd
S(sµIterator over elements repeating each as many times as its count.

            >>> c = Counter('ABCABC')
            >>> sorted(c.elements())
            ['A', 'A', 'B', 'B', 'C', 'C']

            # Knuth's example for prime factors of 1836:  2**2 * 3**3 * 17**1
            >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
            >>> product = 1
            >>> for factor in prime_factors.elements():     # loop over factors
            ...     product *= factor                       # and multiply them
            >>> product
            1836

            Note, if an element's count has been set to zero or is a negative
            number, elements() will ignore it.

            N(RRR(Rtelemtcountt
_((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pytelementsus



cC@std
ƒ
‚
dS(Ns@Counter.fromkeys() is undefined.  Use Counter(iterable) instead.(
tNotImplementedError(tclsRt
v((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pytfromkeyss
cK@sÊ|
dj	o¡
t
|
d
ƒo\
|oA
|i}xE|
iƒD]#\}}||dƒ|||<q:Wqª
ti||
ƒ
q®
|i}x)|
D]}||dƒd||<q‰Wn

|o
|i|ƒ

n

dS(sé
Like dict.update() but add counts instead of replacing them.

            Source can be an iterable, a dictionary, or another Counter instance.

            >>> c = Counter('which')
            >>> c.update('witch')           # add elements from another iterable
            >>> d = Counter('watch')
            >>> c.update(d)                 # add elements from another counter
            >>> c['h']                      # four 'h' in which, witch, and watch
            4

            Rii
N(RthasattrtgetRtdictR(RRR	tself_getRR((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyR–s



	


	



cK@sft|
d
ƒo1
xO|
i
ƒD]\}}||c|8<qWn"
x|
D]}||cd8<qHWdS(sãLike dict.update() but subtracts counts instead of replacing them.
            Counts can be reduced below zero.  Both the inputs and outputs are
            allowed to contain zero and negative counts.

            Source can be an iterable, a dictionary, or another Counter instance.

            >>> c = Counter('which')
            >>> c.subtract('witch')             # subtract elements from another iterable
            >>> c.subtract(Counter('watch'))    # subtract elements from another counter
            >>> c['h']                          # 2 in which, minus 1 in witch, minus 1 in watch
            0
            >>> c['w']                          # 1 in which, minus 1 in witch, minus 1 in watch
            -1

            Ri
N(RR(RRR	RR((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pytsubtract¹s



c

C@s
|i|ƒ
S(
sReturn a shallow copy.(
t	__class__(
R((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pytcopyÐsc

C@s|it
|ƒ
f
fS(
N(R!R(
R((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyt
__reduce__Ôs
cC@s%|
|jo
ti
||
ƒ
n

d
S(sGLike dict.__delitem__() but does not raise KeyError for missing values.N(Rt__delitem__(RR((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyR$×s

c
C@sK|p
d
|ii
S
ditdi|iƒƒƒ
}
d|ii
|
fS(Ns%s()s, s%r: %rs%s({%s})(R!t__name__tjointmapt__mod__R(Rtitems((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyt__repr__Üs


!
cC@spt|
t
ƒp
tS
t
ƒ}xKt|ƒ
t|
ƒ
BD]3}|||
|}|d
jo
|||<q5
q5W|S(s‹Add counts from two counters.

            >>> Counter('abbb') + Counter('bcc')
            Counter({'b': 4, 'c': 2, 'a': 1})

            i(t
isinstanceR
tNotImplementedtset(RtothertresultRtnewcount((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyt__add__ës

	





cC@spt|
t
ƒp
tS
t
ƒ}xKt|ƒ
t|
ƒ
BD]3}|||
|}|d
jo
|||<q5
q5W|S(s¤ Subtract count, but keep only results with positive counts.

            >>> Counter('abbbc') - Counter('bccd')
            Counter({'b': 2, 'a': 1})

            i(R+R
R,R-(RR.R/RR0((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyt__sub__ûs

	





cC@s{t|
t
ƒp
tS
t}t
ƒ}xPt|ƒ
t|
ƒ
BD]8}||||
|ƒ}|d
jo
|||<q;
q;W|S(s¬Union is the maximum of value in either of the input counters.

            >>> Counter('abbb') | Counter('bcc')
            Counter({'b': 3, 'c': 2, 'a': 1})

            i(R+R
R,tmaxR-(RR.t_maxR/RR0((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyt__or__
s


	





cC@s¡t|
t
ƒp
tS
t}t
ƒ}t|ƒ
t|
ƒ
jo
|
|}}
n

xLt|i|
ƒD]8}||||
|ƒ}|d
jo
|||<qa
qaW|S(s“ Intersection is the minimum of corresponding counts.

            >>> Counter('abbb') & Counter('bcc')
            Counter({'b': 1})

            i(R+R
R,tmintlenRt__contains__(RR.t_minR/RR0((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyt__and__
s


	







N(R%t
__module__t__doc__RR
RRRtclassmethodRRR R"R#R$R*R1R2R5R:(((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyR
#s"+
	
	
#							t__main__N(t
__future__RtcollectionsR
tImportErrortoperatorRtheapqRt	itertoolsRRRR%tdoctestttestmod(((sh/home/zelgadis/synfig-buildroot/linux64/build/lib/gobject-introspection/giscanner/collections/counter.pyt<module>s



ÿ