a0bi; S r SSKrSSKJr SSKJrJr \ " S5 r
Sr S r " S S\\5 r
g! \ a SSKJrJr N*f = f) 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)
MutableSetSequencez3.1c [ U S5 =( a1 [ U [ 5 ( + =( a [ U [ 5 ( + $ )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
isinstancestrtuple)objs ڗ/builddir/build/BUILDROOT/alt-python313-setuptools-69.0.2-3.el8.x86_64/opt/alt/python313/lib/python3.13/site-packages/setuptools/_vendor/ordered_set.py is_iterabler s7 Z '3$ $ '3& & c \ rS rSrSrS!S jrS rS rS rS r S r
S
r S r \ r
S rS
r\r\rS rS rS rS rS rS rS rS rS rS rS r S r S r S r S r S r!S r"S r#S r$g)"
OrderedSet* z
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 0 / U l 0 U l Ub X- n g g Nitemsmap)selfiterables r
__init__OrderedSet.__init__4 s#
D r c , [ U R 5 $ )z
Returns the number of unique elements in the ordered set
Example:
>>> len(OrderedSet([]))
0
>>> len(OrderedSet([1, 2]))
2
)lenr r s r
__len__OrderedSet.__len__: s 4:: r c [ U[ 5 ( a U[ :X a U R 5 $ [ U5 ( a U Vs/ s H o R
U PM sn$ [
US5 ( d [ U[ 5 ( a7 U R
U n[ U[ 5 ( a U R U5 $ U$ [ SU- 5 es snf )a
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
__index__z+Don't know how to index an OrderedSet by %r)
r slice SLICE_ALLcopyr r r list __class__ TypeError)r indexiresults r
__getitem__OrderedSet.__getitem__F s $ eU # #(:99;
+015aJJqM51 1
UK
(
(Jue,D,DZZ&F&$''~~f--
IE QR R 2s C
c $ U R U 5 $ )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 s r
r% OrderedSet.copye s ~~d##r c 8 [ U 5 S:X a g[ U 5 $ )Nr r )r r& r s r
__getstate__OrderedSet.__getstate__s s t9> : r c V US:X a U R / 5 g U R U5 g )Nr )r )r states r
__setstate__OrderedSet.__setstate__ s" G MM" MM% r c XR ; $ )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 keys r
__contains__OrderedSet.__contains__ s hh r c XR ; a= [ U R 5 U R U' U R R U5 U R U $ )z
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 appendr8 s r
addOrderedSet.add sC hh
ODHHSM JJ c "xx} r c Sn U H nU R U5 nM U$ ! [ a [ S[ U5 - 5 ef = f)z
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(
ValueErrortype)r sequence
item_indexitems r
updateOrderedSet.update sW
!XXd^
! :T(^K
s "Ac [ U5 ( a! U Vs/ s H o R U5 PM sn$ U R U $ s snf )a
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
)r r) r )r r9 subkeys r
r) OrderedSet.index s> s 589S6JJv&S9 9xx} :s Ac U R ( d [ S5 eU R S nU R S U R U U$ )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 elems r
popOrderedSet.pop s> zz>* *zz"~ JJrN HHTN r c X; af U R U nU R U U R U U R R 5 H u p4XB: d M US-
U R U' M gg)ax
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 r9 r* kvs r
discardOrderedSet.discard s^ ;
A
1
(6"#a%DHHQK ) r c V U R SS2 U R R 5 g)z(
Remove all items from this OrderedSet.
N)r r clearr s r
rX OrderedSet.clear s
JJqM r c , [ U R 5 $ )zB
Example:
>>> list(iter(OrderedSet([1, 2, 3])))
[1, 2, 3]
)iterr r s r
r OrderedSet.__iter__ s DJJ r c , [ U R 5 $ )zF
Example:
>>> list(reversed(OrderedSet([1, 2, 3])))
[3, 2, 1]
)reversedr r s r
__reversed__OrderedSet.__reversed__ s
##r c U ( d U R R < S3$ U R R < S[ U 5 < S3$ )Nz()())r' __name__r& r s r
__repr__OrderedSet.__repr__ s1 !^^ 4 46 6 >>22DJ??r c [ U[ [ 45 ( a [ U 5 [ U5 :H $ [ U5 n[ U 5 U:H $ ! [
a gf = f)aF
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
F)r r r r& setr( )r other other_as_sets r
__eq__OrderedSet.__eq__ s^ $ eh . / / :e, , - u:L
t9 , , s A
AAc [ U [ 5 ( a U R O[ n[ [ [
R " U /U5 5 n[
R R U5 nU" U5 $ )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& itchain
from_iterable)r setscls
containersr s r
unionOrderedSet.union6 sR !+4 < >> 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 6 ># U H oT; d M
Uv M g 7fr ).0rE commons r
*OrderedSet.intersection..^ s =ddfnTTd )r r r' rh rw r )r rq rr r r s @r
rw OrderedSet.intersectionM sN !+4 < >> 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 6 ># U H oT; d M
Uv M g 7fr r} r~ rE ri s r
r (OrderedSet.difference..t s @dd%.?TTdr )r' rh rt r )r rq rr r ri s @r
differenceOrderedSet.differencec s> nn IIs3~.E@d@EE5zr c ` ^ [ U 5 [ T5 : a g[ U4S jU 5 5 $ )z
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 , ># U H oT; v M g 7fr r} r s r
r &OrderedSet.issubset.. s 2TT5=T r allrx s `r
issubsetOrderedSet.issubsety s) t9s5z !2T222r c ` ^ [ T 5 [ U5 : a g[ U 4S jU 5 5 $ )z
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 , ># U H oT; v M g 7fr r} )r~ rE r s r
r (OrderedSet.issuperset.. s 2ED4>> 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' r rt )r ri rr diff1diff2s r
symmetric_difference OrderedSet.symmetric_difference sR !+4 < >> 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])
Nrh r r )r rq items_to_removeri rE s r
difference_update OrderedSet.difference_update sL %E s5z )O TZZWZT;VDZWXWs AAc [ U5 nU R U R Vs/ s H o"U; d M
UPM sn5 gs snf )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])
Nr )r ri rE s r
intersection_update OrderedSet.intersection_update s5 E
TZZIZT5=DZIJIs
A A c U Vs/ s H o"U ; d M
UPM nn[ U5 nU R U R Vs/ s H o"U; d M
UPM snU- 5 gs snf s snf )aA
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])
Nr )r ri rE items_to_addr s r
symmetric_difference_update&OrderedSet.symmetric_difference_update s` */Cd2B C e* "jj Hjd,GTj H< W
D
Is A A A! A!r r )%rd
__module__ __qualname____firstlineno____doc__r r r, r% r1 r5 r: r> r= rF r) get_loc get_indexerrO rU rX r r_ re rk rt ry rw r r r r r r r r __static_attributes__r} r r
r r * s
S> $
!
& F, $ GK&(0 $@
-<&(,,3 3 "(CY(
K
r r )r itertoolsrn collectionsr collections.abcr r ImportErrorr# r$ __version__r r r} r r
r sV 14
$K (~
X ~
9 1001s 0 A A