Ë
    n€9e�  ã                   ó0  — d dl mZmZmZmZ d dlmZ d dlmZm	Z	 d dl
mZ  e	dd¬«      Zd„ Z G d	„ d
ee   «      Z ej                  e«        ej                  e«        ej                  e«        ej                  e«       d„ Zd„ Z e e«       «      Zy)é    )Ú	ContainerÚIterableÚSizedÚHashable)Úreduce)ÚGenericÚTypeVar)ÚpmapÚT_coT)Ú	covariantc                 óL   — | j                  || j                  |d«      dz   «      S )Nr   é   )ÚsetÚget)ÚcountersÚelements     ú2/usr/lib/python3/dist-packages/pyrsistent/_pbag.pyÚ_add_to_countersr   	   s#   € Ø�<‰<˜ §¡¨g°qÓ!9¸AÑ!=Ó>Ð>ó    c                   ó€   — e Zd ZdZdZd„ Zd„ Zd„ Zd„ Zd„ Z	d„ Z
d	„ Zd
„ Zd„ Zd„ Zd„ ZeZeZeZd„ Zd„ Zd„ Zd„ Zd„ Zy)Ú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__c                 ó   — || _         y )N©r   )ÚselfÚcountss     r   Ú__init__zPBag.__init__&   s	   € Øˆ�r   c                 ó@   — t        t        | 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])
        )r   r   r   ©r   r   s     r   ÚaddzPBag.add)   s   € ô Ô$ T§\¡\°7Ó;Ó<Ð<r   c                 óR   — |r$t        t        t        || j                  «      «      S | S )z‹
        Update bag with all elements in iterable.

        >>> s = pbag([1])
        >>> s.update([1, 2])
        pbag([1, 1, 2])
        )r   r   r   r   )r   Úiterables     r   ÚupdatezPBag.update7   s%   € ñ ÜœÔ/°¸4¿<¹<ÓHÓIÐIàˆr   c                 ó  — || j                   vrt        |«      ‚| j                   |   dk(  r&| j                   j                  |«      }t	        |«      S | j                   j                  || j                   |   dz
  «      }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   )r   r   Únewcs      r   r'   zPBag.removeD   s|   € ð ˜$Ÿ,™,Ñ&Ü˜7Ó#Ð#Ø�\‰\˜'Ñ" aÒ'Ø—<‘<×&Ñ& wÓ/ˆDô �D‹zÐð —<‘<×#Ñ# G¨T¯\©\¸'Ñ-BÀQÑ-FÓGˆDÜ�D‹zÐr   c                 ó:   — | j                   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   )r   r   r    s     r   Úcountz
PBag.countX   s   € ð �|‰|×Ñ ¨Ó+Ð+r   c                 óH   — t        | j                  j                  «       «      S )ze
        Return the length including duplicates.

        >>> len(pbag([1, 1, 2]))
        3
        )Úsumr   Ú
itervalues©r   s    r   Ú__len__zPBag.__len__d   s   € ô �4—<‘<×*Ñ*Ó,Ó-Ð-r   c              #   óx   K  — | j                   j                  «       D ]  \  }}t        |«      D ]  }|–— Œ Œ y­w)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*   Úis       r   Ú__iter__zPBag.__iter__m   s@   è ø€ ð Ÿ,™,×0Ñ0Ó2ò 	‰JˆC�Ü˜5“\ò �Ø“	ññ	ùs   ‚8:c                 ó   — || j                   v S )z�
        Check if an element is in the bag.

        >>> 1 in pbag([1, 1, 2])
        True
        >>> 0 in pbag([1, 2])
        False
        r   )r   r3   s     r   Ú__contains__zPBag.__contains__z   s   € ð �d—l‘lÐ"Ð"r   c                 ó6   — dj                  t        | «      «      S )Nz	pbag({0}))ÚformatÚlistr.   s    r   Ú__repr__zPBag.__repr__…   s   € Ø×!Ñ!¤$ t£*Ó-Ð-r   c                 ól   — t        |«      t        urt        d«      ‚| j                  |j                  k(  S )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   Úothers     r   Ú__eq__zPBag.__eq__ˆ   s/   € ô �‹;œdÑ"ÜÐ>Ó?Ð?Ø�|‰|˜uŸ}™}Ñ,Ð,r   c                 ó   — t        d«      ‚)NzPBags are not orderable)r>   r?   s     r   Ú__lt__zPBag.__lt__–   s   € ÜÐ1Ó2Ð2r   c                 ó  — t        |t        «      st        S | j                  j	                  «       }|j                  j                  «       D ]  \  }}| j                  |«      |z   ||<   Œ t        |j                  «       «      S )z‚
        Combine elements from two PBags.

        >>> pbag([1, 2, 2]) + pbag([2, 3, 3])
        pbag([1, 2, 2, 2, 3, 3])
        )Ú
