a
    lc                     @   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=   V/var/www/html/django/DPS/env/lib/python3.9/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}zZ|j|  d7  < d}| jd u rD|  |ju rD|d9 }|j| |krdtd| tW S W n t	y   d|j|< Y n0  | g|R i |S )N   i,  d   z+In value %s there were too many inferences.)
	tree_nodeinference_stateZinferred_element_countsparent_context	get_valueZbuiltins_moduler   warningr   KeyError)contextargskwargsnrF   maximumfuncr=   rA   wrapper?   s    

z$_limit_value_infers.<locals>.wrapperr=   )rQ   rR   r=   rP   rA   _limit_value_infers6   s    	rS   c              	      s  t | trt| |S |}|d urD|j}|jdv r2qDt|rd }qDq| 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rzt|t|	 dkrtd	| i g} qt|}
g }|	D ]J}t|
}t|D ]*\}}| ||< t|g|| |j< q@||7 }q,q|D ]}|	||j< q~qt|dkrt}|D ]B}| || |t| |O }W d    n1 s0    Y  q|S t| |S n|rt| |S t| |S d S )
N)if_stmtfor_stmtrT   rC   c                 S   s   g | ]
}|j qS r=   value)r>   er=   r=   rA   
<listcomp>t       zinfer_node.<locals>.<listcomp>c                 3   s   | ]}|j  v V  qd S NrV   )r>   iZstr_element_namesr=   rA   	<genexpr>u   rZ   zinfer_node.<locals>.<genexpr>   z,Too many options for if branch inference %s.)
isinstancer    _infer_nodeparenttyper   Zis_scopepredefined_namesgetrF   Zis_analysischildren	start_posend_posr   anyinferlenr   dbglist	enumeratecopyr   rW   r   predefine_names_infer_node_if_inferred)rK   elementrT   predefined_if_name_dictZif_stmt_testZ
name_dictsZif_namesZelement_namesZif_nameZdefinitionsZoriginal_name_dictsZ
definitionZnew_name_dictsr\   Z	name_dictresultr=   r]   rA   
infer_nodeW   sd    




2
ru   c                 C   s<   |}|dur2|j }| j|}|durt| |S qt| |S )zA
    TODO This function is temporary: Merge with infer_node.
    N)rb   rd   re   ra   _infer_node_cached)rK   rr   rb   rs   r=   r=   rA   rq      s    rq   )defaultc                 C   s
   t | |S r[   )ra   )rK   rr   r=   r=   rA   rv      s    rv   c                 C   s  t d||j|  | j}|j}|dv r0t| |S |dkrJtt| |gS |dkr\t	| |S |dv r|j
d }|j
dd  }d}|jd	kr|jd
krd}|d}| |}t|D ]B\}}	|	dkr| ||d  }
t| ||	|
}  qt| ||	}q|r|  S |S |dv r.tt|| |gS |dv rl| |j
d }|j
d d D ]}t||}qV|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r8| |j
d S |dkrXt| |j
d  S |dkrt|j
r|j
d jdkr|j
d j
d }| |d  }| S t!S |dkr| |j
d S t"| |S d S )Nzinfer_node %s@%s in %s)namenumberstringatomstringskeywordfstringlambdef	expr_stmt)power	atom_exprr   rC   Fr}   awaitTr7   )Ztestlist_star_exprZtestlist)Znot_testfactortestoperatorz...zunhandled operator %s in %s EllipsisZdotted_namer<   )name_contextZ
eval_input	annassignZ
yield_exprZ	yield_arg__iter__namedexpr_test)#r   rl   rg   rF   rc   
infer_atomr   r   from_contextinfer_expr_stmtrf   rW   popru   rn   _infer_comparisoninfer_trailerpy__await__py__stop_iteration_returnsr   SequenceLiteralValueinfer_factorrb   AssertionErrorreprr   builtin_from_namepy__getattribute__r   infer_annotationexecute_annotationrk   execute_with_valuesr   infer_or_test)rK   rr   rF   typZfirst_childrf   Z	had_await	value_setr\   trailerrightr   originZ	next_name
generatorsr=   r=   rA   ra      s    















