biBddlmZmZmZddlmZmZGddZdZy))getterconspluck)teestarmapc@eZdZdZddgZdZdZdZdZdZ d Z d Z y ) 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|_||_yt|st||_||_y||_||_yN)_default_hashkeyr callablerr )selfr r s M/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/toolz/sandbox/core.py__init__zEqualityHashKey.__init__@sJ ;,,DH  #c{DH DH c|j|jk(r|j}t|S|j|j}t|Sr)r rr hash)rvals r__hash__zEqualityHashKey.__hash__IsG 88t,, ,((CCy((499%CCyrc |j|jk(xr|j|jk(S#t$rYywxYw)NF)rr AttributeErrorrothers r__eq__zEqualityHashKey.__eq__PsG ))U-C-CC,II+ -  s36 AAc&|j| Sr)rrs r__ne__zEqualityHashKey.__ne__Ws;;u%%%rc2dt|jzSNz=%s=)strr rs r__str__zEqualityHashKey.__str__ZsDII&&rc2dt|jzSr!)reprr r#s r__repr__zEqualityHashKey.__repr__]sTYY''rN) __name__ __module__ __qualname____doc__ __slots__rrrrrr$r'rrr r s74jI-&'(rr ct|} tt|}t |}t t |||}tttt|S#t$r tcYSwxYw)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 runzipr9bsl. s)Cd3i  ZF tE3 (D  $0 11 wsA$$A:9A:N) toolz.itertoolzrrr itertoolsrrr r9r-rrr<s //" W(W(v#2r