
    J/Ph#                     |    	 d dl mZ n# e$ r d ZY nw xY w	 d dlmZmZmZ n# e$ r Y nw xY w G d de          Z	dS )    )	get_identc                      dS )Nz<no get_ident> r       X/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/patsy/compat_ordereddict.py
_get_identr      s    r   )KeysView
ValuesView	ItemsViewc                       e Zd ZdZd Zej        fdZej        fdZd Zd Z	d Z
dd	Zd
 Zd Zd Zd Zd Zd Zd ZeZ e            ZefdZddZi fdZd Zd Zedd            Zd Zd Zd Zd Z d Z!dS )OrderedDictz)Dictionary that remembers insertion orderc                     t          |          dk    rt          dt          |          z            	 | j         n*# t          $ r g x| _        }||dg|dd<   i | _        Y nw xY w | j        |i | dS )zInitialize an ordered dictionary.  Signature is the same as for
        regular dictionaries, but keyword arguments are not recommended
        because their insertion order is arbitrary.

           z$expected at most 1 arguments, got %dN)len	TypeError_OrderedDict__rootAttributeError_OrderedDict__map_OrderedDict__update)selfargskwdsroots       r   __init__zOrderedDict.__init__%   s     t99q==BSYYNOOO	KKK 	 	 	!##DK$T4(DGDJJJ	 	t$t$$$$$s   < $A#"A#c                 t    || vr&| j         }|d         }|||gx|d<   x|d<   | j        |<    || ||           dS )z!od.__setitem__(i, y) <==> od[i]=yr   r   N)r   r   )r   keyvaluedict_setitemr   lasts         r   __setitem__zOrderedDict.__setitem__5   s[     d??;D7D37s2CCDGCd1g
3T3&&&&&r   c                 n     || |           | j                             |          \  }}}||d<   ||d<   dS )z od.__delitem__(y) <==> del od[y]r   r   N)r   pop)r   r   dict_delitem	link_prev	link_nexts        r   __delitem__zOrderedDict.__delitem__?   sF     	T3$(JNN3$7$7!	9c 	! 	!r   c              #   `   K   | j         }|d         }||ur|d         V  |d         }||udS dS )zod.__iter__() <==> iter(od)r      Nr   r   r   currs      r   __iter__zOrderedDict.__iter__H   P      {Aw$q'MMM7D $r   c              #   `   K   | j         }|d         }||ur|d         V  |d         }||udS dS )z#od.__reversed__() <==> reversed(od)r   r(   Nr)   r*   s      r   __reversed__zOrderedDict.__reversed__P   r-   r   c                     	 | j                                         D ]}|dd= | j        }||dg|dd<   | j                                          n# t          $ r Y nw xY wt
                              |            dS )z.od.clear() -> None.  Remove all items from od.N)r   
itervaluesr   clearr   dict)r   noder   s      r   r2   zOrderedDict.clearX   s    	
--//  GG;DT4(DGJ 	 	 	D	

4s   AA 
AATc                     | st          d          | j        }|r|d         }|d         }||d<   ||d<   n|d         }|d         }||d<   ||d<   |d         }| j        |= t                              | |          }||fS )zod.popitem() -> (k, v), return and remove a (key, value) pair.
        Pairs are returned in LIFO order if last is true or FIFO order if false.

        zdictionary is emptyr   r   r(   )KeyErrorr   r   r3   r"   )r   r   r   linkr$   r%   r   r   s           r   popitemzOrderedDict.popitemd   s    
  	20111{ 		 7DQIIaLDGG7DQIDGIaL1gJsOs##Ezr   c                      t          |           S )zod.keys() -> list of keys in od)listr   s    r   keyszOrderedDict.keys}       Dzzr   c                        fd D             S )z#od.values() -> list of values in odc                      g | ]
}|         S r   r   .0r   r   s     r   
<listcomp>z&OrderedDict.values.<locals>.<listcomp>   s    ***cS	***r   r   r;   s   `r   valueszOrderedDict.values   s    ****T****r   c                        fd D             S )z.od.items() -> list of (key, value) pairs in odc                 $    g | ]}||         fS r   r   r@   s     r   rB   z%OrderedDict.items.<locals>.<listcomp>   s"    111Sd3i 111r   r   r;   s   `r   itemszOrderedDict.items   s    1111D1111r   c                      t          |           S )z0od.iterkeys() -> an iterator over the keys in od)iterr;   s    r   iterkeyszOrderedDict.iterkeys   r=   r   c              #   (   K   | D ]}| |         V  dS )z2od.itervalues -> an iterator over the values in odNr   r   ks     r   r1   zOrderedDict.itervalues   s.       	 	Aq'MMMM	 	r   c              #   ,   K   | D ]}|| |         fV  dS )z=od.iteritems -> an iterator over the (key, value) items in odNr   rK   s     r   	iteritemszOrderedDict.iteritems   s6       	 	Ad1g,	 	r   c                     t          |           dk    r t          dt          |           fz            | st          d          | d         }d}t          |           dk    r| d         }t          |t                    r|D ]}||         ||<   n@t	          |d          r#|                                D ]}||         ||<   n|D ]
\  }}|||<   |                                D ]
\  }}|||<   dS )	a  od.update(E, **F) -> None.  Update od from dict/iterable E and F.

        If E is a dict instance, does:           for k in E: od[k] = E[k]
        If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
        Or if E is an iterable of items, does:   for k, v in E: od[k] = v
        In either case, this is followed by:     for k, v in F.items(): od[k] = v

        r(   z8update() takes at most 2 positional arguments (%d given)z,update() takes at least 1 argument (0 given)r   r   r   r<   N)r   r   
