
    [c"                         d dl Z d dlZd dlmZ d dlmZ dZd Zd Zd Z	e
fdZe
fd	Ze
fd
Ze
fdZe
fdZe
fdZe
fdZd Ze
fdZde
fdZddZdS )    N)reduce)Mapping)merge
merge_withvalmapkeymapitemmap	valfilter	keyfilter
itemfilterassocdissocassoc_in	update_inget_inc                     |                     dt                    }|r@t          d                    | j        |                                d                             |S )Nfactoryz,{}() got an unexpected keyword argument '{}'r   )popdict	TypeErrorformat__name__popitem)fkwargsr   s      /lib/python3.11/site-packages/toolz/dicttoolz.py_get_factoryr      s]    jjD))G H %vaj&..2B2B12EFFH H 	HN    c                      t          |           dk    r#t          | d         t                    s| d         } t          t          |          } |            }| D ]}|                    |           |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
isinstancer   r   r   update)dictsr   r   rvds        r   r   r      ss     5zzQ z%(G<< a5&))G	B  
		!Ir   c                    t          |          dk    r#t          |d         t                    s|d         }t          t          |          }t          j        d           }|D ]-}|                                D ]\  }} ||         |           . |            }|                                D ]\  }} | |j                  ||<   |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
    r    r   c                      g j         S N)append r   r   <lambda>zmerge_with.<locals>.<lambda>>   s    RY r   )	r!   r"   r   r   r   collectionsdefaultdictitems__self__)	funcr$   r   r   valuesr&   kvresults	            r   r   r   +   s     5zzQ z%(G<< a:v..G$%6%677F  GGII 	 	DAqF1IaLLLL	 WYYF % %1D$$q		Mr   c           
           |            }|                     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mapr2   r1   r&   r   r%   s       r   r   r   I   sJ     
BIIc!&&((Cahhjj1122333Ir   c           	           |            }|                     t          t          | |                                          |                                                     |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#   r7   r9   r8   r2   r:   s       r   r   r   Y   sJ     
BIIc#dAFFHH%%qxxzz22333Ir   c                      |            }|                     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#   r9   r/   r:   s       r   r	   r	   i   s8     
BIIc$		""###Ir   c                 n     |            }|                                 D ]\  }} | |          r|||<   |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&   r   r%   r3   r4   s         r   r
   r
   y   I     
B		  19Q<< 	BqEIr   c                 n     |            }|                                 D ]\  }} | |          r|||<   |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>   r?   s         r   r   r      rA   r   c                 r     |            }|                                 D ]} | |          r
|\  }}|||<   |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>   )r@   r&   r   r%   itemr3   r4   s          r   r   r      sN      
B		  9T?? 	DAqBqEIr   c                 N     |            }|                     |            |||<   |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   d2s        r   r   r      s,     
BIIaLLLBsGIr   c                 6   t          t          |          } |            }t          |          t          |           dz  k     r"|                    |            |D ]	}||v r||= 
n4t	          |           }|                    |           |D ]}| |         ||<   |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?)r   r   r!   r#   setdifference_update)r&   r8   r   r   rH   rF   	remainingr3   s           r   r   r      s     66**G	B
4yy3q66B; 	
		! 	 	Cby sG	 FF	##D))) 	 	AaDBqEEIr   c                 0    t          | |fd|          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']}}
    c                     S r)   r+   )xrG   s    r   r,   zassoc_in.<locals>.<lambda>   s     r   )r   )r&   r8   rG   r   s     ` r   r   r      s!     Qooooug>>>r   c                 ^   t          |          }t          |          } |            x}}|                    |            |D ]C}	|| v r(| |         }  |            }
|
                    |            n |            x} }
|
x||<   }|	}D|| v r || |                   ||<   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&   r8   r1   defaultr   ksr3   r%   innerrF   dtemps              r   r   r      s    D 
dBRABIIaLLL 	 	6 	"!AGIIELLOOOO		!A  a5Av !4!::a4==aIr   Fc                 ~    	 t          t          j        | |          S # t          t          t
          f$ r |r |cY S w xY w)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
    )r   operatorgetitemKeyError
IndexErrorr   )r8   collrS   
no_defaults       r   r   r   /  sR    >h&d333j),    	s    <<)NF)rX   r-   	functoolsr   collections.abcr   __all__r   r   r   r   r   r   r	   r
   r   r   r   r   r   r   r   r+   r   r   <module>ra      s              # # # # # #A
    0  < !      !      "      %)    ( %)    ( &*    0 "&       : &* ? ? ? ? &*4 7 7 7 7t$ $ $ $ $ $r   