U JºcQ)ã@sàddlZddlZddlmZddlmZdZdd„Zdd„Zd d „Z e fd d „Z e fd d„Z e fdd„Z e fdd„Ze fdd„Ze fdd„Ze fdd„Zdd„Ze fdd„Zde fdd„Zd(d d!„Zd"d#„Zd$d%„Zd&d'„ZdS))éN)Úreduce)ÚMapping) ÚmergeÚ merge_withÚvalmapÚkeymapÚitemmapÚ valfilterÚ keyfilterÚ itemfilterÚassocÚdissocÚassoc_inÚ update_inÚget_incCs.| dt¡}|r*td |j| ¡d¡ƒ‚|S)NÚfactoryz,{}() got an unexpected keyword argument '{}'r)ÚpopÚdictÚ TypeErrorÚformatÚ__name__Úpopitem)ÚfÚkwargsr©rúW/tmp/pip-unpacked-wheel-gikjz4vx/torch/fx/experimental/unification/unification_tools.pyÚ _get_factory s  ÿrcOsJt|ƒdkr"t|dtƒs"|d}tt|ƒ}|ƒ}|D]}| |¡q6|S)zô Merge a collection of dictionaries >>> merge({1: 'one'}, {2: 'two'}) {1: 'one', 2: 'two'} Later dictionaries have precedence >>> merge({1: 2, 3: 4}, {3: 3, 4: 4}) {1: 2, 3: 3, 4: 4} See Also: merge_with ér)ÚlenÚ isinstancerrrÚupdate)ÚdictsrrÚrvÚdrrrrs  rcOs|t|ƒdkr"t|dtƒs"|d}tt|ƒ}|ƒ}|D]8}| ¡D]*\}}||kr^|g||<qB|| |¡qBq6t|||ƒS)a¦ Merge dictionaries and apply function to combined values A key may occur in more than one dict, and all values mapped from the key will be passed to the function as a list, such as func([val1, val2, ...]). >>> merge_with(sum, {1: 1, 2: 2}, {1: 10, 2: 20}) {1: 11, 2: 22} >>> merge_with(first, {1: 1, 2: 2}, {2: 20, 3: 30}) # doctest: +SKIP {1: 1, 2: 2, 3: 30} See Also: merge rr)rrrrrÚitemsÚappendr)Úfuncr!rrÚresultr#ÚkÚvrrrr*s  rcCs(|ƒ}| t| ¡t|| ¡ƒƒ¡|S)zÞ Apply function to values of dictionary >>> bills = {"Alice": [20, 15, 30], "Bob": [10, 35]} >>> valmap(sum, bills) # doctest: +SKIP {'Alice': 65, 'Bob': 45} See Also: keymap itemmap )r ÚzipÚkeysÚmapÚvalues©r&r#rr"rrrrGs rcCs(|ƒ}| tt|| ¡ƒ| ¡ƒ¡|S)zò Apply function to keys of dictionary >>> bills = {"Alice": [20, 15, 30], "Bob": [10, 35]} >>> keymap(str.lower, bills) # doctest: +SKIP {'alice': [20, 15, 30], 'bob': [10, 35]} See Also: valmap itemmap )r r*r,r+r-r.rrrrWs rcCs|ƒ}| t|| ¡ƒ¡|S)zÜ Apply function to items of dictionary >>> accountids = {"Alice": 10, "Bob": 20} >>> itemmap(reversed, accountids) # doctest: +SKIP {10: "Alice", 20: "Bob"} See Also: keymap valmap )r r,r$r.rrrrgs rcCs,|ƒ}| ¡D]\}}||ƒr|||<q|S)zæ Filter items in dictionary by value >>> iseven = lambda x: x % 2 == 0 >>> d = {1: 2, 2: 3, 3: 4, 4: 5} >>> valfilter(iseven, d) {1: 2, 3: 4} See Also: keyfilter itemfilter valmap ©r$©Ú predicater#rr"r(r)rrrr ws  r cCs,|ƒ}| ¡D]\}}||ƒr|||<q|S)zä Filter items in dictionary by key >>> iseven = lambda x: x % 2 == 0 >>> d = {1: 2, 2: 3, 3: 4, 4: 5} >>> keyfilter(iseven, d) {2: 3, 4: 5} See Also: valfilter itemfilter keymap r/r0rrrr ‹s  r cCs0|ƒ}| ¡D]}||ƒr|\}}|||<q|S)a Filter items in dictionary by item >>> def isvalid(item): ... k, v = item ... return k % 2 == 0 and v < 4 >>> d = {1: 2, 2: 3, 3: 4, 4: 5} >>> itemfilter(isvalid, d) {2: 3} See Also: keyfilter valfilter itemmap r/)r1r#rr"Úitemr(r)rrrr Ÿs   r cCs|ƒ}| |¡|||<|S)zô Return a new dict with new key value pair New dict has d[key] set to value. Does not modify the initial dictionary. >>> assoc({'x': 1}, 'x', 2) {'x': 2} >>> assoc({'x': 1}, 'y', 3) # doctest: +SKIP {'x': 1, 'y': 3} )r )r#ÚkeyÚvaluerÚd2rrrr ·s  r cOsttt|ƒ}|ƒ}t|ƒt|ƒdkrH| |¡|D]}||kr2||=q2n(t|ƒ}| |¡|D]}||||<q^|S)aB Return a new dict with the given key(s) removed. New dict has d[key] deleted for each supplied key. Does not modify the initial dictionary. >>> dissoc({'x': 1, 'y': 2}, 'y') {'x': 1} >>> dissoc({'x': 1, 'y': 2}, 'y', 'x') {} >>> dissoc({'x': 1}, 'y') # Ignores missing keys {'x': 1} g333333ã?)rr rr ÚsetÚdifference_update)r#r+rrr5r3Ú remainingr(rrrr Çs    r cst||‡fdd„ˆ|ƒS)aê Return a new dict with new, potentially nested, key value pair >>> purchase = {'name': 'Alice', ... 'order': {'items': ['Apple', 'Orange'], ... 'costs': [0.50, 1.25]}, ... 'credit card': '5555-1234-1234-1234'} >>> assoc_in(purchase, ['order', 'costs'], [0.25, 1.00]) # doctest: +SKIP {'credit card': '5555-1234-1234-1234', 'name': 'Alice', 'order': {'costs': [0.25, 1.00], 'items': ['Apple', 'Orange']}} csˆS©Nr©Úx©r4rrÚðózassoc_in..)r)r#r+r4rrr<rräs rc Cs”t|ƒ}t|ƒ}|ƒ}}| |¡|D]@} ||krN||}|ƒ} |  |¡n |ƒ}} | ||<}| }q(||kr„|||ƒ||<n ||ƒ||<|S)a  Update value in a (potentially) nested dictionary inputs: d - dictionary on which to operate keys - list or tuple giving the location of the value to be changed in d func - function to operate on that value If keys == [k0,..,kX] and d[k0]..[kX] == v, update_in returns a copy of the original dictionary with v replaced by func(v), but does not mutate the original dictionary. If k0 is not a key in d, update_in creates nested dictionaries to the depth specified by the keys, with the innermost value set to func(default). >>> inc = lambda x: x + 1 >>> update_in({'a': 0}, ['a'], inc) {'a': 1} >>> transaction = {'name': 'Alice', ... 'purchase': {'items': ['Apple', 'Orange'], ... 'costs': [0.50, 1.25]}, ... 'credit card': '5555-1234-1234-1234'} >>> update_in(transaction, ['purchase', 'costs'], sum) # doctest: +SKIP {'credit card': '5555-1234-1234-1234', 'name': 'Alice', 'purchase': {'costs': 1.75, 'items': ['Apple', 'Orange']}} >>> # updating a value when k0 is not in d >>> update_in({}, [1, 2, 3], str, default="bar") {1: {2: {3: 'bar'}}} >>> update_in({1: 'foo'}, [2, 3, 4], inc, 0) {1: 'foo', 2: {3: {4: 1}}} )ÚiterÚnextr ) r#r+r&ÚdefaultrÚksr(r"Úinnerr3Zdtemprrrrós "      rFc Cs:zttj||ƒWStttfk r4|r,‚|YSXdS)a4 Returns coll[i0][i1]...[iX] where [i0, i1, ..., iX]==keys. If coll[i0][i1]...[iX] cannot be found, returns ``default``, unless ``no_default`` is specified, then it raises KeyError or IndexError. ``get_in`` is a generalization of ``operator.getitem`` for nested data structures such as dictionaries and lists. >>> transaction = {'name': 'Alice', ... 'purchase': {'items': ['Apple', 'Orange'], ... 'costs': [0.50, 1.25]}, ... 'credit card': '5555-1234-1234-1234'} >>> get_in(['purchase', 'items', 0], transaction) 'Apple' >>> get_in(['name'], transaction) 'Alice' >>> get_in(['purchase', 'total'], transaction) >>> get_in(['purchase', 'items', 'apple'], transaction) >>> get_in(['purchase', 'items', 10], transaction) >>> get_in(['purchase', 'total'], transaction, 0) 0 >>> get_in(['y'], {}, no_default=True) Traceback (most recent call last): ... KeyError: 'y' See Also: itertoolz.get operator.getitem N)rÚoperatorÚgetitemÚKeyErrorÚ IndexErrorr)r+ZcollrAZ no_defaultrrrr-s rcsPtˆtƒrBtˆƒdkr*ˆd‰‡fdd„Sˆr8tjˆŽSdd„Sn t ˆ¡SdS)Nrrcs |ˆfSr9rr:©Úindexrrr=Wr>zgetter..cSsdS)Nrrr:rrrr=[r>)rÚlistrrDÚ itemgetterrHrrHrÚgetterSs     rLcCs\t|ƒst|ƒ}t dd„¡}|D]}|||ƒ|ƒq"i}| ¡D]\}}|j||<qD|S)aV Group a collection by a key function >>> names = ['Alice', 'Bob', 'Charlie', 'Dan', 'Edith', 'Frank'] >>> groupby(len, names) # doctest: +SKIP {3: ['Bob', 'Dan'], 5: ['Alice', 'Edith', 'Frank'], 7: ['Charlie']} >>> iseven = lambda x: x % 2 == 0 >>> groupby(iseven, [1, 2, 3, 4, 5, 6, 7, 8]) # doctest: +SKIP {False: [1, 3, 5, 7], True: [2, 4, 6, 8]} Non-callable keys imply grouping on a member. >>> groupby('gender', [{'name': 'Alice', 'gender': 'F'}, ... {'name': 'Bob', 'gender': 'M'}, ... {'name': 'Charlie', 'gender': 'M'}]) # doctest:+SKIP {'F': [{'gender': 'F', 'name': 'Alice'}], 'M': [{'gender': 'M', 'name': 'Bob'}, {'gender': 'M', 'name': 'Charlie'}]} Not to be confused with ``itertools.groupby`` See Also: countby cSsgjSr9)r%rrrrr=zr>zgroupby..)ÚcallablerLÚ collectionsÚ defaultdictr$Ú__self__)r3Úseqr#r2r"r(r)rrrÚgroupby_s rRcCs tt|ƒƒS)zC The first element in a sequence >>> first('ABC') 'A' )r@r?)rQrrrÚfirst‚srS)NF)rNrDÚ functoolsrÚcollections.abcrÚ__all__rrrrrrrr r r r r rrrrLrRrSrrrrÚs*          : & #