관리-도구
편집 파일: _pbag.cpython-311.pyc
� ���k��K�/b��������������������� ����d�dl�mZmZmZmZ�d�dlmZ�d�dlmZ�d��Z �G�d��de ������������Z�ej��������e��������������ej��������e��������������ej��������e��������������ej��������e�������������d��Z d��Z�e�e��������������������������Zd S�) �����)� Container�Iterable�Sized�Hashable)�reduce)�pmapc������������������\�����|�����������������������||����������������������|d������������dz���������������S�)Nr�������)�set�get)�counters�elements��� �p/builddir/build/BUILD/imunify360-venv-2.5.2/opt/imunify360/venv/lib/python3.11/site-packages/pyrsistent/_pbag.py�_add_to_countersr������s)�������<�<�����g�q�!9�!9�A�!=�>�>�>�����c�������������������������e�Zd�ZdZdZd��Zd��Zd��Zd��Zd��Z d��Z d ��Zd ��Zd��Z d��Zd ��ZeZeZeZd��Zd��Zd��Zd��Zd��ZdS�)�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����addzPBag.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����updatezPBag.update4���s/��������� J���/��4�<�H�H�I�I�I��r���c�����������������������||�j���������vrt����������|�������������|�j���������|���������dk����r|�j������������������������������|������������}n)|�j������������������������������||�j���������|���������dz ��������������}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#���zPBag.removeA���sw��������$�,�&�&��7�#�#�#� �\�'� "�a� '� '��<�&�&�w�/�/�D�D��<�#�#�G�T�\�'�-B�Q�-F�G�G�D��D�z�z�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__zPBag.__len__a���s ��������4�<�*�*�,�,�-�-�-r���c��������������#����t���K����|�j��������������������������������������������D�]\��}}t����������|������������D�]}|V�����dS�)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�� �� �J�C���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__zPBag.__contains__w���s��������d�l�"�"r���c������������������F�����d����������������������t����������|�������������������������S�)Nz pbag({0}))�format�listr*���s��� r����__repr__z PBag.__repr__����s�������!�!�$�t�*�*�-�-�-r���c������������������l�����t����������|������������t����������urt����������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__zPBag.__eq__����s3���������;�;�d�"�"��>�?�?�?��|�u�}�,�,r���c������������������ �����t����������d�������������)NzPBags are not orderable)r:���r;���s��� r����__lt__zPBag.__lt__����s�������1�2�2�2r���c������������������"����t����������|t����������������������st����������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__zPBag.__add__����s���������%��&�&�� "�!�!���%�%�'�'��!&��!8�!8�!:�!:�� :�� :��D�+��:�:�d�+�+�k�9�F�4�L�L��F�%�%�'�'�(�(�(r���c������������������f����t����������|t����������������������st����������S�|�j�������������������������������������������}|j�������������������������������������������D�]B\��}}|����������������������|������������|z ��}|dk����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__zPBag.__sub__����s���������%��&�&�� "�!�!���%�%�'�'��!&��!8�!8�!:�!:�� $�� $��D�+��z�z�$�'�'�+�5�H��!�|�|�'��t�������� � �d�#�#�#���F�%�%�'�'�(�(�(r���c������������������@����t����������|t����������������������st����������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__zPBag.__or__����s���������%��&�&�� "�!�!���%�%�'�'��!&��!8�!8�!:�!:�� $�� $��D�+��J�J�t�$�$�E��5�+�.�.�H�#�F�4�L�L��F�%�%�'�'�(�(�(r���c������������������V����t����������|t����������������������st����������S�t�����������������������������������������������������������}|�j�������������������������������������������D�]3\��}}t����������||���������������������|������������������������}|dk����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__zPBag.__and__����s���������%��&�&�� "�!�!������!�!���<�1�1�3�3�� (�� (�K�D�%��5�%�+�+�d�"3�"3�4�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�!�!�!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�����|�st�����������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��������������'��4�6�6�:�:�;�;�;r���N)�collections.abcr���r���r���r���� functoolsr����pyrsistent._pmapr���r����objectr����registerrb���r_���rd���r]���r���r����<module>rj������s�����@��@��@��@��@��@��@��@��@��@��@��@��������������!��!��!��!��!��!�?��?��?�\"��\"��\"��\"��\"�6��\"��\"��\"�~�� ���4������������$�����������t������������$������� �� �� �<��<��<���d�4�4�6�6�l�l���r���