U
|
G=®d; ã @ s| d Z ddlZddlmZ zddlmZmZ W n$ ek
|
rP ddlmZmZ Y nX e dZ
|
dZ dd Z G dd d eeZ dS )
|
zí
|
An OrderedSet is a custom MutableSet that remembers its order, so that every
|
entry has an index that can be looked up.
|
|
Based on a recipe originally posted to ActiveState Recipes by Raymond Hettiger,
|
and released under the MIT license.
|
é N)Údeque)Ú
|
MutableSetÚSequencez3.1c C s" t | do t| t o t| t S )a
|
|
Are we being asked to look up a list of things, instead of a single thing?
|
We check for the `__iter__` attribute so that this can cover types that
|
don't have to be known by this module, such as NumPy arrays.
|
|
Strings, however, should be considered as atomic values to look up, not
|
iterables. The same goes for tuples, since they are immutable and therefore
|
valid entries.
|
|
We don't need to check for the Python 2 `unicode` type, because it doesn't
|
have an `__iter__` attribute anyway.
|
Ú__iter__)ÚhasattrÚ
|
isinstanceÚstrÚtuple)Úobj© r úUD:\z\workplace\VsCode\pyvenv\venv\Lib\site-packages\setuptools/_vendor/ordered_set.pyÚ is_iterable s
|
|
|
ÿ
|
ýr c @ sþ e Zd ZdZd;ddZdd Zdd Zd d
|
Zd d Zd d Z dd Z
|
dd Z e Z dd Z dd ZeZeZdd Zdd Zdd Zd d Zd d Zd!d" Zd#d$ Zd%d& Zd'd( Zd)d* Zd+d, Zd-d. Z d/d0 Z d1d2 Z d3d4 Z d5d6 Z d7d8 Z!d9d: Z"dS )<Ú
|
OrderedSetzØ
|
An OrderedSet is a custom MutableSet that remembers its order, so that
|
every entry has an index that can be looked up.
|
|
Example:
|
>>> OrderedSet([1, 1, 2, 3, 2])
|
OrderedSet([1, 2, 3])
|
Nc C s g | _ i | _|d k r | |O } d S ©N)ÚitemsÚmap)ÚselfÚiterabler r r Ú__init__4 s zOrderedSet.__init__c C s
|
t | jS )zÄ
|
Returns the number of unique elements in the ordered set
|
|
Example:
|
>>> len(OrderedSet([]))
|
0
|
>>> len(OrderedSet([1, 2]))
|
2
|
)Úlenr ©r r r r Ú__len__: s
|
zOrderedSet.__len__c s| t |tr|tkr ¡ S t|r4 fdd|D S t|dsHt |trl j| }t |trf |¡S |S n t d| dS )aQ
|
Get the item at a given index.
|
|
If `index` is a slice, you will get back that slice of items, as a
|
new OrderedSet.
|
|
If `index` is a list or a similar iterable, you'll get a list of
|
items corresponding to those indices. This is similar to NumPy's
|
"fancy indexing". The result is not an OrderedSet because you may ask
|
for duplicate indices, and the number of elements returned should be
|
the number of elements asked for.
|
|
Example:
|
>>> oset = OrderedSet([1, 2, 3])
|
>>> oset[1]
|
2
|
c s g | ]} j | qS r )r )Ú.0Úir r r Ú
|
<listcomp>[ s z*OrderedSet.__getitem__.<locals>.<listcomp>Ú __index__z+Don't know how to index an OrderedSet by %rN)
|
r ÚsliceÚ SLICE_ALLÚcopyr r r ÚlistÚ __class__Ú TypeError)r ÚindexÚresultr r r Ú __getitem__F s
|
|
|
zOrderedSet.__getitem__c C s
|
| | ¡S )zù
|
Return a shallow copy of this object.
|
|
Example:
|
>>> this = OrderedSet([1, 2, 3])
|
>>> other = this.copy()
|
>>> this == other
|
True
|
>>> this is other
|
False
|
)r r r r r r e s zOrderedSet.copyc C s t | dkrdS t| S d S )Nr r )r r r r r r Ú __getstate__s s zOrderedSet.__getstate__c C s" |dkr| g ¡ n
|
| |¡ d S )Nr )r )r Ústater r r Ú __setstate__ s zOrderedSet.__setstate__c C s
|
|| j kS )zÄ
|
Test if the item is in this ordered set
|
|
Example:
|
>>> 1 in OrderedSet([1, 3, 2])
|
True
|
>>> 5 in OrderedSet([1, 3, 2])
|
False
|
)r ©r Úkeyr r r Ú __contains__
s
|
zOrderedSet.__contains__c C s0 || j kr&t| j| j |< | j |¡ | j | S )aE
|
Add `key` as an item to this OrderedSet, then return its index.
|
|
If `key` is already in the OrderedSet, return the index it already
|
had.
|
|
Example:
|
>>> oset = OrderedSet()
|
>>> oset.append(3)
|
0
|
>>> print(oset)
|
OrderedSet([3])
|
)r r r Úappendr( r r r Úadd s
|
zOrderedSet.addc C sF d}z|D ]}| |¡}q
|
W n$ tk
|
r@ tdt| Y nX |S )a<
|
Update the set with the given iterable sequence, then return the index
|
of the last element inserted.
|
|
Example:
|
>>> oset = OrderedSet([1, 2, 3])
|
>>> oset.update([3, 1, 5, 1, 4])
|
4
|
>>> print(oset)
|
OrderedSet([1, 2, 3, 5, 4])
|
Nz(Argument needs to be an iterable, got %s)r, r! Ú
|
ValueErrorÚtype)r ÚsequenceZ
|
item_indexÚitemr r r Úupdate¦ s
|
ÿ
|
zOrderedSet.updatec s$ t |r fdd|D S j| S )aH
|
Get the index of a given entry, raising an IndexError if it's not
|
present.
|
|
`key` can be an iterable of entries that is not a string, in which case
|
this returns a list of indices.
|
|
Example:
|
>>> oset = OrderedSet([1, 2, 3])
|
>>> oset.index(2)
|
1
|
c s g | ]} |¡qS r )r" )r Úsubkeyr r r r Ê s z$OrderedSet.index.<locals>.<listcomp>)r r r( r r r r" ¼ s zOrderedSet.indexc C s, | j std| j d }| j d= | j|= |S )zØ
|
Remove and return the last element from the set.
|
|
Raises KeyError if the set is empty.
|
|
Example:
|
>>> oset = OrderedSet([1, 2, 3])
|
>>> oset.pop()
|
3
|
z Set is emptyéÿÿÿÿ)r ÚKeyErrorr )r Úelemr r r ÚpopÑ s
|
zOrderedSet.popc C sP || krL| j | }| j|= | j |= | j ¡ D ] \}}||kr,|d | j |< q,dS )aØ
|
Remove an element. Do not raise an exception if absent.
|
|
The MutableSet mixin uses this to implement the .remove() method, which
|
*does* raise an error when asked to remove a non-existent item.
|
|
Example:
|
>>> oset = OrderedSet([1, 2, 3])
|
>>> oset.discard(2)
|
>>> print(oset)
|
OrderedSet([1, 3])
|
>>> oset.discard(2)
|
>>> print(oset)
|
OrderedSet([1, 3])
|
é N)r r )r r) r ÚkÚvr r r Údiscardä s
|
zOrderedSet.discardc C s | j dd
= | j ¡ dS )z8
|
Remove all items from this OrderedSet.
|
N)r r Úclearr r r r r; ü s zOrderedSet.clearc C s
|
t | jS )zb
|
Example:
|
>>> list(iter(OrderedSet([1, 2, 3])))
|
[1, 2, 3]
|
)Úiterr r r r r r s zOrderedSet.__iter__c C s
|
t | jS )zf
|
Example:
|
>>> list(reversed(OrderedSet([1, 2, 3])))
|
[3, 2, 1]
|
)Úreversedr r r r r Ú __reversed__ s zOrderedSet.__reversed__c C s& | sd| j jf S d| j jt| f S )Nz%s()z%s(%r))r Ú__name__r r r r r Ú__repr__ s zOrderedSet.__repr__c C sR t |ttfr t| t|kS z t|}W n tk
|
r@ Y dS X t| |kS dS )a®
|
Returns true if the containers have the same items. If `other` is a
|
Sequence, then order is checked, otherwise it is ignored.
|
|
Example:
|
>>> oset = OrderedSet([1, 3, 2])
|
>>> oset == [1, 3, 2]
|
True
|
>>> oset == [1, 2, 3]
|
False
|
>>> oset == [2, 3]
|
False
|
>>> oset == OrderedSet([3, 2, 1])
|
False
|
FN)r r r r Úsetr! )r ÚotherZ other_as_setr r r Ú__eq__ s zOrderedSet.__eq__c G s< t | tr| jnt}ttt | g|¡}tj |¡}||S )a¶
|
Combines all unique items.
|
Each items order is defined by its first appearance.
|
|
Example:
|
>>> oset = OrderedSet.union(OrderedSet([3, 1, 4, 1, 5]), [1, 3], [2, 0])
|
>>> print(oset)
|
OrderedSet([3, 1, 4, 5, 2, 0])
|
>>> oset.union([8, 9])
|
OrderedSet([3, 1, 4, 5, 2, 0, 8, 9])
|
>>> oset | {10}
|
OrderedSet([3, 1, 4, 5, 2, 0, 10])
|
)r r r r r ÚitÚchainÚ from_iterable)r ÚsetsÚclsZ
|
containersr r r r Úunion6 s zOrderedSet.unionc C s
|
| |¡S r )Ú intersection©r rB r r r Ú__and__I s zOrderedSet.__and__c sH t | tr| jnt}|r<tjtt| fdd| D }n| }||S )a¯
|
Returns elements in common between all sets. Order is defined only
|
by the first set.
|
|
Example:
|
>>> oset = OrderedSet.intersection(OrderedSet([0, 1, 2, 3]), [1, 2, 3])
|
>>> print(oset)
|
OrderedSet([1, 2, 3])
|
>>> oset.intersection([2, 4, 5], [1, 2, 3, 4])
|
OrderedSet([2])
|
>>> oset.intersection()
|
OrderedSet([1, 2, 3])
|
c 3 s | ]}| kr|V qd S r r ©r r0 ©Úcommonr r Ú <genexpr>^ s z*OrderedSet.intersection.<locals>.<genexpr>)r r r rA rJ r ©r rG rH r r rN r rJ M s zOrderedSet.intersectionc s: | j }|r.tjtt| fdd| D }n| }||S )aÝ
|
Returns all elements that are in this set but not the others.
|
|
Example:
|
>>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]))
|
OrderedSet([1, 3])
|
>>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]), OrderedSet([3]))
|
OrderedSet([1])
|
>>> OrderedSet([1, 2, 3]) - OrderedSet([2])
|
OrderedSet([1, 3])
|
>>> OrderedSet([1, 2, 3]).difference()
|
OrderedSet([1, 2, 3])
|
c 3 s | ]}| kr|V qd S r r rM ©rB r r rP t s z(OrderedSet.difference.<locals>.<genexpr>)r rA rI r rQ r rR r Ú
|
differencec s zOrderedSet.differencec s* t | t krdS t fdd| D S )a7
|
Report whether another set contains this set.
|
|
Example:
|
>>> OrderedSet([1, 2, 3]).issubset({1, 2})
|
False
|
>>> OrderedSet([1, 2, 3]).issubset({1, 2, 3, 4})
|
True
|
>>> OrderedSet([1, 2, 3]).issubset({1, 4, 3, 5})
|
False
|
Fc 3 s | ]}| kV qd S r r rM rR r r rP s z&OrderedSet.issubset.<locals>.<genexpr>©r ÚallrK r rR r Úissubsety s zOrderedSet.issubsetc s* t t |k rdS t fdd|D S )a=
|
Report whether this set contains another set.
|
|
Example:
|
>>> OrderedSet([1, 2]).issuperset([1, 2, 3])
|
False
|
>>> OrderedSet([1, 2, 3, 4]).issuperset({1, 2, 3})
|
True
|
>>> OrderedSet([1, 4, 3, 5]).issuperset({1, 2, 3})
|
False
|
Fc 3 s | ]}| kV qd S r r rM r r r rP s z(OrderedSet.issuperset.<locals>.<genexpr>rT rK r r r Ú
|
issuperset s zOrderedSet.issupersetc C s: t | tr| jnt}|| |¡}|| | ¡}| |¡S )að
|
Return the symmetric difference of two OrderedSets as a new set.
|
That is, the new set will contain all elements that are in exactly
|
one of the sets.
|
|
Their order will be preserved, with elements from `self` preceding
|
elements from `other`.
|
|
Example:
|
>>> this = OrderedSet([1, 4, 3, 5, 7])
|
>>> other = OrderedSet([9, 7, 1, 3, 2])
|
>>> this.symmetric_difference(other)
|
OrderedSet([4, 5, 9, 2])
|
)r r r rS rI )r rB rH Zdiff1Zdiff2r r r Úsymmetric_difference s z OrderedSet.symmetric_differencec C s || _ dd t|D | _dS )zt
|
Replace the 'items' list of this OrderedSet with a new one, updating
|
self.map accordingly.
|
c S s i | ]\}}||qS r r )r Úidxr0 r r r Ú
|
<dictcomp>³ s z,OrderedSet._update_items.<locals>.<dictcomp>N)r Ú enumerater )r r r r r Ú _update_items s zOrderedSet._update_itemsc s: t |D ]} t |O q
|
| fdd| jD ¡ dS )aË
|
Update this OrderedSet to remove items from one or more other sets.
|
|
Example:
|
>>> this = OrderedSet([1, 2, 3])
|
>>> this.difference_update(OrderedSet([2, 4]))
|
>>> print(this)
|
OrderedSet([1, 3])
|
|
>>> this = OrderedSet([1, 2, 3, 4, 5])
|
>>> this.difference_update(OrderedSet([2, 4]), OrderedSet([1, 4, 6]))
|
>>> print(this)
|
OrderedSet([3, 5])
|
c s g | ]}| kr|qS r r rM ©Úitems_to_remover r r Ç s z0OrderedSet.difference_update.<locals>.<listcomp>N©rA r\ r )r rG rB r r] r Údifference_updateµ s z OrderedSet.difference_updatec s& t | fdd| jD ¡ dS )a^
|
Update this OrderedSet to keep only items in another set, preserving
|
their order in this set.
|
|
Example:
|
>>> this = OrderedSet([1, 4, 3, 5, 7])
|
>>> other = OrderedSet([9, 7, 1, 3, 2])
|
>>> this.intersection_update(other)
|
>>> print(this)
|
OrderedSet([1, 3, 7])
|
c s g | ]}| kr|qS r r rM rR r r r Ö s z2OrderedSet.intersection_update.<locals>.<listcomp>Nr_ rK r rR r Úintersection_updateÉ s z OrderedSet.intersection_updatec s< fdd|D }t | fddjD | ¡ dS )a
|
Update this OrderedSet to remove items from another set, then
|
add items from the other set that were not present in this set.
|
|
Example:
|
>>> this = OrderedSet([1, 4, 3, 5, 7])
|
>>> other = OrderedSet([9, 7, 1, 3, 2])
|
>>> this.symmetric_difference_update(other)
|
>>> print(this)
|
OrderedSet([4, 5, 9, 2])
|
c s g | ]}| kr|qS r r rM r r r r ä s z:OrderedSet.symmetric_difference_update.<locals>.<listcomp>c s g | ]}| kr|qS r r rM r] r r r ç s Nr_ )r rB Z items_to_addr )r^ r r Úsymmetric_difference_updateØ s
|
ÿz&OrderedSet.symmetric_difference_update)N)#r? Ú
|
__module__Ú __qualname__Ú__doc__r r r$ r r% r' r* r, r+ r1 r" Zget_locZ get_indexerr6 r: r; r r> r@ rC rI rL rJ rS rV rW rX r\ r` ra rb r r r r r * s@
|
r )re Ú itertoolsrD Ú collectionsr Úcollections.abcr r Ú ImportErrorr r Ú __version__r r r r r r Ú<module> s
|
