o
    ˷e                     @   sz  d 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m	Z	m
Z
mZ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mZ ddlmZ ddlmZmZ ddlmZ ddlmZmZm Z m!Z!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/m0Z0 ddl1m2Z2 ddddddd d!d"d#d$d%d&d'Z3d(d) e34 D Z5d*d+ Z6d,d- Z7d.d/ Z8e&e	d0d1d2 Z9ej:e6d3d4 Z;d5d6 Z<d7d8 Z=e6d[d9d:Z>ej:d[d;d<Z?d=d> Z@ed?d@ ZAdAdB ZBdCdD ZCdEdF ZDdGdH ZEdIdJ ZFdKdL ZGdMdN ZHdOdP ZIe2J dQdR ZKe& dSdT ZLdUdV ZMG dWdX dXe
ZNdYdZ ZOdS )\z&
Functions inferring the syntax tree.
    N)tree)debug)parser_utils)ValueSet	NO_VALUESContextualizedNodeiterator_to_value_setiterate_values)LazyTreeValue)compiled)	recursion)analysis)imports)	arguments)
ClassValueFunctionValue)iterable)ListModificationDictModification)TreeInstance)	is_string
is_literal	is_numberget_names_of_nodeis_big_annoying_library)COMPARISON_OPERATORS)inference_state_method_cache)VersionInfo)
annotation)TreeNameDefinition)CompForContext	Decoratee)plugin_manager__add____sub____mul__
__matmul____truediv____floordiv____mod____pow__
__lshift__
__rshift____and____or____xor__)+-*@/z//%**z<<z>>&|^c                 C   s"   i | ]\}}|d |dd  qS )__r   N ).0kvr=   r=   Q/var/www/ideatree/venv/lib/python3.10/site-packages/jedi/inference/syntax_tree.py
<dictcomp>1   s    rB   c                    s    fdd}|S )a{  
    This is for now the way how we limit type inference going wild. There are
    other ways to ensure recursion limits as well. This is mostly necessary
    because of instance (self) access that can be quite tricky to limit.

    I'm still not sure this is the way to go, but it looks okay for now and we
    can still go anther way in the future. Tests are there. ~ dave
    c                    s   | j }| j}z-|j|  d7  < d}| jd u r"|  |ju r"|d9 }|j| |kr2td| tW S W n t	yA   d|j|< Y nw  | g|R i |S )N   i,  d   z+In value %s there were too many inferences.)
	tree_nodeinference_stateinferred_element_countsparent_context	get_valuebuiltins_moduler   warningr   KeyError)contextargskwargsnrF   maximumfuncr=   rA   wrapper?   s    
z$_limit_value_infers.<locals>.wrapperr=   )rS   rT   r=   rR   rA   _limit_value_infers6   s   	rU   c              	      s  t | tr
t| |S |}|d ur%|j}|jdv rnt|r!d }n|d us| j|}|d u r|r|jdkr| j	j
r|jd }i g}|j|jkrt|}t|}dd |D  t fdd|D r|D ][}| j	| |}	t|	dkrt|t|	 dkrtd	| i g} n8t|}
g }|	D ]#}t|
}t|D ]\}}| ||< t|g|| |j< q||7 }qqd|D ]}|	||j< qqdt|dkrt}|D ]}| || |t| |O }W d    n1 sw   Y  q|S t| |S |rt| |S t| |S )
N)if_stmtfor_stmtrV   rC   c                 S   s   g | ]}|j qS r=   value)r>   er=   r=   rA   
<listcomp>t   s    zinfer_node.<locals>.<listcomp>c                 3   s    | ]}|j  v V  qd S NrX   )r>   istr_element_namesr=   rA   	<genexpr>u   s    zinfer_node.<locals>.<genexpr>   z,Too many options for if branch inference %s.)
isinstancer    _infer_nodeparenttyper   is_scopepredefined_namesgetrF   is_analysischildren	start_posend_posr   anyinferlenr   dbglist	enumeratecopyr   rY   r   predefine_names_infer_node_if_inferred)rM   elementrV   predefined_if_name_dictif_stmt_test
name_dictsif_nameselement_namesif_namedefinitionsoriginal_name_dicts
definitionnew_name_dictsr]   	name_dictresultr=   r^   rA   
infer_nodeW   sh   