ra   c                 C   s   |j d d \}}|dkrd }|dkrJ|j \}}}|t| |t| |S td|| |dkrn|j| |dS |dksJ d| t| j	| ||}|
|S d S )	Nr<   )[zinfer_trailer: %s in %s.)r   Zname_or_str(ztrailer_op is actually %s)rf   Zget_item_infer_subscript_listr   r   rl   r   r   ZTreeArgumentsrF   execute)rK   Zatom_valuesr   Z
trailer_opnode_rL   r=   r=   rA   r     s$    r   c              	      s  | j } jdkr|t dddp" }|jdkrNt fdd| D s\ }n|jdkr\ }|j}t rnd}| j |dS  jd	krƈ j	d
v rt
t| j	gS  j	dkrtS dsJ d  nt tjr|j j	}t
t||gS  jdkr@t|  jd } jdd D ]}t| |}t| |d|}q|S  jdkrVt|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 nT0 |	dkrz|d jd }	W n ty   Y n0 |	jdv r(t
t||  gS |d }
z
|
j}W n tyR   g }Y n0 |d dkr|
dksd|v sd|v rt||  }nt||  }t
|gS d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.
    rx   r   r   rT   c                 3   s,   | ]$}|j  j   ko|jk n  V  qd S r[   )rg   rh   )r>   rN   r{   r=   rA   r^   $  rZ   zinfer_atom.<locals>.<genexpr>Npositionr}   )FalseTrueNoneyieldFzCannot infer the keyword %sr|   r   rC   r1   r~   r   r<   Ztestlist_comp:   )comp_forsync_comp_for{}r7   )rF   rc   r   search_ancestorri   Zget_test_nodesrg   _is_annotation_namer   rW   r   r   r   r   r`   LiteralZcompiled_subprocessZsafe_literal_evalcreate_simple_objectr   rf   r   Zget_string_value_setrk   ru   
IndexErrorAttributeErrorr   Zcomprehension_from_atomZDictLiteralValuer   )rK   r{   statestmtr   rz   r   r   cr   Z
array_nodeZarray_node_c	new_valuer=   r   rA   r     sx    










"r   c                 C   s|   t | j|Z}|rZ|d ur@t| ||}|r@|W  d    S t| ||W  d    S W d    n1 sn0    Y  tS r[   )r   Zexecution_allowedrF   r   Z"find_type_from_comment_hint_assign_infer_expr_stmtr   )rK   r   	seek_nameallowedZpep0484_valuesr=   r=   rA   r   n  s    8r   c              	      s  dd }t d|| | } ||r@t |}t|t| d}||\}|dvoj|jdk}|sv|r|j	ddd	 j
}	 j|	|jd
}
|rć fddtfdd|
D nt|}|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 s0    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   )FNrx   r<   r   r   rC   )rf   rc   rk   )r   r   rx   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r6t| |S | S )Ndictrm   )ContextualizedSubscriptListNode
array_typer   r   )r@   r   )rK   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^     rZ   z#_infer_expr_stmt.<locals>.<genexpr>r   rU   rC   zinfer_expr_stmt result %s)r   rl   Zget_rhsru   r   check_tuple_assignmentsnextZyield_operatorsrc   Zget_defined_namesrW   r   rg   r   ro   r   r   r   Zfor_stmt_defines_one_nameZget_testlistr   rm   rj   iteraterf   rp   r   )rK   r   r   r   rhsrN   Zfirst_operatorZ
is_setitemZis_annassignrx   left_valuesr   rU   r   cnZordered
lazy_valuedcttr=   )rK   r   r   r   rA   r   |  sD    







2r   c                 C   s   t |j}| t|}|D ]}t|}|jdkrHddd |jD }|dv rtdd |D }|dhkr|dkr| |}q|d	hkr|dkr| |}qt| ||| |}qt	d
| |S )NZcomp_op c                 s   s   | ]}|j V  qd S r[   rV   r>   r   r=   r=   rA   r^     rZ   z infer_or_test.<locals>.<genexpr>)andorc                 s   s   | ]}|  V  qd S r[   )
py__bool__)r>   leftr=   r=   rA   r^     rZ   Tr   Fzinfer_or_test types %s)
iterrf   ru   r   rc   joinsetr   r   rl   )rK   Zor_testiteratortypesr   r   Z
left_boolsr=   r=   rA   r     s&    



r   c                 c   sb   | D ]X}|dkr$t |r\| V  q|dkrV| }|du rB dS t|j| V  q|V  qdS )z6
    Calculates `+`, `-`, `~` and `not` prefixes.
    r2   notN)r   negater   r   r   rF   )r   r   rW   br=   r=   rA   r     s    r   c                 C   sF   t }|D ]8}t|r2t| |jj}|| O }q|t|gO }q|S r[   )r   r   r   r   rx   string_namer   r   )rF   rt   Z
new_resultr   clsr=   r=   rA   _literals_to_types  s    r   c                    sl    j |rs(|ptptB }t|S t|t dkrJt|B S t fdd|D S d S )N   c                 3   s(   | ] }D ]}t  ||V  q
qd S r[   )_infer_comparison_part)r>   r   r   rK   r   right_valuesr   r=   rA   r^     s   z$_infer_comparison.<locals>.<genexpr>)rF   r   r   rk   r   	from_sets)rK   r   r   r   rt   r=   r   rA   r     s    
r   c                 C   s   t | ddd}|d u rdS |jdv rT|j}|d ur|j| j  koL|jk S   S nP|jdkr|j}t|dkr|d jdkr|d j| j  ko|d jk S   S dS )Nparamfuncdefr   F)r   r   rC   r   )r   r   rc   r   rg   rh   rf   rk   )rx   Zancestorannr   r=   r=   rA   r     s    
 
&r   c                 C   s
   | j dkS )Nrm   r   rV   r=   r=   rA   _is_list(  s    r   c                 C   s
   | j dkS )Ntupler   rV   r=   r=   rA   	_is_tuple,  s    r   c                 C   s   t | t|S r[   )r   r   str)rF   bool_r=   r=   rA   _bool_to_value0  s    r   c              	   C   sx   t | tjsd S g }|  D ]V}t |ts0 d S |j}|jdkrF d S z|t|j	 W q t
yp   Y  d S 0 q|S )Nry   )r`   r   r   Z
py__iter__r
   datarc   appendintrW   
