3
tûœ]ˆ  ã               @   sÒ  d Z ddlZddlZddlZddlmZ ddlmZ ddlmZ ddlm	Z	 ddlm
Z
 ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ ejƒ Zd[dd„Zeej_eej_eej_eej_eej_eej_d\dd„Ze	jd]dd„ƒZeej_eej_eej _d^dd„Z!dd„ Z"dd„ Z#e!ej$_dd„ Z%d_dd„Z&e	je	j'e&ƒƒej(_e&ej)_*e	je	j'd`dd„ƒƒZ+e+ej,_e	je	j'dad d!„ƒƒZ-e-ej._e	je	j'dbd"d#„ƒƒZ/e/ej0_dcd$d%„Z1e	je	j'e1ƒƒej2_e	je1ƒej3_*e	je	j'ddd&d'„ƒƒZ4e4ej5_e6ƒ Z7e	jded(d)„ƒZ8e	j'e8ƒej9_e8ej9_*e	je	j'dfd*d+„ƒƒZ:e:ej;_d,d-„ Z<dgd.d/„Z=e	je	j'dhd0d1„ƒƒZ>e=ej?_=e>ej?_d2d3„ Z@d4d5„ ZAdid7d8„ZBdjd9d:„ZCd;d<„ ZDd=d>„ ZEd?d@„ ZFdAdB„ ZGdCdD„ ZHdEdF„ ZIe	jJe	j'dkdGdH„ƒƒZKeIejL_IeKejL_dldIdJ„ZMe	je	j'dmdKdL„ƒƒZNeMejO_MeNejO_e	jdndMdN„ƒZPePejQ_e	je	j'dodOdP„ƒƒZReRej)_eRej3_e	je	j'dpdQdR„ƒƒZSeSejT_e	jdqdSdT„ƒZUeUejV_drdUdV„ZWeWejX_YdWdX„ ZZe	jdsdYdZ„ƒZ[e[ej\_dS )tzMthis module contains a set of functions to handle inference on astroid trees
é    N)Úbases)Úcontext)Ú
exceptions)Ú
decorators)Úhelpers)Úmanager)Únodes)Údunder_lookup)Ú	protocols)Úutilc             c   s
   | V  dS )zRinference's end for node such as Module, ClassDef, FunctionDef,
    Const...

    N© )Úselfr   r   r   ú4/tmp/pip-build-fn42xldr/astroid/astroid/inference.pyÚ	infer_end.   s    r   c             C   s®   g }x¤| j D ]š}t|tjƒrdtj|j|ƒ}|s<tj| |d�‚t	|dƒsTtj| |d�‚|j
t|ƒƒ qt|tjƒrœtj|j|ƒ}|s�tj| |d�‚|j|ƒ q|j|ƒ qW |S )z-Infer all values based on _BaseContainer.elts)Únoder   Úelts)r   Ú
isinstancer   ÚStarredr   Ú
safe_inferÚvaluer   ÚInferenceErrorÚhasattrÚextendÚ_infer_sequence_helperÚ	NamedExprÚappend)r   r   ÚvaluesÚeltZstarredr   r   r   r   r   >   s     
r   c             c   sV   t dd„ | jD ƒƒ}|rLt| |ƒ}t| ƒ| j| j| jd�}|j|ƒ |V  n| V  d S )Nc             s   s    | ]}t |tjtjfƒV  qd S )N)r   r   r   r   )Ú.0Úer   r   r   ú	<genexpr>W   s    z!infer_sequence.<locals>.<genexpr>)ÚlinenoÚ
col_offsetÚparent)Úanyr   r   Útyper!   r"   r#   Úpostinit)r   r   Zhas_starred_named_exprr   Únew_seqr   r   r   Úinfer_sequenceT   s    