r   c                 C   sB   |}|dur|j }| j|}|durt| |S |dust| |S )zA
    TODO This function is temporary: Merge with infer_node.
    N)rd   rg   rh   rc   _infer_node_cached)rM   rv   rd   rw   r=   r=   rA   ru      s   

ru   )defaultc                 C   s
   t | |S r\   )rc   )rM   rv   r=   r=   rA   r      s   
r   c                 C   s  t d||j|  | j}|j}|dv rt| |S |dkr%tt| |gS |dkr.t	| |S |dv r|j
d }|j
dd  }d}|jd	krQ|jd
krQd}|d}| |}t|D ] \}}	|	dkrt| ||d  }
t| ||	|
} nt| ||	}qZ|r|  S |S |dv rtt|| |gS |dv r| |j
d }|j
d d D ]}t||}q|S |dkr| |j
d | |j
d B S |dkr|jdkr|j}tdt|j|f tt|dgS |dkrt| |j
d }|j
dd d D ]	}|j|| d}q|S |dkr| |j
d S |dkr"t| |j
d  S |dkrNt|j
rL|j
d jdkrL|j
d j
d }| |d  }| S t!S |dkr[| |j
d S t"| |S )Nzinfer_node %s@%s in %s)namenumberstringatomstringskeywordfstringlambdef	expr_stmt)power	atom_exprr   rC   Fr   awaitTr7   )testlist_star_exprtestlist)not_testfactortestoperatorz...zunhandled operator %s in %s Ellipsisdotted_namer<   )name_context
eval_input	annassign
yield_expr	yield_arg__iter__namedexpr_test)#r   rp   rk   rF   re   
infer_atomr   r   from_contextinfer_expr_stmtrj   rY   popr   rr   _infer_comparisoninfer_trailerpy__await__py__stop_iteration_returnsr   SequenceLiteralValueinfer_factorrd   AssertionErrorreprr   builtin_from_namepy__getattribute__r   infer_annotationexecute_annotationro   execute_with_valuesr   infer_or_test)rM   rv   rF   typfirst_childrj   	had_await	value_setr]   trailerrightr   origin	next_name
generatorsr=   r=   rA   rc      s   












rc   c                 C   s   |j d d \}}|dkrd }|dkr%|j \}}}|t| |t| |S td|| |dkr7|j| |dS |dksAJ d| t| j	| ||}|
|S )	Nr<   )[zinfer_trailer: %s in %s.)r   name_or_str(ztrailer_op is actually %s)rj   get_item_infer_subscript_listr   r   rp   r   r   TreeArgumentsrF   execute)rM   atom_valuesr   
trailer_opnode_rN   r=   r=   rA   r     s$   
r   c              	      s  | j } jdkr>t dddp }|jdkr't fdd| D s& }n|jdkr. }|j}t r7d}| j |dS  jd	kr_ j	d
v rRt
t| j	gS  j	dkrYtS J d  t tjru|j j	}t
t||gS  jdkrt|  jd } jdd D ]}t| |}t| |d|}q|S  jdkrt|S  j}|d dkrt|dks|d jdkrt|d jdks| |d S z	|d jd }	W n ttfy   Y n(w |	dkrz	|d jd }	W n	 ty   Y nw |	jdv rt
t||  gS |d }
z|
j}W n ty   g }Y nw |d dkr:|
dks2d|v s2d|v r:t||  }nt||  }t
|gS )z
    Basically to process ``atom`` nodes. The parser sometimes doesn't
    generate the node (because it has just one child). In that case an atom
    might be a name or a literal as well.
    r   r   r   rV   c                 3   s.    | ]}|j  j   ko|jk n  V  qd S r\   )rk   rl   )r>   rP   r   r=   rA   r`   $  s   , zinfer_atom.<locals>.<genexpr>Npositionr   )FalseTrueNoneyieldFzCannot infer the keyword %sr   r   rC   r1   r   r   r<   testlist_comp:   )comp_forsync_comp_for{}r7   )rF   re   r   search_ancestorrm   get_test_nodesrk   _is_annotation_namer   rY   r   r   r   r   rb   Literalcompiled_subprocesssafe_literal_evalcreate_simple_objectr   rj   r   get_string_value_setro   r   
IndexErrorAttributeErrorr   comprehension_from_atomDictLiteralValuer   )rM   r   statestmtr   r   r   r   cr   
array_nodearray_node_c	new_valuer=   r   rA   r     sz   










"

r   c                 C   s~   t | j|.}|r-|d ur t| ||}|r |W  d    S t| ||W  d    S W d    tS 1 s8w   Y  tS r\   )r   execution_allowedrF   r   "find_type_from_comment_hint_assign_infer_expr_stmtr   )rM   r   	seek_nameallowedpep0484_valuesr=   r=   rA   r   n  s   

		r   c              	      s  dd }t d|| | } ||r t |}t|t| d}||\}|dvo5|jdk}|s:|r|j	ddd	 j
}	 j|	|jd
}
|ra fddtfdd|
D npt|}|j
dd |_
t|d}|dur|jdkrʈrt|r| }t |}t| |}|D ].}|jd j
| i} ||  |}t |
||}
W d   n1 sw   Y  q|
nt |
|t d S )aD  
    The starting point of the completion. A statement always owns a call
    list, which are the calls, that a statement does. In case multiple
    names are defined in the statement, `seek_name` returns the result for
    this name.

    expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) |
                     ('=' (yield_expr|testlist_star_expr))*)
    annassign: ':' test ['=' test]
    augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' |
                '<<=' | '>>=' | '**=' | '//=')

    :param stmt: A `tree.ExprStmt`.
    c                 S   s`   | j d }|jdvrdS |j d }|jdkst|j dkrdS |j d }|j d dk|j d fS )	Nr   )r   r   )FNr   r<   r   r   rC   )rj   re   ro   )r   r   r   r   r=   r=   rA   check_setitem  s   