ValueError)rW   numbersr   r   r=   r=   rA   _get_tuple_ints4  s    

r   c                 C   s  t |}t |}t|tr |}n
t|j}|dkrrt|tjsFt|rPt|gS t|tjsdt|rnt|gS nv|dkr|r|st|rt|r|||S t	|rt	|st
|rt
|rtt| ||fgS n|dkr|r|r|||S n|dkr
t|gS |tv r| r@| r@|||}|r|S n|dv rzt| }	|	||}
|dv |
krzt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 r4||kr4||s4||s4d}t|d||||f  | sH| rLtS t| }||}|rx||}|rx|S |st| }||}||}|r|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.)r   float)r`   r   rx   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   r`   r   rW   r   Sequencer   r   Zexecute_operationr   r   ZMergedArrayr   Zis_compiledr   r   r   r   accessenvironmentversion_infor   r   r   addZis_classoperator_to_magic_methodr   r    reverse_operator_to_magic_methodr   rl   )rF   rK   r   r   r   Zl_is_numZr_is_numZstr_operatorrt   Z	operationr   r  Zbool_resultr  messagemethod_nameZmagic_methodsZreverse_method_namer=   r=   rA   r   E  s    


 













r   c                 C   s  t }| j}|d ur| |jg }d}|D ]\}|j}|jdkr0|jd jdkr0t	
||jk}	|	r0d}|t||jd jd  O }q0|r|S g }
|jddd}|d u r&|j}|jdkr||}| rt S t| }||j}tdd	 |D S |jd
vr&||}t||S |j}|dkrNt|||}
|
rN|
S |dkrpt|||}
|
rp|
S |dv rz|j| |j }
W nR ty   t||jd }t| ||jjdkd}t||}t||}
Y n0 n|dkrt|||}
n|dkrV| |!|}|jjdkrD|"d}|# }|$ % S |"d}|# S |d
v rnt&'||}
n~|dv rt(||}
nh|dkr| |) ) }|# }
nB|dkrt }
n2|dkrt }
n"|dkrt ||}
nt*d| |
S )NFr   rC   r   T)Zimport_name_alwaysr   Zglobal_stmtc                 s   s   | ]}|  V  qd S r[   )rj   )r>   rx   r=   r=   rA   r^     rZ   z&tree_name_to_values.<locals>.<genexpr>)Zimport_fromimport_namerU   Z	with_stmt)rU   r   r   r   Z
async_stmt)Zcontextualized_nodeis_async
__aenter__	__enter__)r   classdefZtry_stmtr   Zdel_stmtr   zShould not happen. type: %s)+r   Zget_root_contextrE   Zget_used_namesre   rW   rb   rc   rf   r   Zget_parent_scoper   r   r   Zget_definitionZcreate_contextZ	is_moduler   Zget_filtersr   r   r   Zfind_type_from_comment_hint_forZ find_type_from_comment_hint_withrd   rJ   r   r	   rj   r   r   r   ru   Zget_test_node_from_namer   r   r   r   r   Zinfer_import_apply_decoratorsZget_previous_siblingr   )rF   rK   Z	tree_namer   Zmodule_nodenamesZfound_annotationrx   r   Zcorrect_scoper   r   r   filterr   r   Z	for_typesrN   Zvalue_managersZenter_methodscoro
exceptionsr=   r=   rA   tree_name_to_values  s    




