isinstancer3   hasattrr<   rF   )r   r   r   otherr   r   s         r   updatezOrderedDict.update   s<    t99q=='*-d))6    	LJKKKAwt99>>GEeT"" 	" ' '!#JS		'UF## 	"zz|| ' '!#JS		' $ " "
U!S		**,, 	 	JCDII	 	r   c                 X    || v r| |         }| |= |S || j         u rt          |          |S )zod.pop(k[,d]) -> v, remove specified key and return the corresponding value.
        If key is not found, d is returned if given, otherwise KeyError is raised.

        )_OrderedDict__markerr6   )r   r   defaultresults       r   r"   zOrderedDict.pop   s@    
 $;;#YFS	Mdm##3--r   Nc                 (    || v r| |         S || |<   |S )zDod.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in odr   )r   r   rV   s      r   
setdefaultzOrderedDict.setdefault   s#    $;;9S	r   c                     t          |           t                      f}||v rdS d||<   	 | s| j        j        d||= S | j        j        d|                                 d||= S # ||= w xY w)zod.__repr__() <==> repr(od)z...r   z()())idr   	__class____name__rF   )r   _repr_runningcall_keys      r   __repr__zOrderedDict.__repr__   s    d88Z\\)}$$5"#h	( ;!%!8!8!8: h''  $~666

Eh''h'''''s   A% #A% %A*c                       fd D             }t                                                     }t          t                                D ]}|                    |d           |r j        |f|fS  j        |ffS )z%Return state information for picklingc                 $    g | ]}||         gS r   r   )rA   rL   r   s     r   rB   z*OrderedDict.__reduce__.<locals>.<listcomp>   s!    ,,,!!T!W,,,r   N)varscopyr   r"   r^   )r   rF   	inst_dictrL   s   `   r   
__reduce__zOrderedDict.__reduce__   s    ,,,,t,,,JJOO%%	kmm$$ 	# 	#AMM!T"""" 	9NUHi88~x''r   c                 ,    |                      |           S )z!od.copy() -> a shallow copy of od)r^   r;   s    r   rf   zOrderedDict.copy   s    ~~d###r   c                 .     |             }|D ]}|||<   |S )zOD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
        and values equal to v (which defaults to None).

        r   )clsiterabler   dr   s        r   fromkeyszOrderedDict.fromkeys   s.     CEE 	 	CAcFFr   c                     t          |t                    rJt          |           t          |          k    o)|                                 |                                k    S t                              | |          S )zod.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
        while comparison to a regular mapping is order-insensitive.

        )rP   r   r   rF   r3   __eq__r   rR   s     r   rp   zOrderedDict.__eq__   s\    
 e[)) 	Mt99E

*Ltzz||u{{}}/LL{{4'''r   c                     | |k     S Nr   rq   s     r   __ne__zOrderedDict.__ne__   s    5=  r   c                      t          |           S )z@od.viewkeys() -> a set-like object providing a view on od's keys)r	   r;   s    r   viewkeyszOrderedDict.viewkeys  s    ~~r   c                      t          |           S )z<od.viewvalues() -> an object providing a view on od's values)r
   r;   s    r   
viewvalueszOrderedDict.viewvalues  s    $r   c                      t          |           S )zBod.viewitems() -> a set-like object providing a view on od's items)r   r;   s    r   	viewitemszOrderedDict.viewitems  s    r   )Trs   )"r_   
__module____qualname____doc__r   r3   r    r&   r,   r/   r2   r8   r<   rC   rF   rI   r1   rN   rS   r   objectrU   r"   rY   rb   rh   rf   classmethodrn   rp   rt   rv   rx   rz   r   r   r   r   r      s       //% % %  483C ' ' ' ' -1,< ! ! ! !    
 
 
   2  + + +2 2 2    
  
  B HvxxH'        &( ( ( ( (( ( ($ $ $    [( ( (! ! !
           r   r   N)
threadr   r   ImportError_abcollr	   r
   r   r3   r   r   r   r   <module>r      s    .......               	 	77777777777 	 	 	D	v v v v v$ v v v v vs   	 
# ++