r(   c             c   sX   t dd„ | jD ƒƒs| V  n8t| |ƒ}t| ƒ| j| j| jƒ}|jt|jƒ ƒƒ |V  d S )Nc             s   s   | ]\}}t |tjƒV  qd S )N)r   r   Ú
DictUnpack)r   ÚkÚ_r   r   r   r    k   s    zinfer_map.<locals>.<genexpr>)	r$   ÚitemsÚ
_infer_mapr%   r!   r"   r#   r&   Úlist)r   r   r,   r'   r   r   r   Ú	infer_mapj   s    
r/   c             C   s.   t j| jƒ |jƒ ƒ}dd„ |D ƒ}t|jƒ ƒS )ab  Delete nodes that equate to duplicate keys

    Since an astroid node doesn't 'equal' another node with the same value,
    this function uses the as_string method to make sure duplicate keys
    don't get through

    Note that both the key and the value are astroid nodes

    Fixes issue with DictUnpack causing duplicte keys
    in inferred Dict items

    :param dict(nodes.NodeNG, nodes.NodeNG) lhs_dict: Dictionary to 'merge' nodes into
    :param dict(nodes.NodeNG, nodes.NodeNG) rhs_dict: Dictionary with nodes to pull from
    :return dict(nodes.NodeNG, nodes.NodeNG): merged dictionary of nodes
    c             S   s   i | ]\}}||f|j ƒ “qS r   )Ú	as_string)r   Úkeyr   r   r   r   ú
<dictcomp>†   s    z,_update_with_replacement.<locals>.<dictcomp>)Ú	itertoolsÚchainr,   Údictr   )Zlhs_dictZrhs_dictZcombined_dictZ
string_mapr   r   r   Ú_update_with_replacementt   s    r6   c             C   s¼   i }x²| j D ]¨\}}t|tjƒrftj||ƒ}|s6tj‚t|tjƒsPtj| |d�‚t	||ƒ}t
||ƒ}qtj||d�}tj||d�}tdd„ ||fD ƒƒr¦tj| |d�‚t
|||iƒ}qW |S )z$Infer all values based on Dict.items)r   r   )r   c             s   s   | ]}| V  qd S )Nr   )r   Úelemr   r   r   r    š   s    z_infer_map.<locals>.<genexpr>)r,   r   r   r)   r   r   r   r   ÚDictr-   r6   r$   )r   r   r   Únamer   Zdouble_starredZunpack_itemsr1   r   r   r   r-   ‹   s     
r-   c             C   s:   | }x |j r$t|j tjƒ r$|j }qW |r6|j r6|j S dS )a¡   Search for the first function which encloses the given
    scope. This can be used for looking up in that function's
    scope, in case looking up in a lower scope for a particular
    name fails.

    :param node: A scope node.
    :returns:
        ``None``, if no parent function scope was found,
        otherwise an instance of :class:`astroid.scoped_nodes.Function`,
        which encloses the given node.
    N)r#   r   r   ÚFunctionDef)r   Úcurrentr   r   r   Ú_higher_function_scope£   s    

