o

���aJ�@s�dd
lm
Z
mZmZmZ
ddlmZ
ddlmZ
dd�Z	Gdd�de
�Ze
�e�

e�e�

e�e�

e�e�

dd	�Z
d
d�Zee��
ZdS)
�)�	Container�Iterable�Sized�Hashable)
�reduce)
�pmapcCs|�|
|�
|
d
�d�S)Nr
�
)�set�get)�counters�element�r
�2/usr/lib/python3/dist-packages/pyrsistent/_pbag.py�_add_to_counterss
rc@s�eZ
dZd
ZdZdd�Zdd�Zdd�Zd	d
�Zdd�Z	d
d�Z
dd�Zdd�Zdd�Z
dd�Zdd�ZeZeZeZdd�Zdd�Zdd�Zdd �Zd!d"�Zd#S)$�PBaga�

    A persistent bag/multiset type.

    Requires elements to be hashable, and allows duplicates, but has no
    ordering. Bags are hashable.

    Do not instantiate directly, instead use the factory functions :py:func:`b`
    or :py:func:`pbag` to create an instance.

    Some examples:

    >>> s = pbag([1, 2, 3, 1])
    >>> s2 = s.add(4)
    >>> s3 = s2.remove(1)
    >>> s
    pbag([1, 1, 2, 3])
    >>> s2
    pbag([1, 1, 2, 3, 4])
    >>> s3
    pbag([1, 2, 3, 4])
    )�_counts�__weakref__cCs
|
|_dS)
N�
r)�self�countsr
r
r�__init__#s

z
PBag.__init__cCstt
|j|
��
S)
z�
        Add an element to the bag.

        >>> s = pbag([1])
        >>> s2 = s.add(1)
        >>> s3 = s.add(2)
        >>> s2
        pbag([1, 1])
        >>> s3
        pbag([1, 2])
        )rrr�rrr
r
r�add&szPBag.addcCs|
rtt
t|
|j��
S|S)
z�
        Update bag with all elements in iterable.

        >>> s = pbag([1])
        >>> s.update([1, 2])
        pbag([1, 1, 2])
        )rrrr)r�iterabler
r
r�update4s
zPBag.updatecCsT|
|jv
r	t
|
�
�
|j|
d
kr|j�|
�
}t|�
S|j�|
|j|
d
�}t|�
S)z�
        Remove an element from the bag.

        >>> s = pbag([1, 1, 2])
        >>> s2 = s.remove(1)
        >>> s3 = s.remove(2)
        >>> s2
        pbag([1, 2])
        >>> s3
        pbag([1, 1])
        r)r�KeyError�remover	r)rr�newcr
r
rrAs



�
zPBag.removecCs|j�
|
d
�S)z�
        Return the number of times an element appears.


        >>> pbag([]).count('non-existent')
        0
        >>> pbag([1, 1, 2]).count(1)
        2
        r
)rr
rr
r
r�countUs
z
PBag.countc

Cst|j
���
S)
ze
        Return the length including duplicates.

        >>> len(pbag([1, 1, 2]))
        3
        )�sumr�
itervalues�
rr
r
r�__len__aszPBag.__len__c
cs.�|j�
�D]\}
}t|�
D]}|
V
qqd
S)z�
        Return an iterator of all elements, including duplicates.

        >>> list(pbag([1, 1, 2]))
        [1, 1, 2]
        >>> list(pbag([1, 2]))
        [1, 2]
        N)r�	iteritems�range)r�eltr�
ir
r
r�__iter__js�	

��z
PBag.__iter__cCs
|
|jvS)
z�
        Check if an element is in the bag.

        >>> 1 in pbag([1, 1, 2])
        True
        >>> 0 in pbag([1, 2])
        False
        r)rr%r
r
r�__contains__ws
	zPBag.__contains__c

Csd
�t
|�
�
S)Nz	pbag({0}))�format�listr!r
r
r�__repr__�s
z
PBag.__repr__cCs t|
�
t
u
r
td
�
�
|j|
jkS)z�
        Check if two bags are equivalent, honoring the number of duplicates,
        and ignoring insertion order.

        >>> pbag([1, 1, 2]) == pbag([1, 2])
        False
        >>> pbag([2, 1, 0]) == pbag([0, 1, 2])
        True
        z Can only compare PBag with PBags)�typer�	TypeErrorr�r�otherr
r
r�__eq__�s


zPBag.__eq__cCstd
�
�
)NzPBags are not orderable)
r-r.r
r
r�__lt__�s
zPBag.__lt__cCsJt|
t
�stS|j��}|
j��D]
\}}|�|�
|||<qt
|���
S)
z�
        Combine elements from two PBags.

        >>> pbag([1, 2, 2]) + pbag([2, 3, 3])
        pbag([1, 2, 2, 2, 3, 3])
        )�
isinstancer�NotImplementedr�evolverr#r�
persistent)rr/�result�elem�other_countr
r
r�__add__�s






zPBag.__add__cCsjt|
t
�stS|j��}|
j��D]\}}|�|�
|}|d
kr%|||<q||vr.|�|�

qt
|���
S)z�
        Remove elements from one PBag that are present in another.

        >>> pbag([1, 2, 2, 2, 3]) - pbag([2, 3, 3, 4])
        pbag([1, 2, 2])
        r
)	r2rr3rr4r#rrr5)rr/r6r7r8�newcountr
r
r�__sub__�s











�
zPBag.__sub__cCsTt|
t
�stS|j��}|
j��D]\}}|�|�
}t||�}|||<qt
|���
S)
z�
        Union: Keep elements that are present in either of two PBags.

        >>> pbag([1, 2, 2, 2]) | pbag([2, 3, 3])
        pbag([1, 2, 2, 2, 3, 3])
        )	r2rr3rr4r#r�maxr5)rr/r6r7r8rr:r
r
r�__or__�s











zPBag.__or__cCsXt|
t
�stSt���}|j��D]\}}t||
�|�
�}|d
kr%|||<qt
|�	��
S)z�
        Intersection: Only keep elements that are present in both PBags.

        >>> pbag([1, 2, 2, 2]) & pbag([2, 3, 3])
        pbag([2])
        r
)
r2rr3rr4rr#�minrr5)rr/r6r7rr:r
r
r�__and__�s







�
zPBag.__and__c

Cs
t|j
�
S)
z�
        Hash based on value of elements.

        >>> m = pmap({pbag([1, 2]): "it's here!"})
        >>> m[pbag([2, 1])]
        "it's here!"
        >>> pbag([1, 1, 2]) in m
        False
        )�hashrr!r
r
r�__hash__�s

z
PBag.__hash__N)�__name__�
__module__�__qualname__�__doc__�	__slots__rrrrrr"r'r(r+r0r1�__le__�__gt__�__ge__r9r;r=r?rAr
r
r
rr
s,

	


rc
Gst|�
S)
z�
    Construct a persistent bag.

    Takes an arbitrary number of arguments to insert into the new persistent
    bag.

    >>> b(1, 2, 3, 2)
    pbag([1, 2, 2, 3])
    )
�pbag�
�elementsr
r
r�
b�s
rMc

Cs|stSt
tt|t���
S)
z�
    Convert an iterable to a persistent bag.

    Takes an iterable with elements to insert.

    >>> pbag([1, 2, 3, 2])
    pbag([1, 2, 2, 3])
    )�_EMPTY_PBAGrrrrrKr
r
rrJ�s	

rJN)�collections.abcrrrr�	functoolsr�pyrsistent._pmaprr�objectr�registerrMrJrNr
r
r
r�<module>
s


`