z'_infer_expr_stmt.<locals>.check_setitemzinfer_expr_stmt %s (%s)N)=Nr   T)include_setitemr   r   c                    s:   t  }| jdkrt| |S | jdkrt| |S | S )Ndictrq   )ContextualizedSubscriptListNode
array_typer   r   )r@   r   )rM   subscriptlistr   r=   rA   to_mod  s   


z _infer_expr_stmt.<locals>.to_modc                 3   s    | ]} |V  qd S r\   r=   )r>   r@   )r   r=   rA   r`         z#_infer_expr_stmt.<locals>.<genexpr>r   rW   rC   zinfer_expr_stmt result %s)r   rp   get_rhsr   r   check_tuple_assignmentsnextyield_operatorsre   get_defined_namesrY   r   rk   r   rs   r   r   r   for_stmt_defines_one_nameget_testlistr   rq   rn   iteraterj   rt   r   )rM   r   r   r   rhsrP   first_operator
is_setitemis_annassignr   left_valuesr   rW   r   cnordered
lazy_valuedcttr=   )rM   r   r   r   rA   r   |  sH   






r   c                 C   s   t |j}| t|}|D ]K}t|}|jdkr$ddd |jD }|dv rOtdd |D }|dhkr@|dkr?| |}q|d	hkrN|dkrN| |}qt| ||| |}qt	d
| |S )Ncomp_op c                 s   s    | ]}|j V  qd S r\   rX   r>   r   r=   r=   rA   r`     s    z infer_or_test.<locals>.<genexpr>)andorc                 s       | ]}|  V  qd S r\   )
py__bool__)r>   leftr=   r=   rA   r`     r   Tr  Fzinfer_or_test types %s)
iterrj   r   r   re   joinsetr   r   rp   )rM   or_testiteratortypesr   r   
left_boolsr=   r=   rA   r     s*   





r   c                 c   sd    | D ],}|dkrt |r| V  q|dkr,| }|du r" dS t|j| V  q|V  qdS )z6
    Calculates `+`, `-`, `~` and `not` prefixes.
    r2   notN)r   negater  r   r   rF   )r   r   rY   br=   r=   rA   r     s   
r   c                 C   sF   t }|D ]}t|rt| |jj}|| O }q|t|gO }q|S r\   )r   r   r   r   r   string_namer   r   )rF   r   
new_resultr   clsr=   r=   rA   _literals_to_types  s   r   c                    sh    j |rs|p
tptB }t|S t|t dkr%t|B S t fdd|D S )N   c                 3   s*    | ]}D ]}t  ||V  qqd S r\   )_infer_comparison_part)r>   r  r   rM   r   right_valuesr   r=   rA   r`     s    z$_infer_comparison.<locals>.<genexpr>)rF   r   r   ro   r   	from_sets)rM   r  r   r$  r   r=   r#  rA   r     s   
r   c                 C   s   t | ddd}|d u rdS |jdv r+|j}|d ur)|j| j  ko&|jk S   S dS |jdkrS|j}t|dkrS|d jdkrS|d j| j  koP|d jk S   S dS )Nparamfuncdefr   F)r&  r'  rC   r   )r   r   re   r   rk   rl   rj   ro   )r   ancestorannr   r=   r=   rA   r     s   