r<   c             C   sn   | j | jƒ\}}|sNt| jƒ ƒ}|r4|j | jƒ\}}|sNtj| j| jƒ |d�‚tj|ƒ}| j|_t	j
|||ƒS )z#infer a Name: use name lookup rules)r9   Úscoper   )Úlookupr9   r<   r=   r   ZNameInferenceErrorÚ
contextmodÚcopy_contextÚ
lookupnamer   Ú_infer_stmts)r   r   ÚframeÚstmtsZparent_functionr+   r   r   r   Ú
infer_name·   s    
rE   c             c   s¬   t j|ƒ}t j| j| jd�|_d|_|dk	r<t| |jƒ ƒ|_	xb| j
j|ƒD ]R}|tjkr`|V  qJy"t|dƒr€|j| |d�E dH  W qJ tjk
rš   wJY qJX qJW t| |d�S )z>infer a Call node by trying to guess what the function returns)ÚargsÚkeywordsNÚinfer_call_result)Úcallerr   )r   r   )r?   r@   ÚCallContextrF   rG   ÚcallcontextÚ	boundnodeÚ_populate_context_lookupÚcloneZextra_contextÚfuncÚinferr   ÚUninferabler   rH   r   r   r5   )r   r   rK   Zcalleer   r   r   Ú
infer_callÑ   s     


rR   Tc             c   s~   |j }|dkrtj| |d�‚y(|r6| j| j|ƒƒV  n| j|ƒV  W n4 tjk
rx } ztj| |d�|‚W Y dd}~X nX dS )z7infer an Import node: return the imported module/objectN)r   r   )rA   r   r   Údo_import_moduleÚ	real_nameÚAstroidBuildingError)r   r   Úasnamer9   Úexcr   r   r   Úinfer_importì   s    rX   c              C   sÞ   |j }|dkrtj| |d�‚|r*| j|ƒ}y| jƒ }W n4 tjk
rj } ztj| |d�|‚W Y dd}~X nX y2tj|ƒ}||_ |j||| j	ƒ kd�}t
j||ƒS  tjk
rØ } ztj|j| ||d�|‚W Y dd}~X nX dS )z:infer a ImportFrom node: return the imported module/objectN)r   r   )Zignore_locals)ÚtargetÚ	attributer   )rA   r   r   rT   rS   rU   r?   r@   ÚgetattrÚrootr   rB   ÚAttributeInferenceErrorÚmessage)r   r   rV   r9   ÚmodulerW   rD   Úerrorr   r   r   Úinfer_import_from   s$    
"
ra   c             c   sô   xæ| j j|ƒD ]Ö}|tjkr$|V  q|r„|jr„t|tjƒr„t|jtjƒr„y$tj	tj
|jƒtj
|ƒƒrj|j}W n tjk
r‚   Y nX y$||_|j| j|ƒE dH  d|_W q tjtjfk
rÊ   d|_Y q tk
râ   d|_Y qX qW t| |d�S )zAinfer an Attribute node by using getattr on the associated objectN)r   r   )ÚexprrP   r   rQ   rL   r   r   ÚInstancer   Ú
is_subtypeÚobject_typer   Ú_NonDeducibleTypeHierarchyÚigetattrÚattrnamer]   r   ÚAttributeErrorr5   )r   r   Úownerr   r   r   Úinfer_attribute  s.    





rk   c             C   sr   |j d krtj| |d�‚ytj| jƒ j|j ƒ|ƒS  tjk
rl } ztj|j| |j |d�|‚W Y d d }~X nX d S )N)r   r   )rY   rZ   r   )	rA   r   r   r   rB   r\   r[   r]   r^   )r   r   r`   r   r   r   Úinfer_globalH  s    
rl   c       	      c   sP  d}�x2| j j|ƒD �] }|tjkr0tjV  dS �x| jj|ƒD ]ò}|tjkrZtjV  dS t}|jtjkrp|}n$|jtjkr�t	j
|ƒ}|r”|}n|}|tkrªtj| |d�‚y|j||ƒ}W n@ tjtjtjtfk
rú } ztj| |d�|‚W Y dd}~X nX | |k�s|tjk�rtjV  dS |j|ƒE dH  d}q@W qW |�rLt| |d�S dS )zâInference for subscripts

    We're understanding if the index is a Const
    or a slice, passing the result of inference
    to the value's `getitem` method, which should
    handle each supported index type accordingly.
    FN)r   r   T)r   rP   r   rQ   ÚsliceÚ_SUBSCRIPT_SENTINELÚ	__class__r   rc   r   Zclass_instance_as_indexr   r   ÚgetitemZAstroidTypeErrorZAstroidIndexErrorr]   ri   r5   )	r   r   Z	found_oner   ÚindexZindex_valueZinstance_as_indexÚassignedrW   r   r   r   Úinfer_subscript[  sF    



"rs   c             #   sî   | j }| jdkrtj}ntj}y‡ fdd„|D ƒ}W n tjk
rR   tjV  dS X xŒt	j
|Ž D ]~}tdd„ |D ƒƒr€tjV  q`dd„ |D ƒ}tdd„ |D ƒƒrªtjV  q`tj}x,t||ƒD ]\}}||ƒr¼|V  P q¼W |V  q`W t| ˆ d	�S )
z²Infer a boolean operation (and / or / not).

    The function will calculate the boolean operation
    for all pairs generated through inference for each component
    node.
    Úorc                s   g | ]}|j ˆ d �‘qS ))r   )rP   )r   r   )r   r   r   ú
<listcomp>¨  s    z!_infer_boolop.<locals>.<listcomp>Nc             s   s   | ]}|t jkV  qd S )N)r   rQ   )r   Úitemr   r   r   r    ®  s    z _infer_boolop.<locals>.<genexpr>c             S   s   g | ]}|j ƒ ‘qS r   )Ú
bool_value)r   rv   r   r   r   ru   ³  s    c             s   s   | ]}|t jkV  qd S )N)r   rQ   )r   rv   r   r   r   r    ´  s    )r   r   )r   ÚopÚoperatorÚtruthÚnot_r   r   r   rQ   r3   Úproductr$   Úzipr5   )r   r   r   Ú	predicateÚpairZbool_valuesr   rw   r   )r   r   Ú_infer_boolop˜  s0    	

r€   c             c   s2   x,|| |ƒD ]}t ||ƒr$tjV  q|V  qW d S )N)r   r   rQ   )r   Zinfer_callabler   r`   Úresultr   r   r   Ú_filter_operation_errorsÓ  s    

