403Webshell
Server IP : 35.80.110.71  /  Your IP : 216.73.216.221
Web Server : Apache/2.4.58 (Ubuntu)
System : Linux ip-172-31-21-44 6.17.0-1019-aws #19~24.04.1-Ubuntu SMP Tue Jun 23 18:53:06 UTC 2026 x86_64
User : ubuntu ( 1000)
PHP Version : 8.3.31
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /usr/lib/python3/dist-packages/jedi/inference/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /usr/lib/python3/dist-packages/jedi/inference/__pycache__/syntax_tree.cpython-312.pyc
�

Še����&�dZddlZddlZddlmZddlmZddlmZddlm	Z	m
Z
mZmZm
Z
ddlmZddlmZdd	lmZdd
lmZddlmZddlmZdd
lmZmZddlmZddlmZmZddlmZddlmZm Z m!Z!m"Z"m#Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddddddd d!d"d#d$d%d&d'�
Z4e4jk�D��cic]\}}|d(|d)dz��c}}Z6d*�Z7d+�Z8d,�Z9e'e
�-�d.��Z:ejve7d/���Z<d0�Z=d1�Z>e7dDd2��Z?ejvdDd3��Z@d4�ZAed5��ZBd6�ZCd7�ZDd8�ZEd9�ZFd:�ZGd;�ZHd<�ZId=�ZJe3j��d>��ZLe'�d?��ZMd@�ZNGdA�dBe�ZOdC�ZPycc}}w)Ez&
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>>�&�|�^�__r�c����fd�}|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�t��|j}|j}	|j|xxdz
cc<d}|j�!|j	�|j
ur|dz}|j||kDrt
jd|�tS	�|g|��i|��S#t$rd|j|<Y�&wxYw)N�i,�dz+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�nrB�maximum�funcs      ��</usr/lib/python3/dist-packages/jedi/inference/syntax_tree.py�wrapperz$_limit_value_infers.<locals>.wrapper@s��������!�1�1��	;��3�3�A�6�!�;�6��G��%�%�-��)�)�+��/N�/N�N�
�3����6�6�q�9�G�C��
�
�K�Q�O� � �D�
�G�-�d�-�f�-�-���	;�9:�O�3�3�A�6�	;�s�A3B�B7�6B7�)rNrPs` rO�_limit_value_infersrR7s���.�*�N�c����t|t�rt||�S|}|�6|j}|jdvrntj|�rd}n|��6|jj|�}|���|�r�|jdk(�r�|jj�r�|jd}ig}|j|jkD�r't|�}t|�}|D�cgc]}|j��c}�t!�fd�|D��r�|D]�}	|jj#||	�}
t%|
�dkDr�t%|�t%|
�zdkDrt'j(d|�ig}nt+|�}g}|
D]T}t+|�}
t-|
�D]4\}}|j/�|
|<t1|g�|
||	j<�6||
z
}�V��|D]}|
||	j<���t%|�dkDr9t2}|D],}|j5||�5|t||�z}ddd��.|St7||�S|rt||�St7||�Scc}w#1swY�exYw)N)�if_stmt�for_stmtrUr?c3�:�K�|]}|j�v���y�w�N��value)�.0�i�str_element_namess  �rO�	<genexpr>zinfer_node.<locals>.<genexpr>vs�����B�A�1�7�7�/�/�B�s��z,Too many options for if branch inference %s.)�
isinstancer!�_infer_node�parent�typer�is_scope�predefined_names�getrB�is_analysis�children�	start_pos�end_posrrZ�any�infer�lenr�dbg�list�	enumerate�copyrr�predefine_names�_infer_node_if_inferred)rI�elementrU�predefined_if_name_dict�if_stmt_test�
name_dicts�if_names�
element_names�e�if_name�definitions�original_name_dicts�
definition�new_name_dictsr\�	name_dict�resultr]s                 @rO�
infer_noder�Xs�����'�>�*��7�G�,�,��G�
�
��.�.���<�<�2�2��� � ��)��G��
�
�&�6�6�:�:�7�C���&�7����	�)�g�.E�.E�.Q�.Q��'�'��*���T�
�
���|�3�3�3�)��6�H�-�g�6�M�2?� @�Q���� @���B��B�B�'�C�G�")�"9�"9�"?�"?���"Q�K��;�'�!�+��z�?�S��-=�=��B�!�I�I�&T�V]�^�+-��J�!�.2�:�.>�+�%'�
�*5�9�J�-1�2E�-F�N�09�.�0I�Z���9�4=�N�N�4D��q� 1�CK�Z�L�CY��q� 1�'�-�-� @�Z�'�.�8�J�
9�*4�C�I�7B�I�g�m�m�4�C�1C�4�z�?�Q���F�'�
<�	��,�,�W�i�@�<��k�'�7�;�;�F�<�<�
<��M�*�7�G�<�<�"��w��0�0�*�7�G�<�<��Q!A�><�<�s�&I �I%�%I.	c��|}|�8|j}|jj|�}|�t||�S|��8t	||�S)zA
    TODO This function is temporary: Merge with infer_node.
    )rbrerfra�_infer_node_cached)rIrtrbrus    rOrsrs�sY���F�
�
�����")�":�":�">�">�v�"F��"�.��w��0�0�	�
�
�g�w�/�/rS)�defaultc��t||�SrX)ra)rIrts  rOr�r��s���w��(�(rSc��tjd||j|�|j}|j}|dvrt||�S|dk(r t
tj||�g�S|dk(rt||�S|dvr�|jd}|jdd}d}|jd	k(r"|jd
k(rd}|jd�}|j|�}t|�D]>\}}	|	dk(r'|j||dz�}
t|||	|
�}nt!|||	�}�@|r|j#�j%�S|S|d
vr!t
t'j(|||�g�S|dvr@|j|jd�}|jddD]}t+||�}�|S|dk(r=|j|jd�|j|jd�zS|dk(r`|jdk7r1|j,}t/dt1|j��d|�d���t
t3j4|d�g�S|dk(rEt||jd�}|jddd�D]}
|j7|
|��}�|S|dk(r|j|jd�S|dk(r1t9j:||jd�j=�S|dk(r�t?|j�rv|jdjdk(rZ|jdjd}|j|�j7d�jA�}|j%�StBS|dk(r|j|jd�StE||�S) Nzinfer_node %s@%s in %s)�name�number�string�atom�strings�keyword�fstring�lambdef�	expr_stmt)�power�	atom_exprrr?Fr��awaitTr7)�testlist_star_expr�testlist)�not_test�factor����test�operatorz...zunhandled operator z in � �Ellipsis�dotted_namer<)�name_context�
eval_input�	annassign�
yield_expr�	yield_arg�__iter__�namedexpr_test)#rrnrirBrc�
infer_atomrr�from_context�infer_expr_stmtrhrZ�popr�rp�_infer_comparison�
infer_trailer�py__await__�py__stop_iteration_returnsr�SequenceLiteralValue�infer_factorrb�AssertionError�reprr�builtin_from_name�py__getattribute__r�infer_annotation�execute_annotationrm�execute_with_valuesr�
infer_or_test)rIrtrB�typ�first_childrh�	had_await�	value_setr\�trailer�rightr��origin�	next_name�
generatorss               rOrara�s���
�I�I�&���1B�1B�G�L��-�-�O�
�,�,�C�
�S�S��'�7�+�+�	�	�	���3�3�G�W�E�F�G�G�	��	��w��0�0�	�&�	&��&�&�q�)���#�#�A�B�'���	����y�(�[�->�->�'�-I��I�"�,�,�q�/�K��&�&�{�3�	�%�h�/�
	C�L�Q���$���*�*�8�A��E�?�;��-�����	�	��%�g�y�'�B�I�
	C���(�(�*�E�E�G�G���	�3�	3���6�6���QX�Y�Z�[�[�	�&�	&��&�&�w�'7�'7��';�<�	��(�(��"�-�	:�H�$�Y��9�I�	:���	����"�"�7�#3�#3�A�#6�7��$�$�W�%5�%5�b�%9�:�;�	<�	�
�	��=�=�E�!��^�^�F� �4��
�
�CV�X^�!_�`�`���3�3�O�Z�P�Q�R�R�	�
�	��w��(8�(8��(;�<�	� �)�)�!�$�Q�$�/�	V�I�!�4�4�Y�W�4�U�I�	V���	��	��!�!�'�"2�"2�1�"5�6�6�	��	��*�*�7�G�4D�4D�Q�4G�H�
�
�
!�	"�	��	��w��� �W�%5�%5�a�%8�%=�%=��%L��&�&�q�)�2�2�1�5�G� �+�+�G�4�#�#�J�/�0C�0C�0E�
��8�8�:�:���	� �	 ��!�!�'�"2�"2�1�"5�6�6��W�g�.�.rSc��|jdd\}}|dk(rd}|dk(r6|j\}}}|jt||�t||��St	j
d||�|dk(r|j
||��S|dk(s
Jd|z��tj|j|||�}|j|�S)	Nr<�)�[zinfer_trailer: %s in %s�.)r��name_or_str�(ztrailer_op is actually %s)rh�get_item�_infer_subscript_listrrrnr�r�
TreeArgumentsrB�execute)rI�atom_valuesr��
trailer_op�node�_rJs       rOr�r�s����'�'���+��J���s�{����S��%�.�.��
�D�!��#�#�!�'�4�0��w��0�
�	
�
	�	�	�+�W�k�B�����1�1�$� �2��
�
��$�N�&A�J�&N�N�$��*�*�7�+B�+B�G�T�SZ�[�D��&�&�t�,�,rSc�~��|j}�jdk(r�tj�ddd�xs�}|jdk(r%t	�fd�|j�D��s�}n|jdk(r�}|j}t��rd}|j�|��S�jdk(rW�jd	vr*ttj|�j�g�S�jd
k(rtSJd�z��t�tj�rE|j j#�j�}ttj$||�g�S�jdk(rIt'|�j(d
�}�j(ddD]}t'||�}t+||d|�}�|S�jdk(rtj,|�S�j(}|d
dk(rOt/|�dk(sA|djdk(rt/|dj(�dkDs|j1|d�S	|dj(d}	|	dk(r	|dj(d}	|	jdvr!tt5j6||��g�S|d}
	|
j(}|d
dk(r%|
dk(sd|vsd|vrt5j:||��}nt5j<||��}t|g�S#t2$rY��wxYw#t2t8f$rY��wxYw#t8$rg}Y��wxYw)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�rUc3�z�K�|]2}|j�jcxkxr|jknc���4y�wrX)rirj)r[rLr�s  �rOr^zinfer_atom.<locals>.<genexpr>%s*�����`�Q�q�{�{�d�n�n�@�q�y�y�@�@�`�s�8;N��positionr�)�False�True�None�yieldzCannot infer the keyword %sr�rr?r1r�r�r<�
testlist_comp�:�)�comp_for�
sync_comp_for�{�}r7)rBrcr�search_ancestorrk�get_test_nodesri�_is_annotation_namer�rZrrr�rr`�Literal�compiled_subprocess�safe_literal_eval�create_simple_objectr�rhr��get_string_value_setrmr��
IndexErrorr�comprehension_from_atom�AttributeError�DictLiteralValuer�)
rIr��state�stmtr�r�r�r��cr��
array_node�array_node_c�	new_values
 `           rOr�r�s4���
�#�#�E��y�y�F���#�#�D�+�y�)�L�T�PT���9�9�	�!��`�$�J]�J]�J_�`�`���
�Y�Y�)�
#��D��>�>���t�$��H��)�)�$��)�B�B�	
���i�	��:�:�2�2��X�7�7��t�z�z�J�K�L�L�
�Z�Z�7�
"���:�3�d�:�:�u�	�D�$�,�,�	'��*�*�<�<�T�Z�Z�H����6�6�u�f�E�F�G�G�	
���i�	��w��
�
�a�(8�9�	��m�m�A�B�'�	J�F��w��/�E�)�'�9�c�5�I�I�	J���	
���i�	��,�,�U�3�3��M�M���Q�4�3�;�s�1�v��{��1����o�5� ��1����/�!�3��%�%�a��d�+�+�	���t�}�}�Q�'�H��3��� ��t�}�}�Q�/�H��}�}� =�=���!A�!A��7�D�"�!���
�q�T�
�	�%�.�.�L�
�Q�4�3�;�J�#�-���1D�#�|�3� �1�1�%��$�G�I� �5�5�e�W�d�K�I����$�$��'"������N�+�	��	��&�	��L�	�s6�L�'L
�.L.�
	L�L�L+�*L+�.L<�;L<c��tj|j|�5}|r<|�$tj|||�}|r|cddd�St|||�cddd�S	ddd�tS#1swYtSxYwrX)r
�execution_allowedrBr�"find_type_from_comment_hint_assign�_infer_expr_stmtr)rIr��	seek_name�allowed�pep0484_valuess     rOr�r�os���	�	$�	$�W�%<�%<�d�	C�>�w���$��A�A�'�4�QZ�[��!�)�
>�>�$�G�T�9�=�>�>��>���>���s�A/�
A/�/A=c�|�����d�}tjd||�|j�}�j|��|rt	�|�}t|���t
|j�d�}||�\}�|dvxr|jdk(}|s|�r�|jd��dj}	�j|	|j�	�}
|r���fd
��t�fd�|
D����n&tj|�}|jdd|_
tj |d
�}|��|jd
k(rȉr�t#j$|�r�|j'�}
t)�|
�}t+|j-�j/|��}|D]e}|j0dj|j-�i}�j3||�5�j|�}t5�|
||�}
ddd��g|
�nt5�|
|���tjd���S#1swY��xYw)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��|jd}|jdvry|jd}|jdk7st|j�dk7ry|jd}|jddk(|jdfS)	Nr)r�r�)FNr�r<r�r�r?)rhrcrm)r�r�r�r�s    rO�
check_setitemz'_infer_expr_stmt.<locals>.check_setitem�s����M�M�!�$�	��>�>�!7�7���!�!�!�$���9�9���#�i�&8�&8�"9�Q�">���$�$�R�(������"�c�)�7�+;�+;�A�+>�>�>rSzinfer_expr_stmt %s (%s)N)�=Nr�T)�include_setitemrr�c���t���}|jdk(r
t|�|�S|jdk(r
t|�|�S|S)N�dictro)�ContextualizedSubscriptListNode�
array_typerr)�vr�rI�
subscriptlistr�s  ���rO�to_modz _infer_expr_stmt.<locals>.to_mod�sJ���3�G�]�K���<�<�6�)�+�A�y�!�<�<��\�\�V�+�+�A�y�!�<�<��rSc3�.�K�|]}�|����y�wrXrQ)r[r�rs  �rOr^z#_infer_expr_stmt.<locals>.<genexpr>�s����� @�q���� @�s�r�rVr?zinfer_expr_stmt result %s)rrn�get_rhsr�r �check_tuple_assignments�next�yield_operatorsrc�get_defined_namesrZr�rirrqrr�r�for_stmt_defines_one_name�get_testlistrrorl�iteraterhrrr�)rIr�r�r��rhsrL�first_operator�
is_setitem�is_annassignr��left_valuesr�rVr��cn�ordered�
lazy_value�dct�trrr�s`                  @@@rOr�r�}s!��� ?�
�I�I�'��y�9�
�,�,�.�C��"�"�3�'�I���w�	�2��+�A�y�9�	��$�.�.�0�$�7�N� -�d� 3��J�
�!��4�Z��9L�9L�PZ�9Z�L��z��%�%�d�%�;�A�>�D�D���0�0�����0�O���
�!� @�K� @�@�I��y�y��0�H�%�^�^�C�R�0�H�N��+�+�D�*�=�H��#��
�
��(C�	�$�>�>�x�H� �,�,�.��'���6���r�x�x�z�1�1�"�5�6��")�[�J�#�,�,�Q�/�5�5�z�7G�7G�7I�J�C� �0�0��3�?�[�#�.�.�s�3��&7���h�XY�&Z��[�[�[�
(�	�-�g�{�H�i�X�	�	�I�I�)�9�5���[�[�s� H2�2H;	c	��t|j�}|jt|��}|D]�}t|�}|jdk(r"djd�|jD��}|dvrOt
d�|D��}|dhk(r|dk(s�a|j|�}�s|dhk(s�z|dk7s��|j|�}��t||||j|��}��tjd	|�|S)
N�comp_opr�c3�4K�|]}|j���y�wrXrY)r[r�s  rOr^z infer_or_test.<locals>.<genexpr>�s����C�A����C�s�)�and�orc3�<K�|]}|j����y�wrX)�
py__bool__)r[�lefts  rOr^z infer_or_test.<locals>.<genexpr>�s����A�4�T�_�_�.�A���TrFzinfer_or_test types %s)
�iterrhr�rrc�join�setr�rrn)rI�or_test�iterator�typesr�r��
left_boolss       rOr�r��s����G�$�$�%�H����t�H�~�.�E��A���X����=�=�I�%��x�x�C��1B�1B�C�C�H��}�$��A�5�A�A�J��d�V�#��u�$�#�.�.�u�5�E���w�&��u�$�#�.�.�u�5�E�&�g�u�h�&-�&8�&8��&?�A�E�!A�$
�I�I�&��.��LrSc#��K�|D]g}|dk(rt|�s�|j����'|dk(r8|j�}|�ytj|j
|����d|���iy�w)z6
    Calculates `+`, `-`, `~` and `not` prefixes.
    r2�notN)r�negaterrr�rB)r�r�rZ�bs    rOr�r��sp����
�
���s�?�����l�l�n�$�
��
�� � �"�A��y���/�/��0E�0E�1�u�M�M��K�
�s�A0�AA0c���t}|D]Z}t|�r>tj||jj
�}||j
�z}�L|t|g�z}�\|SrX)rrrr�r��string_namer�r)rBr��
new_resultr��clss     rO�_literals_to_typesr-�sh���J��*���c�?��,�,�_�c�h�h�>R�>R�S�C��#�1�1�3�3�J��(�C�5�/�)�J�*��rSc��������j�t�t�r�}nt�j�}|r�s!|xst�xstz}t�|�S|dk(r=t
d�tj|��D��rtj|�f�St|�t��zdkDrt�|�z�Stj����fd�|D��S)Nr9c3�`K�|]&}|j�xs|j����(y�wrX)�is_class�is_compiled)r[rZs  rOr^z$_infer_comparison.<locals>.<genexpr>s0����%��	����/�E�-�-�/�/�%�s�,.�c	3�J�K�|]}�D]}t��|�|�����y�wrX)�_infer_comparison_part)r[rr�rIr��right_valuesr�s   ����rOr^z$_infer_comparison.<locals>.<genexpr>s;�����&��)�&��'�u�g�t�X�u�M�&�M�&�s� #)rBr`�strrZrr-�all�	itertools�chainr�	from_setsrm)rIrr�r5�operator_strr�r�s` ``  @rOr�r�s�����#�#�E��(�C� ����8�>�>�*���l��*��|�/H�y�I��!�%��0�0�	��	��%��_�_�[�,�?�%�"�
�!�!�;��"=�>�>�
�{��c�,�/�/�!�3�%�e�[�<�-G�H�H��%�%�&�'�&��
rSc��tj|ddd�}|�y|jdvr=|j}|�.|j|jcxkxr|j
kScSy|jdk(r`|j}t|�dkDrF|djdk(r4|dj|jcxkxr|dj
kScSy)N�param�funcdefr�F)r=r>r?r�)rr�rcrrirjrhrm)r��ancestor�annr�s    rOr�r�#s����#�#�D�'�9�k�J�H�����}�}�,�,��!�!���?��=�=�D�N�N�@�S�[�[�@�@�@�@�
�	
���+�	%������q�6�A�:�!�A�$�)�)�{�2��Q�4�>�>�T�^�^�B�a��d�l�l�B�B�B�B�rSc� �|jdk(S)Nro�r�rYs rO�_is_listrC3s�����v�%�%rSc� �|jdk(S)N�tuplerBrYs rO�	_is_tuplerF7s�����w�&�&rSc�@�tj|t|��SrX)rr�r6)rB�bool_s  rO�_bool_to_valuerI;s���%�%�o�s�5�z�B�BrSc�2�t|tj�syg}|j�D]V}t|t�sy|j
}|jdk7ry	|jt|j���X|S#t$rYywxYw)Nr�)r`rr��
py__iter__r�datarc�append�intrZ�
ValueError)rZ�numbersrr�s    rO�_get_tuple_intsrQ?s����e�X�:�:�;���G��&�&�(�	�
��*�m�4�������9�9�� ��	��N�N�3�t�z�z�?�+�	��N���	��	�s�!$B	�		B�Bc��t|�}t|�}t|t�r|}nt|j�}|dk(rct|tj
�st
|�rt|g�St|tj
�st
|��r�t|g�S|dk(r||r|st
|�rt
|�r|j||�St|�rt|�st|��rkt|��r_tt	j|||f�g�S|dk(r|�r5|�r2|j||�S|dk(rt|g�S|tvr�|j�r&|j�r|j||�}|r�|S|dvr/t|}	|	||�}
|dv|
k(rtt||
�g�St|t�rct!|�}|�Vt#j$j||j&j(t+|��}tt||�g�Stt|d�t|d�g�S|d	vrt,Sd
�}
|dvr4||k7r/|
|�s'|
|�sd}t/j0|d
||||fz�|j3�s|j3�rt,St4|}|j7|�}|r|j9|�}|r|S|s/t:|}|j7|�}|j9|�}|r|St||g�}t=j>d||�|S)Nr3r1r2r6)�isz!=�==zis not)rSrTTF)�inznot inc�V�t|t�xr|jjdvS)z4Checks if a Jedi object is either a float or an int.)rN�float)r`rr�r*)�objs rO�checkz%_infer_comparison_part.<locals>.check�s)���#�|�,�5��H�H� � �$4�4�	5rS)r1r2z7TypeError: unsupported operand type(s) for +: %s and %sztype-error-operationz Used operator %s resulting in %s) rr`r6rZr�Sequencerr�execute_operationrCrF�MergedArrayrr1rIrrQr�access�environment�version_inforErr�addr0�operator_to_magic_methodr�r�� reverse_operator_to_magic_methodrrn)rBrIrr�r��l_is_num�r_is_num�str_operatorr��	operationrHr_�bool_resultrY�message�method_name�
magic_methods�reverse_method_names                  rOr4r4Ps%�����H����H��(�C� ����8�>�>�*���s���d�H�-�-�.�)�D�/��T�F�#�#�
��x�0�0�
1�Y�u�5E��U�G�$�$�	��	���I�d�O�	�%�8H��)�)�%��>�>�
�d�^����9�T�?�y�QV�GW��X�1�1�/�D�%�=�Q�R�S�S�	��	����)�)�%��>�>�	��	������	�-�	-�����%�"3�"3�"5��+�+�E�<�@�F���
��;�;�0��>�	�!�$��.��!�L�0�U�:�#�^�O�U�%K�$L�M�M��$��,�.�u�5���+�"*�/�/�"F�"F�x�"P�'�3�3�@�@��l�+�#�K�$�^�O�[�%Q�$R�S�S���?�D�1��?�E�2�
��	�
�)�	)���5��z�!�h�(�&:��4�[�E�%�L�K�����W�4�h���e�}�,�	.��}�}��%�.�.�*���*�<�8�K��+�+�K�8�M���2�2�5�9����M��>�|�L���0�0�1D�E�
��2�2�4�8����M�
�t�U�m�
$�F�	�I�I�0�(�F�C��MrSc�"�t}|j�j}|��|j�j	|j
g�}d}|D]�}|j}|jdk(s�|jdjdk(s�<tj|�|jk(}	|	s�ad}|tj||jdjd�j�z}��|r|Sg}
|jdd��}|��|j}|jdk(rw|j|�}|j!�rtSt#|j%��}
|
j	|j
�}t'j(d�|D��S|jd	vr|j|�}t+||�S|j}|d
k(rtj,|||�}
|
r|
S|dk(rtj.|||�}
|
r|
S|dvr	|j0||j
}
|
S|dk(rt?|||�}
|
S|dk(r�|jA|jC|��}|jjdk(r?|jEd�}|jG�}|jI�jK�S|jEd�}|jG�S|d	vrtMjN||�}
|
S|dvrtQ||�}
|
S|dk(r?|jA|jS�jS��}|jG�}
|
S|dk(rt}
|
S|dk(rt}
|
S|dk(rtA||�}
|
StUd|z��#t2$rht5||jd
�}t7|j9�||jjdk(��}t;||�}t=||�}
Y|
SwxYw)NFr�r?r�T)�import_name_alwaysr��global_stmtc3�<K�|]}|j����y�wrX)rl)r[r�s  rOr^z&tree_name_to_values.<locals>.<genexpr>�s����%E�t�d�j�j�l�%E�r)�import_from�import_namerV�	with_stmt)rVr�r�r��
async_stmt)�contextualized_node�is_async�
__aenter__�	__enter__)r>�classdef�try_stmtr=�del_stmtr�zShould not happen. type: %s)+r�get_root_contextrA�get_used_namesrfrZrbrcrhr�get_parent_scoperr�r��get_definition�create_context�	is_moduler�get_filtersrr:r��find_type_from_comment_hint_for� find_type_from_comment_hint_withrerHrr
rlr rr�r��get_test_node_from_namer�r�r�r�r�infer_import�_apply_decorators�get_previous_siblingrO)rBrI�	tree_namer��module_node�names�found_annotationr�r��
correct_scoper#r�r��filterr�r�	for_typesrL�value_managers�
enter_methods�coro�
exceptionss                      rO�tree_name_to_valuesr��s&���I��*�*�,�6�6�K����*�*�,�0�0����"�E�� ���		+�D����I��~�~��,��1C�1C�A�1F�1K�1K�{�1Z� ,� =� =�d� C�w�GX�GX� X�
� �'+�$���!<�!<���!3�!3�A�!6�!?�!?��!B�"�(�(�*�+�I�		+�����E��#�#�t�T�#�R�D��|������9�9�
�%��&�&�y�1�A��{�{�}�!� ��!�-�-�/�*�F��J�J�y���/�E��%�%�%E�u�%E�E�E�
�Y�Y�<�
<��&�&�y�1�A��a��+�+�
�)�)�C�
�j���:�:�7�D�)�T����L�
�k���;�;�G�T�9�U����L�
�7�7�
	:��,�,�T�2�9�?�?�C�E�R�L�?