isinstancer   ÚNotImplementedr   Úevolverr1   r*   Ú
persistent)r   r@   ÚresultÚelemÚother_counts        r   Ú__add__zPBag.__add__Ÿ   sr   € ô ˜%¤Ô&Ü!Ð!Ø—‘×%Ñ%Ó'ˆØ!&§¡×!8Ñ!8Ó!:ò 	:ÑˆD�+ØŸ:™: dÓ+¨kÑ9ˆF�4ŠLð	:ä�F×%Ñ%Ó'Ó(Ð(r   c                 óB  — t        |t        «      st        S | j                  j	                  «       }|j                  j                  «       D ]:  \  }}| j                  |«      |z
  }|dkD  r|||<   Œ%|| v sŒ*|j                  |«       Œ< t        |j                  «       «      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   )	rE   r   rF   r   rG   r1   r*   r'   rH   )r   r@   rI   rJ   rK   Únewcounts         r   Ú__sub__zPBag.__sub__­   s“   € ô ˜%¤Ô&Ü!Ð!Ø—‘×%Ñ%Ó'ˆØ!&§¡×!8Ñ!8Ó!:ò 	$ÑˆD�+Ø—z‘z $Ó'¨+Ñ5ˆHØ˜!Š|Ø'��t’Ø˜’Ø—‘˜dÕ#ð	$ô �F×%Ñ%Ó'Ó(Ð(r   c                 ó  — t        |t        «      st        S | j                  j	                  «       }|j                  j                  «       D ]'  \  }}| j                  |«      }t        ||«      }|||<   Œ) t        |j                  «       «      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])
        )	rE   r   rF   r   rG   r1   r*   ÚmaxrH   )r   r@   rI   rJ   rK   r*   rN   s          r   Ú__or__zPBag.__or__¿   s€   € ô ˜%¤Ô&Ü!Ð!Ø—‘×%Ñ%Ó'ˆØ!&§¡×!8Ñ!8Ó!:ò 	$ÑˆD�+Ø—J‘J˜tÓ$ˆEÜ˜5 +Ó.ˆHØ#ˆF�4ŠLð	$ô �F×%Ñ%Ó'Ó(Ð(r   c                 ó   — t        |t        «      st        S t        «       j	                  «       }| j
                  j                  «       D ]+  \  }}t        ||j                  |«      «      }|dkD  sŒ'|||<   Œ- t        |j                  «       «      S )z–
        Intersection: Only keep elements that are present in both PBags.

        >>> pbag([1, 2, 2, 2]) & pbag([2, 3, 3])
        pbag([2])
        r   )
rE   r   rF   r
   rG   r   r1   Úminr*   rH   )r   r@   rI   rJ   r*   rN   s         r   Ú__and__zPBag.__and__Ï   s}   € ô ˜%¤Ô&Ü!Ð!Ü“—‘Ó!ˆØŸ<™<×1Ñ1Ó3ò 	(‰KˆD�%Ü˜5 %§+¡+¨dÓ"3Ó4ˆHØ˜!‹|Ø'��t’ð	(ô �F×%Ñ%Ó'Ó(Ð(r   c                 ó,   — 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
        )Úhashr   r.   s    r   Ú__hash__zPBag.__hash__ß   s   € ô �D—L‘LÓ!Ð!r   N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__Ú	__slots__r   r!   r$   r'   r*   r/   r5   r7   r;   rA   rC   Ú__le__Ú__gt__Ú__ge__rL   rO   rR   rU   rX   © r   r   r   r      so   „ ñð, +€Iòò=òòò(
,ò.òò	#ò.ò-ò3ð €FØ€FØ€Fò)ò)ò$)ò )ó 
"r   r   c                  ó   — t        | «      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©Úelementss    r   Úbrf   ò   s   € ô �‹>Ðr   c                 óV   — | st         S t        t        t        | 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_PBAGr   r   r   r
   rd   s    r   rc   rc   ÿ   s$   € ñ ÜÐÜ”Ô'¨´4³6Ó:Ó;Ð;r   N)Úcollections.abcr   r   r   r   Ú	functoolsr   Útypingr   r	   Úpyrsistent._pmapr
   r   r   r   Úregisterrf   rc   rh   ra   r   r   ú<module>rn      s�   ðß @Ó @Ý ß #Ý !áˆv Ô&€ò?ô\"ˆ7�4‰=ô \"ð~ €	× Ñ �4Ô Ø €× Ñ �$Ô Ø €‡�ˆtÔ Ø €× Ñ �$Ô ò
ò<ñ ‘4“6‹l�r   