r‚   c       
      c   s  �x | j j|ƒD �]î}y|j| jƒV  W q tk
r\ } ztj|| j|ƒV  W Y dd}~X q tk
�rþ } �z„tj	| j }|dkr²|j
ƒ }|tjk	r¦tj| ƒV  ntjV  �n<t|tjtjfƒsØtj|| j|ƒV  wy¾ytj||ƒ}W n, tjk
�r   tj|| j|ƒV  wY nX |d }t|j|d�ƒ}|tjk�sH|jƒ  �rJwtj|ƒ}tj|gd�|_|j| |d�}t|dƒ}	|	dk�rŽ|V  n|	V  W nV tjk
�rÎ } ztj|| j|ƒV  W Y dd}~X n  tjk
�rì   tjV  Y nX W Y dd}~X qX qW dS )z3Infer what an UnaryOp should return when evaluated.Nr   )r   )rF   )ÚoperandrP   Zinfer_unary_oprx   Ú	TypeErrorr   ÚBadUnaryOperationMessageri   r
   ZUNARY_OP_METHODrw   rQ   r   Zconst_factoryr   r   rc   ÚClassDefr	   r>   r   r]   ÚnextÚcallabler?   r@   rJ   rK   rH   r   )
r   r   rƒ   rW   Úmethrw   ÚmethodsÚinferredZcall_resultsr�   r   r   r   Ú_infer_unaryopÞ  sH    "




"rŒ   c             c   s"   t | t|tjƒE dH  t| |d�S )z3Infer what an UnaryOp should return when evaluated.N)r   r   )r‚   rŒ   r   r…   r5   )r   r   r   r   r   Úinfer_unaryop  s    r�   c             C   s   t | tjƒo| jtkS )z0Check if the given const node is NotImplemented.)r   r   ÚConstr   ÚNotImplemented)Úconstr   r   r   Ú_is_not_implemented"  s    r‘   c       	      C   sR   t j| |ƒ}tj|| ƒ}|d }t|j|d�ƒ}|tjkr@tj	‚| j
|||||ƒS )z8Invoke binary operation inference on the given instance.r   )r   )r	   r>   r?   Úbind_context_to_noder‡   rP   r   rQ   r   r   Zinfer_binary_op)	ÚinstanceÚopnoderx   Úotherr   Úmethod_namerŠ   Úmethodr‹   r   r   r   Ú_invoke_binop_inference'  s    
r˜   Fc          	   C   s"   t j| }tjt| |||||d�S )z<Get an inference callable for an augmented binary operation.)r“   rx   r”   r•   r   r–   )r
   ZAUGMENTED_OP_METHODÚ	functoolsÚpartialr˜   )r“   r”   rx   r•   r   Úreverser–   r   r   r   Ú_aug_op2  s    
rœ   c          	   C   s2   |rt j| }n
t j| }tjt| |||||d�S )zˆGet an inference callable for a normal binary operation.

    If *reverse* is True, then the reflected method will be used instead.
    )r“   rx   r”   r•   r   r–   )r
   ZREFLECTED_BIN_OP_METHODZBIN_OP_METHODr™   rš   r˜   )r“   r”   rx   r•   r   r›   r–   r   r   r   Ú_bin_op@  s    
r�   c             c   s:   x4||fD ](}| j ƒ }tj|gd�|_d|_|V  q
W dS )zÄGet contexts for binary operations.

    This will return two inference contexts, the first one
    for x.__op__(y), the other one for y.__rop__(x), where
    only the arguments are inversed.
    )rF   N)rN   r?   rJ   rK   rL   )r   ÚleftÚrightÚargÚnew_contextr   r   r   Ú_get_binop_contextsT  s
    	r¢   c             C   s   | j ƒ |j ƒ kS )z$Check if type1 is the same as type2.)Úqname)Ztype1Ztype2r   r   r   Ú
_same_typed  s    r¤   c       	   	   C   sž   |j }t||ƒr$t| ||||ƒg}nvtj||ƒrDt| ||||ƒg}nVtj||ƒrvt|||| |dd�t| ||||ƒg}n$t| ||||ƒt|||| |dd�g}|S )aV  Get the flow for binary operations.

    The rules are a bit messy:

        * if left and right have the same type, then only one
          method will be called, left.__op__(right)
        * if left and right are unrelated typewise, then first
          left.__op__(right) is tried and if this does not exist
          or returns NotImplemented, then right.__rop__(left) is tried.
        * if left is a subtype of right, then only left.__op__(right)
          is tried.
        * if left is a supertype of right, then right.__rop__(left)
          is first tried and then left.__op__(right)
    T)r›   )rx   r¤   r�   r   rd   Úis_supertype)	rž   Ú	left_typeÚbinary_opnoderŸ   Ú
