
    dJ                     
   d dl mZmZmZmZ d dlmZ d dlmZ d Z	 G d de
          Z ej        e            ej        e            ej        e            ej        e           d Zd Z e e                      Zd	S )
    )	ContainerIterableSizedHashable)reduce)pmapc                 \    |                      ||                     |d          dz             S )Nr      )setget)counterselements     T/home/feoh/.local/pipx/venvs/poetry/lib/python3.11/site-packages/pyrsistent/_pbag.py_add_to_countersr      s)    <<gq!9!9A!=>>>    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d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__c                     || _         d S )Nr   )selfcountss     r   __init__zPBag.__init__#   s    r   c                 F    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                 Z    |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.update4   s/      	J/4<HHIIIr   c                     || j         vrt          |          | j         |         dk    r| j                             |          }n)| 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.removeA   sw     $,&&7###\'"a''<&&w//DD<##GT\'-BQ-FGGDDzzr   c                 8    | 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.countU   s     |+++r   c                 N    t          | j                                                  S )ze
        Return the length including duplicates.

        >>> len(pbag([1, 1, 2]))
        3
        )sumr   
itervaluesr   s    r   __len__zPBag.__len__a   s      4<**,,---r   c              #   t   K   | j                                         D ]\  }}t          |          D ]}|V  d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&   is       r   __iter__zPBag.__iter__j   sX       ,0022 	 	JC5\\  					 	r   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   r/   s     r   __contains__zPBag.__contains__w   s     dl""r   c                 F    d                     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__   s3     ;;d"">???|u},,r   c                      t          d          )NzPBags are not orderable)r:   r;   s     r   __lt__zPBag.__lt__   s    1222r   c                 "   t          |t                    st          S | j                                        }|j                                        D ] \  }}|                     |          |z   ||<   !t          |                                          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)r   r<   resultelemother_counts        r   __add__zPBag.__add__   s     %&& 	"!!%%''!&!8!8!:!: 	: 	:D+::d++k9F4LLF%%''(((r   c                 f   t          |t                    st          S | j                                        }|j                                        D ]B\  }}|                     |          |z
  }|dk    r|||<   )|| v r|                    |           Ct          |                                          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   )	rA   r   rB   r   rC   r-   r&   r#   rD   )r   r<   rE   rF   rG   newcounts         r   __sub__zPBag.__sub__   s     %&& 	"!!%%''!&!8!8!:!: 	$ 	$D+zz$''+5H!||'td###F%%''(((r   c                 @   t          |t                    st          S | j                                        }|j                                        D ]/\  }}|                     |          }t          ||          }|||<   0t          |                                          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])
        )	rA   r   rB   r   rC   r-   r&   maxrD   )r   r<   rE   rF   rG   r&   rJ   s          r   __or__zPBag.__or__   s     %&& 	"!!%%''!&!8!8!:!: 	$ 	$D+JJt$$E5+..H#F4LLF%%''(((r   c                 V   t          |t                    st          S t                                                      }| j                                        D ]3\  }}t          ||                    |                    }|dk    r|||<   4t          |	                                          S )z
        Intersection: Only keep elements that are present in both PBags.

        >>> pbag([1, 2, 2, 2]) & pbag([2, 3, 3])
        pbag([2])
        r   )
rA   r   rB   r   rC   r   r-   minr&   rD   )r   r<   rE   rF   r&   rJ   s         r   __and__zPBag.__and__   s     %&& 	"!!!!<1133 	( 	(KD%5%++d"3"344H!||'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     DL!!!r   N)__name__
__module____qualname____doc__	__slots__r   r   r    r#   r&   r+   r1   r3   r7   r=   r?   __le____gt____ge__rH   rK   rN   rQ   rT    r   r   r   r   
   s&        , +I  = = =    (
, 
, 
,. . .  	# 	# 	#. . .- - -3 3 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   brb      s     >>r   c                 r    | 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   r`   s    r   r_   r_      s1      '466::;;;r   N)collections.abcr   r   r   r   	functoolsr   pyrsistent._pmapr   r   objectr   registerrb   r_   rd   r]   r   r   <module>rj      s   @ @ @ @ @ @ @ @ @ @ @ @       ! ! ! ! ! !? ? ?\" \" \" \" \"6 \" \" \"~ 	 4     $    t     $   
 
 
< < < d4466llr   