[cLddlmZmZmZddlmZmZGddeZdZ dS))getterconspluck)teestarmapcBeZdZdZddgZdZdZdZdZdZ d Z d Z d S) EqualityHashKeya Create a hash key that uses equality comparisons between items. This may be used to create hash keys for otherwise unhashable types: >>> from toolz import curry >>> EqualityHashDefault = curry(EqualityHashKey, None) >>> set(map(EqualityHashDefault, [[], (), [1], [1]])) # doctest: +SKIP {=[]=, =()=, =[1]=} **Caution:** adding N ``EqualityHashKey`` items to a hash container may require O(N**2) operations, not O(N) as for typical hashable types. Therefore, a suitable key function such as ``tuple`` or ``frozenset`` is usually preferred over using ``EqualityHashKey`` if possible. The ``key`` argument to ``EqualityHashKey`` should be a function or index that returns a hashable object that effectively distinguishes unequal items. This helps avoid the poor scaling that occurs when using the default key. For example, the above example can be improved by using a key function that distinguishes items by length or type: >>> EqualityHashLen = curry(EqualityHashKey, len) >>> EqualityHashType = curry(EqualityHashKey, type) # this works too >>> set(map(EqualityHashLen, [[], (), [1], [1]])) # doctest: +SKIP {=[]=, =()=, =[1]=} ``EqualityHashKey`` is convenient to use when a suitable key function is complicated or unavailable. For example, the following returns all unique values based on equality: >>> from toolz import unique >>> vals = [[], [], (), [1], [1], [2], {}, {}, {}] >>> list(unique(vals, key=EqualityHashDefault)) [[], (), [1], [2], {}] **Warning:** don't change the equality value of an item already in a hash container. Unhashable types are unhashable for a reason. For example: >>> L1 = [1] ; L2 = [2] >>> s = set(map(EqualityHashDefault, [L1, L2])) >>> s # doctest: +SKIP {=[1]=, =[2]=} >>> L1[0] = 2 # Don't do this! ``s`` now has duplicate items! >>> s # doctest: +SKIP {=[2]=, =[2]=} Although this may appear problematic, immutable data types is a common idiom in functional programming, and``EqualityHashKey`` easily allows the same idiom to be used by convention rather than strict requirement. See Also: identity itemkey__default__hashkey__c| |j|_n+t|st||_n||_||_dSN)_default_hashkeyr callablerr )selfr r s 2lib/python3.11/site-packages/toolz/sandbox/core.py__init__zEqualityHashKey.__init__@sE  ,DHH# c{{DHHDH c|j|jkr|j}n||j}t|Sr)r rr hash)rvals r__hash__zEqualityHashKey.__hash__Is< 8t, , &(CC((49%%CCyyrcf |j|jko|j|jkS#t$rYdSwxYw)NF)rr AttributeErrorrothers r__eq__zEqualityHashKey.__eq__PsM )U-CC,I+ -   55 s " 00c.|| Sr)rrs r__ne__zEqualityHashKey.__ne__Ws;;u%%%%rc0dt|jzSNz=%s=)strr rs r__str__zEqualityHashKey.__str__ZsDI&&rc0dt|jzSr!)reprr r#s r__repr__zEqualityHashKey.__repr__]sTY''rN) __name__ __module__ __qualname____doc__ __slots__rrrrrr$r'rrr r s44jI-&&&'''(((((rr cPt|} tt|}n#t$rtcYSwxYwt |}t t |||}tttt|S)aJInverse of ``zip`` >>> a, b = unzip([('a', 1), ('b', 2)]) >>> list(a) ['a', 'b'] >>> list(b) [1, 2] Unlike the naive implementation ``def unzip(seq): zip(*seq)`` this implementation can handle an infinite sequence ``seq``. Caveats: * The implementation uses ``tee``, and so can use a significant amount of auxiliary storage if the resulting iterators are consumed at different times. * The inner sequence cannot be infinite. In Python 3 ``zip(*seq)`` can be used if ``seq`` is a finite sequence of infinite sequences. ) itertuplenext StopIterationlenrrrr enumerate)seqfirstnitersseqss runzipr9bs. s))Cd3ii   wwZZF tE3 ( (D  $00 1 11s.A A N) toolz.itertoolzrrr itertoolsrrobjectr r9r-rrr=s//////////"""""""" W(W(W(W(W(fW(W(W(v#2#2#2#2#2r