right_typer   Úreverse_contextrx   rŠ   r   r   r   Ú_get_binop_flowi  s    
rª   c       
   
   C   sâ   |j jdƒ}|j }t||ƒr>t| ||||ƒt| ||||ƒg}	n tj||ƒrlt| ||||ƒt| ||||ƒg}	nrtj||ƒr¬t| ||||ƒt|||| |dd�t| ||||ƒg}	n2t| ||||ƒt| ||||ƒt|||| |dd�g}	|	S )a–  Get the flow for augmented binary operations.

    The rules are a bit messy:

        * if left and right have the same type, then left.__augop__(right)
          is first tried and then left.__op__(right).
        * if left and right are unrelated typewise, then
          left.__augop__(right) is tried, then left.__op__(right)
          is tried and then right.__rop__(left) is tried.
        * if left is a subtype of right, then left.__augop__(right)
          is tried and then left.__op__(right).
        * if left is a supertype of right, then left.__augop__(right)
          is tried, then right.__rop__(left) and then
          left.__op__(right)
    ú=T)r›   )rx   Ústripr¤   rœ   r�   r   rd   r¥   )
rž   r¦   Z
aug_opnoderŸ   r¨   r   r©   Zbin_opZaug_oprŠ   r   r   r   Ú_get_aug_flowŒ  s     
r­   c             c   s  t || |ƒ\}}tj| ƒ}tj|ƒ}|| ||||||ƒ}xÎ|D ]Æ}	yt|	ƒ ƒ}
W nH tk
rf   w>Y q> tjk
r|   w>Y q> tjk
r˜   tj	V  dS X t
dd„ |
D ƒƒr¸tj	V  dS ttt|
ƒƒrÈq>tdd„ |
D ƒƒ}|rö|t|
ƒkrötj	V  dS |
E dH  dS q>W tj||j|ƒV  dS )zÎInfer a binary operation between a left operand and a right operand

    This is used by both normal binary operations and augmented binary
    operations, the only difference is the flow factory used.
    Nc             s   s   | ]}|t jkV  qd S )N)r   rQ   )r   r�   r   r   r   r    Ñ  s    z*_infer_binary_operation.<locals>.<genexpr>c             s   s   | ]}t |ƒrd V  qdS )é   N)r‘   )r   r�   r   r   r   r    Ø  s    )r¢   r   re   r.   ri   r   r]   r   r   rQ   r$   ÚallÚmapr‘   ÚsumÚlenÚBadBinaryOperationMessagerx   )rž   rŸ   r§   r   Úflow_factoryr©   r¦   r¨   rŠ   r—   ÚresultsÚnot_implementedr   r   r   Ú_infer_binary_operation¹  s8    



r·   c       
      c   s¾   | j }| j}|ptjƒ }tj|ƒ}tj|ƒ}|j|d�}|j|d�}xttj||ƒD ]d\}}	tdd„ |	|fD ƒƒr|t	j
V  dS yt||	| |tƒE dH  W qR tjk
r´   t	j
V  Y qRX qRW dS )z!Binary operation inference logic.)r   c             s   s   | ]}|t jkV  qd S )N)r   rQ   )r   r   r   r   r   r    ó  s    z_infer_binop.<locals>.<genexpr>N)rž   rŸ   r?   ÚInferenceContextr@   rP   r3   r|   r$   r   rQ   r·   rª   r   rf   )
r   r   rž   rŸ   Zlhs_contextÚrhs_contextÚlhs_iterÚrhs_iterÚlhsÚrhsr   r   r   Ú_infer_binopå  s    