&r   c                 C   
   | j dkS )Nrq   r   rX   r=   r=   rA   _is_list(     
r,  c                 C   r*  )Ntupler+  rX   r=   r=   rA   	_is_tuple,  r-  r/  c                 C   s   t | t|S r\   )r   r   str)rF   bool_r=   r=   rA   _bool_to_value0  s   r2  c              	   C   sv   t | tjsd S g }|  D ]*}t |ts d S |j}|jdkr# d S z
|t|j	 W q t
y8   Y  d S w |S )Nr   )rb   r   r   
py__iter__r
   datare   appendintrY   
ValueError)rY   numbersr  r   r=   r=   rA   _get_tuple_ints4  s   

r9  c                 C   s  t |}t |}t|tr|}nt|j}|dkr8t|tjs#t|r(t|gS t|tjs2t|r7t|gS n|dkrj|r@|sHt|rNt|rN|||S t	|rVt	|s^t
|rit
|ritt| ||fgS n~|dkry|rx|rx|||S no|dkrt|gS |tv r| r| r|||}|r|S n=|dv rt| }	|	||}
|dv |
krtt| |
gS t|trt|}|d urtjj| | jjt|}tt| |gS tt| dt| dgS |d	v rtS d
d }|dv r||kr||s||sd}t|d||||f  | s| rtS t| }||}|r0||}|r0|S |sFt| }||}||}|rF|S t||g}td|| |S )Nr3   r1   r2   r6   )isz!===zis not)r:  r;  TF)inznot inc                 S   s   t | to
| jjdv S )z4Checks if a Jedi object is either a float or an int.)r6  float)rb   r   r   r  )objr=   r=   rA   check  s   

z%_infer_comparison_part.<locals>.check)r1   r2   z7TypeError: unsupported operand type(s) for +: %s and %sztype-error-operationz Used operator %s resulting in %s) r   rb   r0  rY   r   Sequencer   r   execute_operationr,  r/  MergedArrayr   is_compiledr2  r   r9  r   accessenvironmentversion_infor.  r   r   addis_classoperator_to_magic_methodr   r    reverse_operator_to_magic_methodr   rp   )rF   rM   r  r   r   l_is_numr_is_numstr_operatorr   	operationr1  rF  bool_resultr?  messagemethod_namemagic_methodsreverse_method_namer=   r=   rA   r"  E  s   



 