��	����y�9��<�L�;

��	� �+�+�D�,H�,H��,S�T���;�;���|�+�+�=�=�l�K�M� �4�4�6�D��#�#�%�@�@�B�B�&�9�9�+�F�
��0�0�2�2�	�.�	.��$�$�W�i�8��"�L�!

�'�	'�!�'�4�0���L�

�
�	��'�'�	�(F�(F�(H�(]�(]�(_�`�
��.�.�0���L�

������L�


�
�	���
�L�	

� �	 ��7�D�)���L��6��<�=�=��O�	:�#�G�T�]�]�1�-=�>�B�&����
�$&����)�)�\�9��I�
#�7�I�6�A�+�A�y�9�E�@�L�Q	:�s� N�A-P�
Pc	���|jdk(rt|j||��}ntj||�}t|g�x}}t
|�r|St|j��D�]D}tjd||d��tj�5|j|jd�}|jdd}|r*tjd	|�}||_t#|||�}t%|�s;|j'd
��}	|	dk7rtj(d
||�|cddd�cS|j+t-j.|g��}t%|�s#tj(d|�|cddd�cS	ddd�tjd|d����G||k7r#t|D�
cgc]}
t1|
|���c}
�S|S#1swY�NxYwcc}
w)z�
    Returns the function, that should to be executed in the end.
    This is also the places where the decorators are processed.
    rx)rDrAzdecorator: %s %s�MAGENTA)�colorr?r<r�r�F)�include_prefixz	@runtime
zdecorator not found: %s on %sNz)not possible to resolve wrappers found %szdecorator end %s)rcrrBrr�rr�reversed�get_decoratorsrrn�increase_indent_cmr�rhr�
PythonNoderbr�rm�get_coderGr�r�ValuesArgumentsr")rIr��decoratee_value�initial�values�dec�
dec_values�
trailer_nodesr��coder�s           rOr�r�s����y�y�J��$��#�#�"��
��(�4�4�W�d�C���� 1�2�2�G�f��w�'��
���+�+�-�.�?��
�	�	�$�c�6��C�
�
%�
%�
'�	� �+�+�C�L�L��O�<�J��L�L��2�.�M���/�/�)�]�C��!$���*�7�J��H�
��z�?��|�|�5�|�9���<�'��M�M�"A�3��M��!	�	�$ �'�'�	�(A�(A�6�(�(K�L�F��v�;��
�
�I�4�P��+	�	�&�'	�.	�	�	�$�f�I�>�3?�4�����G�1��1�o�6�G�H�H��M�5	�	��2Hs�$BG%�AG%�	G1�%G.	c�V�d}|j�D]|\}}t|j|�}|j|�}t	|t
�rtcSd}||kr!	t|�}||jz
}||kr�!|j�}�~|S#t$rtcYcSwxYw)z(
    Checks if tuples are assigned.
    Nr)�assignment_indexesrrDr
r`�slicerr�max�
StopIterationrl)r�r�r�indexr�r�iteratedr\s        rOrrBs����J��.�.�0�'���t�
�� 3� 3�T�
:���$�$�R�(���e�U�#���
���5�j�	
$�!�(�^�
��Z�^�^�#���5�j��$�$�&�	�%'�&���!�
!�
!� �
!�s� B�B(�'B(c��eZdZd�Zy)r�c�B�t|j|j�SrX)r�rIr�)�selfs rOrlz%ContextualizedSubscriptListNode.infer^s��$�T�\�\�4�9�9�=�=rSN)�__name__�
__module__�__qualname__rlrQrSrOr�r�]s��>rSr�c��|dk(r"ttj|ddd�g�S|jdk(r�|jddk(s�g}|jD]t}|dk(r|r�|jd��|jdk(r8t
|j�dk(s�E|j|jd��d|j|��v|dgd	t
|�z
zz
}ttj|g|���g�S|jd
k(r+ttj|j||�g�S|j|�S)z,
    Handles slices in subscript nodes.
    r�N�	subscriptrr��sliceopr<r?r�r)
rr�SlicercrhrMrmr�rBr�)rIr�r��els    rOr�r�bs,��
��|�������t�T�B�C�D�D�	���{�	"�5�>�>�!�+<��+C����.�.�	"�B��S�y���M�M�$�'����I�%��r�{�{�#�q�(��M�M�"�+�+�a�.�1��
�
�b�!�	"�	�4�&�A��F��O�,�,�������9�&�9�:�;�;�	����	&���6�6�w�7N�7N�PW�Y^�_�`�a�a����e�$�$rSrX)Q�__doc__rqr8�parso.pythonr�jedirr�jedi.inference.base_valuerrrr	r
�jedi.inference.lazy_valuer�jedi.inferencerr
rrr�jedi.inference.valuerrr�#jedi.inference.value.dynamic_arraysrrr�jedi.inference.helpersrrrrr�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#ra�itemsrbrRr�rsr��increase_indentrar�r�r�r�r�r�r-r�r�rCrFrIrQr4�decorater�r�rr�r�)�kr�s00rO�<module>r�s���������*�*�3�#�$�#�"�$�:�)�R�-�/�/�?�=�9�-�3�1�4�'�
�	�	�	�	�
�	�
�
�
�	�	�	���"":�!?�!?�!A�$���A�A�u�q���u�}��$� �
�BE=�P
0��i�0�)�1�)�����K/���K/�\-�0R%�j�
��
����J��J�Z�2����"��<
� &�'�C��"Z�z�����]��]�D��.� �.�b�6>�&8�>�
%��a$s�F


Youez - 2016 - github.com/yon3zu
LinuXploit