r¾   c             C   s   t | t|tjƒS )N)r‚   r¾   r   r³   )r   r   r   r   r   Úinfer_binopþ  s    r¿   c             c   s°   |dkrt jƒ }|jƒ }| jj|d�}| jj|d�}xvtj||ƒD ]f\}}t	dd„ ||fD ƒƒrlt
jV  dS yt||| |td�E dH  W qB tjk
r¦   t
jV  Y qBX qBW dS )z0Inference logic for augmented binary operations.N)r   c             s   s   | ]}|t jkV  qd S )N)r   rQ   )r   r   r   r   r   r      s    z#_infer_augassign.<locals>.<genexpr>)rž   rŸ   r§   r   r´   )r?   r¸   rN   rY   Ú	infer_lhsr   rP   r3   r|   r$   r   rQ   r·   r­   r   rf   )r   r   r¹   rº   r»   r¼   r½   r   r   r   Ú_infer_augassign
  s$    rÁ   c             C   s   t | t|tjƒS )N)r‚   rÁ   r   r³   )r   r   r   r   r   Úinfer_augassign%  s    rÂ   c             C   s*   |j }|d krtj| |d�‚tj| ||ƒS )N)r   r   )rA   r   r   r
   Z_arguments_infer_argname)r   r   r9   r   r   r   Úinfer_arguments3  s    rÃ   c             C   s:   | j ƒ }t|tjƒr|j|ƒS t| j|d�ƒ}tj||ƒS )zWinfer a AssignName/AssignAttr: need to inspect the RHS part of the
    assign node
    )r   )	Z	statementr   r   Ú	AugAssignrP   r.   Zassigned_stmtsr   rB   )r   r   ÚstmtrD   r   r   r   Úinfer_assign>  s
    
rÆ   c             c   sP   | j ƒ stjV  n:ytj| j|d�E d H  W n tjk
rJ   tjV  Y nX d S )N)r   )Zhas_underlying_objectr   rQ   ÚMANAGERZinfer_ast_from_somethingÚobjectr   ZAstroidError)r   r   r   r   r   Úinfer_empty_nodeP  s    
rÉ   c             C   s   | j j|ƒS )N)r   rP   )r   r   r   r   r   Úinfer_index_  s    rÊ   c             C   sd   t j|| ƒ}|s|}t j|gd�|_t| jd|d�d ƒ}t|tjƒsTt	j
d| |d�‚t|j| |ƒƒS )N)rF   Ú__getitem__)r   z(Could not find __getitem__ for {node!r}.)r   r   )r?   r’   rJ   rK   r‡   rg   r   r   ZBoundMethodr   r   rH   )r   rq   r   r¡   r—   r   r   r   Úinstance_getitemh  s    rÌ   c             C   sp   i }|d kr|S x.| j D ]$}t|tjƒr4|||j< q|||< qW | jd k	rP| jng }x|D ]}|||j< qZW |S )N)rF   r   r   r   r   rG   )Úcallr   Zcontext_lookupr    rG   Úkeywordr   r   r   rM   }  s    
rM   c             c   s¨   d}yt | jj|d�ƒ}W n tjk
r4   d}Y nDX |tjk	rt|jƒ r^| jj|d�E dH  qx| j	j|d�E dH  nd}|r¤| jj|d�E dH  | j	j|d�E dH  dS )zÁSupport IfExp inference

    If we can't infer the truthiness of the condition, we default
    to inferring both branches. Otherwise, we infer either branch
    depending on the condition.
    F)r   TN)
r‡   ÚtestrP   r   r   r   rQ   rw   ÚbodyZorelse)r   r   Zboth_branchesrÏ   r   r   r   Úinfer_ifexpŽ  s    

rÑ   )N)N)N)N)N)N)NT)NT)N)N)N)N)N)N)F)F)N)N)N)N)N)N)N)N)N)]Ú__doc__r™   r3   ry   Zastroidr   r   r?   r   r   r   r   r   Zastroid.interpreterr	   r
   r   ZAstroidManagerrÇ   r   ÚModuleZ_inferr†   r:   ÚLambdarŽ   ÚSlicer   Zraise_if_nothing_inferredr(   ÚListÚTupleÚSetr/   r6   r-   r8   r<   rE   Zpath_wrapperÚNameZ
AssignNamerÀ   rR   ÚCallrX   ÚImportra   Ú
ImportFromrk   Ú	AttributeZ
AssignAttrrl   ÚGlobalrÈ   rn   rs   Ú	Subscriptr€   ÚBoolOpr‚   rŒ   r�   ÚUnaryOpr‘   r˜   rœ   r�   r¢   r¤   rª   r­   r·   r¾   Zyes_if_nothing_inferredr¿   ÚBinOprÁ   rÂ   rÄ   rÃ   Ú	ArgumentsrÆ   rÉ   Z	EmptyNoderÊ   ÚIndexrÌ   rc   rp   rM   rÑ   ÚIfExpr   r   r   r   Ú<module>   sä   





$83
6

#-,