r"  c                 C   s  t }| j}|d urK| |jg }d}|D ].}|j}|jdkrF|jd jdkrFt	
||jk}	|	rFd}|t||jd jd  O }q|rK|S g }
|jddd}|d u r|j}|jdkr||}| rkt S t| }||j}tdd	 |D S |jd
vr||}t||S |j}|dkrt|||}
|
r|
S |dkrt|||}
|
r|
S |dv rz|j| |j }
W |
S  ty   t||jd }t| ||jjdkd}t||}t||}
Y |
S w |dkrt|||}
|
S |dkr"| |!|}|jjdkr|"d}|# }|$ % S |"d}|# S |d
v r/t&'||}
|
S |dv r;t(||}
|
S |dkrO| |) ) }|# }
|
S |dkrXt }
|
S |dkrat }
|
S |dkrmt ||}
|
S t*d| )NFr   rC   r   T)import_name_alwaysr   global_stmtc                 s   r  r\   )rn   )r>   r   r=   r=   rA   r`     r   z&tree_name_to_values.<locals>.<genexpr>)import_fromimport_namerW   	with_stmt)rW   r   r   r   
async_stmt)contextualized_nodeis_async
__aenter__	__enter__)r'  classdeftry_stmtr&  del_stmtr   zShould not happen. type: %s)+r   get_root_contextrE   get_used_namesrh   rY   rd   re   rj   r   get_parent_scoper   r   r   get_definitioncreate_context	is_moduler   get_filtersr   r%  r   find_type_from_comment_hint_for find_type_from_comment_hint_withrg   rL   r   r	   rn   r   r   r   r   get_test_node_from_namer   r   r   r   r   infer_import_apply_decoratorsget_previous_siblingr7  )rF   rM   	tree_namer   module_nodenamesfound_annotationr   r   correct_scoper  r   r   filterr   r  	for_typesrP   value_managersenter_methodscoro
exceptionsr=   r=   rA   tree_name_to_values  s   





)

 	






	



ry  c           	   	      s|  |j dkrt| j| |d nt| | t g }}t| r!|S t| D ]}t	j
d||dd t	 f | |jd }|jdd }|rWtd	|}||_t| ||}t|sw|jd
d}|dkrlt	d|| |W  d     S |t|g}t|st	d| |W  d     S W d   n1 sw   Y  t	j
d|dd q'||krt fdd|D S |S )z
    Returns the function, that should to be executed in the end.
    This is also the places where the decorators are processed.
    r^  )rH   rE   zdecorator: %s %sMAGENTA)colorrC   r<   r   r   F)include_prefixz	@runtime
zdecorator not found: %s on %sNz)not possible to resolve wrappers found %szdecorator end %sc                    s   g | ]}t | qS r=   r!   r  decoratee_valuer=   rA   r[   3  s    z%_apply_decorators.<locals>.<listcomp>)re   r   rF   r   r   r   r   reversedget_decoratorsr   rp   increase_indent_cmr   rj   r   
PythonNoderd   r   ro   get_coderK   r   r   ValuesArguments)	rM   r   initialvaluesdec
dec_valuestrailer_nodesr   coder=   r}  rA   rl    sH   

rl  c              	   C   s   d}|   D ]?\}}t| j|}||}t|trt  S d}||krAzt|}W n ty7   t Y   S w ||j	7 }||ks$|
 }q|S )z(
    Checks if tuples are assigned.
    Nr   )assignment_indexesr   rH   r   rb   slicer   r   StopIterationmaxrn   )r   r   r  indexr   r  iteratedr]   r=   r=   rA   r   7  s"   



r   c                   @   s   e Zd Zdd ZdS )r   c                 C   s   t | j| jS r\   )r   rM   r   )selfr=   r=   rA   rn   S  s   z%ContextualizedSubscriptListNode.inferN)__name__
__module____qualname__rn   r=   r=   r=   rA   r   R  s    r   c                 C   s   |dkrt t| dddgS |jdkr`|jd dks`g }|jD ](}|dkr.|s-|d q |jdkrCt|jdkrB||jd  q || q |dgd	t|  7 }t tj| g|R  gS |jd
krpt t| j| |gS | 	|S )z,
    Handles slices in subscript nodes.
    r   N	subscriptr   r   sliceopr<   rC   r   r   )
r   r   Slicere   rj   r5  ro   r   rF   r   )rM   r  r   elr=   r=   rA   r   W  s&   




r   r\   )P__doc__rs   parso.pythonr   jedir   r   jedi.inference.base_valuer   r   r   r   r	   jedi.inference.lazy_valuer
   jedi.inferencer   r   r   r   r   jedi.inference.valuer   r   r   #jedi.inference.value.dynamic_arraysr   r   r   jedi.inference.helpersr   r   r   r   r   jedi.inference.compiled.accessr   jedi.inference.cacher   !jedi.inference.gradual.stub_valuer   jedi.inference.gradualr   jedi.inference.namesr   jedi.inference.contextr    jedi.inference.value.decoratorr"   jedi.pluginsr#   rI  itemsrJ  rU   r   ru   r   increase_indentrc   r   r   r   r   r   r   r   r   r   r,  r/  r2  r9  r"  decoratery  rl  r   r   r   r=   r=   r=   rA   <module>   s    !H
NUM
]
b
1