r  c           	   	      s  |j dkrt| j| |d nt| | t g }}t| rB|S t| D ]}t	j
d||dd t	  | |jd }|jdd }|rtd	|}||_t| ||}t|s|jd
d}|dkrt	d|| |W  d     S |t|g}t|s.t	d| |W  d     S W d   n1 sD0    Y  t	j
d|dd qN||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  )rG   rE   zdecorator: %s %sZMAGENTA)colorrC   r<   r   r   F)Z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   Zdecoratee_valuer=   rA   rY   3  rZ   z%_apply_decorators.<locals>.<listcomp>)rc   r   rF   r   r   r   r   reversedZget_decoratorsr   rl   Zincrease_indent_cmru   rf   r   Z
PythonNoderb   r   rk   get_coderI   r   r   ZValuesArguments)	rK   r   initialvaluesdecZ
dec_valuesZtrailer_nodesr   coder=   r  rA   r    s@    


6
r  c              	   C   s   d}|   D ]x\}}t| j|}||}t|tr<t  S d}||kr|zt|}W n tyn   t Y   S 0 ||j	7 }q@|
 }q|S )z(
    Checks if tuples are assigned.
    Nr   )Zassignment_indexesr   rG   r   r`   slicer   r   StopIterationmaxrj   )rx   r   r   indexr   r   Z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   rK   r   )selfr=   r=   rA   rj   S  s    z%ContextualizedSubscriptListNode.inferN)__name__
__module____qualname__rj   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sg }|jD ]P}|dkr\|s|d q@|jdkrt|jdkr||jd  q@|| q@|dgd	t|  7 }t tj| g|R  gS |jd
krt t| j| |gS | 	|S )z,
    Handles slices in subscript nodes.
    r   NZ	subscriptr   r   Zsliceopr<   rC   r   r   )
r   r   Slicerc   rf   r   rk   r   rF   ru   )rK   r#  rt   elr=   r=   rA   r   W  s"    


r   )N)N)P__doc__ro   Zparso.pythonr   Zjedir   r   Zjedi.inference.base_valuer   r   r   r   r	   Zjedi.inference.lazy_valuer
   Zjedi.inferencer   r   r   r   r   Zjedi.inference.valuer   r   r   Z#jedi.inference.value.dynamic_arraysr   r   r   Zjedi.inference.helpersr   r   r   r   r   Zjedi.inference.compiled.accessr   Zjedi.inference.cacher   Z!jedi.inference.gradual.stub_valuer   Zjedi.inference.gradualr   Zjedi.inference.namesr   Zjedi.inference.contextr    Zjedi.inference.value.decoratorr"   Zjedi.pluginsr#   r	  itemsr
  rS   ru   rq   rv   Zincrease_indentra   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Zdecorater  r  r   r   r   r=   r=   r=   rA   <module>   s   !H
NUM
]
b
1