𝗖𝗨𝗥𝗥𝗘𝗡𝗧 𝗙𝗜𝗟𝗘 : /opt/alt/python37/lib/python3.7/site-packages/astroid/__pycache__//inference.cpython-37.pyc
B
��\�z � @ s� d Z ddlZddlZddlZddlmZ ddlmZ ddlmZ ddlm Z ddlm
Z
ddlm Z dd lm Z dd
l
mZ dd lmZ dd lmZ e �� ZdYd
d�Zee j_ee j_ee j_ee j_ee j_ee j_dZdd�Ze j d[dd��Z e e j _e e j _e e j _d\dd�Z!dd� Z"dd� Z#e!e j$_dd� Z%d]dd �Z&e � e �'e&��e j(_e&e j)_*e j e j'd^d d ���Z+e+e j,_e j e j'd_d d!���Z-e-e j._e j e j'd`d"d#���Z/e/e j0_dad$d%�Z1e � e �'e1��e j2_e � e1�e j3_*e j e j'dbd&d'���Z4e4e j5_e6� Z7e j dcd(d)��Z8e �'e8�e j9_e8e j9_*e j e j'ddd*d+���Z:e:e j;_d,d-� Z<ded.d/�Z=e j e j'dfd0d1���Z>e=e j?_=e>e j?_d2d3� Z@d4d5� ZAdgd7d8�ZBdhd9d:�ZCd;d<� ZDd=d>� ZEd?d@� ZFdAdB� ZGdCdD� ZHdEdF� ZIe jJe j'didGdH���ZKeIe jL_IeKe jL_djdIdJ�ZMe j e j'dkdKdL���ZNeMe jO_MeNe jO_e j dldMdN��ZPePe jQ_e j e j'dmdOdP���ZReRe j)_eRe j3_e j e j'dndQdR���ZSeSe jT_e j dodSdT��ZUeUe jV_dpdUdV�ZWeWejX_YdWdX� ZZdS )qzMthis 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 dS )zRinference's end for node such as Module, ClassDef, FunctionDef,
Const...
N� )�selfr r r �B/opt/alt/python37/lib/python3.7/site-packages/astroid/inference.py� infer_end. s r c C sv g }xl| j D ]b}t|tj�rdt�|j|�}|s<tj| |d��t |d�sTtj| |d��|�
t |�� q |� |� 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�append)r r �values�eltZstarredr r r r > s
r c c sR t dd� | jD ��s | V n2t| |�}t| �| j| j| jd�}|�|� |V d S )Nc s s | ]}t |tj�V qd S )N)r r r )�.0�er r r � <genexpr>Q s z!infer_sequence.<locals>.<genexpr>)�lineno�
col_offset�parent)�anyr r �typer r! r" �postinit)r
r r �new_seqr r r �infer_sequenceO s
r' c c sX t dd� | jD ��s | V n8t| |�}t| �| j| j| j�}|�t|�� �� |V d S )Nc s s | ]\}}t |tj�V qd S )N)r r �
DictUnpack)r �k�_r r r r c s z infer_map.<locals>.<genexpr>) r# �items�
_infer_mapr$ r r! r" r% �list)r
r r+ r& r r r � infer_mapb s
r. c C s. t �| �� |�� �}dd� |D �}t|�� �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|� � �qS r )� as_string)r �keyr r r r �
<dictcomp>~ s z,_update_with_replacement.<locals>.<dictcomp>)� itertools�chainr+ �dictr )Zlhs_dictZrhs_dictZ
combined_dictZ
string_mapr r r �_update_with_replacementl s r5 c C s� i }x�| j D ]�\}}t|tj�rft�||�}|s6tj�t|tj�sPtj| |d��t ||�}t
||�}q tj||d�}tj||d�}t dd� ||fD ��r�tj| |d��t
|||i�}q W |S )z$Infer all values based on Dict.items)r r )r c s s | ] }| V qd S )Nr )r �elemr r r r � s z _infer_map.<locals>.<genexpr>) r+ r r r( r r r r �Dictr, r5 r# )r r r �namer Zdouble_starredZ unpack_itemsr0 r r r r, � s
r, c C s8 | }x |j r"t|j tj�s"|j }qW |r4|j r4|j S dS )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�\}}|sNt| �� �}|r4|� | j�\}}|sNtj| j| �� |d��t�|�}| j|_t �
|||�S )z#infer a Name: use name lookup rules)r8 �scoper ) �lookupr8 r; r< r ZNameInferenceError�
contextmod� copy_context�
lookupnamer � _infer_stmts)r
r �frame�stmtsZparent_functionr* r r r �
infer_name� s
rD c c s� t �|�}t j| j| jd�|_d|_|dk r<t| |�� �|_ xb| j
� |�D ]R}|t j
kr`|V qJy"t|d�r�|j| |d�E dH W qJ tjk
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? � CallContextrE rF � callcontext� boundnode�_populate_context_lookup�cloneZ
extra_context�func�inferr � Uninferabler rG r r r4 )r
r rJ Zcalleer r r �
infer_call� s
rQ Tc
c s~ |j }|dkr tj| |d��y(|r6| �| �|��V n | �|�V W n4 tjk
rx } ztj| |d�|�W dd}~X Y nX dS )z7infer an Import node: return the imported module/objectN)r r )r@ r r �do_import_module� real_name�AstroidBuildingError)r
r �asnamer8 �excr r r � infer_import� s rW c
C s� |j }|dkr tj| |d��|r*| �|�}y | �� }W n4 tjk
rj } ztj| |d�|�W dd}~X Y nX y2t�|�}||_ |j||| � � kd�}t
� ||�S tj k
r� } ztj|j
| ||d�|�W dd}~X Y nX dS )z:infer a ImportFrom node: return the imported module/objectN)r r )Z
ignore_locals)�target� attributer )r@ r r rS rR rT r> r? �getattr�rootr rA �AttributeInferenceError�message)r
r rU r8 �modulerV rC �errorr r r �infer_import_from� s$
"
r` c
c s� x�| j �|�D ]�}|tjkr$|V q|r�|jr�t|tj�r�t|jtj�r�y$t� t�
|j�t�
|��rj|j}W n t j k
r� Y nX y$||_|�
| j|�E dH d|_W q t jt jfk
r� d|_Y q tk
r� d|_Y qX qW t| |d�S )zAinfer an Attribute node by using getattr on the associated objectN)r r )�exprrO r rP rK r r �Instancer �
is_subtype� object_typer �_NonDeducibleTypeHierarchy�igetattr�attrnamer\ r �AttributeErrorr4 )r
r �ownerr r r �infer_attribute s.
rj c
C sr |j d krtj| |d��yt�| �� �|j �|�S tjk
rl } z tj|j| |j |d�|�W d d }~X Y nX d S )N)r r )rX rY r ) r@ r r r rA r[ rZ r\ r] )r
r r_ r r r � infer_global@ s
rk c
c sP d}�x2| j �|�D �] }|tjkr0tjV dS �x| j�|�D ]�}|tjkrZtjV dS t}|jtjkrp|}n$|jtjkr�t �
|�}|r�|}n|}|tkr�t j | |d��y|�
||�}W n@ t jt jt jtfk
r� } zt j | |d�|�W dd}~X Y nX | |k�s|tjk�r tjV dS |�|�E dH d}q@W qW |�rLt| |d�S dS )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 rO r rP �slice�_SUBSCRIPT_SENTINEL� __class__r rb r Zclass_instance_as_indexr r �getitemZAstroidTypeErrorZAstroidIndexErrorr\ rh r4 ) r
r Z found_oner �indexZ index_valueZinstance_as_index�assignedrV r r r �infer_subscriptS sF
" rr c # s� | j }| jdkrtj}ntj}y� fdd�|D �}W n tjk
rR tjV dS X x�t j
|� D ]~}t dd� |D ��r�tjV q`dd� |D �}t dd� |D ��r�tjV q`tj}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 ��qS ))r )rO )r r )r r r �
<listcomp>� s z!_infer_boolop.<locals>.<listcomp>Nc s s | ]}|t jkV qd S )N)r rP )r �itemr r r r � s z _infer_boolop.<locals>.<genexpr>c S s g | ] }|� � �qS r )�
bool_value)r ru r r r rt � s c s s | ]}|t jkV qd S )N)r rP )r ru r r r r � s )r r )r �op�operator�truth�not_r r r rP r2 �productr# �zipr4 )r
r r � predicate�pairZ bool_valuesr rv r )r r �
_infer_boolop� s0
r c c s2 x,|| |�D ] }t ||�r$tjV q |V q W d S )N)r r rP )r
Zinfer_callabler r_ �resultr r r �_filter_operation_errors� s
r� c
c s �x�| j �|�D �]�}y|�| j�V W q tk
r\ } zt�|| j|�V W dd}~X Y q tk
�r� } �z�tj | j }|dkr�|�
� }|tj k r�t �
| �V ntj V �n:t|tjt jf�s�t�|| j|�V wy�yt�||�}W n, tjk
�r t�|| j|�V wY nX |d }t|j|d��}|tj k�sF|�� �sHwt�|�}tj|gd�|_|j | |d�}t|d�} | dk�r�|V n| V W nV tjk
�r� } zt�|| j|�V W dd}~X Y n tj k
�r� tj V Y nX W dd}~X Y qX qW dS )z3Infer what an UnaryOp should return when evaluated.Nr )r )rE ) �operandrO Zinfer_unary_oprw � TypeErrorr �BadUnaryOperationMessagerh r
ZUNARY_OP_METHODrv rP r Z
const_factoryr r rb �ClassDefr r= r r\ �next�callabler> r? rI rJ rG r )
r
r r� rV �methrv �methods�inferredZ call_resultsr� r r r �_infer_unaryop� sH "
"r� c c s" t | t|tj�E dH t| |d�S )z3Infer what an UnaryOp should return when evaluated.N)r r )r� r� r r� r4 )r
r r r r �
infer_unaryop s r� c C s t | tj�o| jtkS )z0Check if the given const node is NotImplemented.)r r �Constr �NotImplemented)�constr r r �_is_not_implemented s r� c C sR t �| |�}t�|| �}|d }t|j|d��}|tjkr@tj �| �
|||||�S )z8Invoke binary operation inference on the given instance.r )r ) r r= r> �bind_context_to_noder� rO r rP r r Zinfer_binary_op) �instance�opnoderw �otherr � method_namer� �methodr� r r r �_invoke_binop_inference s
r� Fc C s" t j| }tjt| |||||d�S )z<Get an inference callable for an augmented binary operation.)r� rw r� r� r r� )r
ZAUGMENTED_OP_METHOD� functools�partialr� )r� r� rw r� r �reverser� r r r �_aug_op* s
r� c C s2 |rt j| }n
t j| }tjt| |||||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� rw r� r� r r� )r
ZREFLECTED_BIN_OP_METHODZ
BIN_OP_METHODr� r� r� )r� r� rw r� r r� r� r r r �_bin_op8 s
r� c c s: x4||fD ](}| � � }tj|gd�|_d|_|V q
W dS )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.
)rE N)rM r> rI rJ rK )r �left�right�arg� new_contextr r r �_get_binop_contextsL s
r� c C s | � � |� � kS )z$Check if type1 is the same as type2.)Zqname)Ztype1Ztype2r r r �
_same_type\ s r� c C s� |j }t||�r$t| ||||�g}nvt�||�rDt| ||||�g}nVt�||�rvt|||| |dd�t| ||||�g}n$t| ||||�t|||| |dd�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� )rw r� r� r rc � is_supertype) r� � left_type�
binary_opnoder� �
right_typer �reverse_contextrw r� r r r �_get_binop_flowa s
r� c
C s� |j �d�}|j }t||�r>t| ||||�t| ||||�g} n�t�||�rlt| ||||�t| ||||�g} nrt�||�r�t| ||||�t|||| |dd�t| ||||�g} n2t| ||||�t| ||||�t|||| |dd�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� )rw �stripr� r� r� r rc r� )
r� r� Z
aug_opnoder� r� r r� Zbin_opZaug_opr� r r r �
_get_aug_flow� s
r� c c s t || |�\}}t�| �}t�|�}|| ||||||�}x�|D ]�} yt| � �}
W nH tk
rf w>Y q> tjk
r| w>Y q> tjk
r� tj V dS X t
dd� |
D ��r�tj V dS t t t
|
��r�q>tdd� |
D ��} | r�| t|
�kr�tj V dS |
E dH dS q>W t�||j|�V dS )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 jkV qd S )N)r rP )r r� r r r r � s z*_infer_binary_operation.<locals>.<genexpr>c s s | ]}t |�rd V qdS )� N)r� )r r� r r r r � s )r� r rd r- rh r r\ r r rP r# �all�mapr� �sum�len�BadBinaryOperationMessagerw ) r� r� r� r � flow_factoryr� r� r� r� r� �resultsZnot_implementedr r r �_infer_binary_operation� s8
r� c
c s� | j }| j}|pt�� }t�|�}t�|�}|j|d�}|j|d�}xtt�||�D ]d\}} tdd� | |fD ��r|t j
V dS yt || | |t �E dH W qR t
jk
r� t j
V Y qRX qRW dS )z!Binary operation inference logic.)r c s s | ]}|t jkV qd S )N)r rP )r r r r r r � s z _infer_binop.<locals>.<genexpr>N)r� r� r> �InferenceContextr? rO r2 r{ r# r rP r� r� r re )
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|tj�S )N)r� r� r r� )r
r r r r � infer_binop� s r� c c s� |dkrt �� }|�� }| jj|d�}| jj|d�}xvt�||�D ]f\}}t dd� ||fD ��rlt
j V dS y t ||| |t
d�E dH W qB tjk
r� t
j V Y qBX qBW dS )z0Inference logic for augmented binary operations.N)r c s s | ]}|t jkV qd S )N)r rP )r r r r r r s z#_infer_augassign.<locals>.<genexpr>)r� r� r� r r� )r> r� rM rX � infer_lhsr rO r2 r{ r# r rP r� r� r re )r
r r� r� r� r� r� r r r �_infer_augassign s$ r� c C s t | t|tj�S )N)r� r� r r� )r
r r r r �infer_augassign s r� c C s* |j }|d kr tj| |d��t�| ||�S )N)r r )r@ r r r
Z_arguments_infer_argname)r
r r8 r r r �infer_arguments+ s r� c C s: | � � }t|tj�r |�|�S t| j|d��}t�||�S )zWinfer a AssignName/AssignAttr: need to inspect the RHS part of the
assign node
)r ) Z statementr r � AugAssignrO r- Zassigned_stmtsr rA )r
r ZstmtrC r r r � infer_assign6 s
r� c c sP | � � stjV n:ytj| j|d�E d H W n tjk
rJ tjV Y nX d S )N)r )Zhas_underlying_objectr rP �MANAGERZinfer_ast_from_something�objectr Z AstroidError)r
r r r r �infer_empty_nodeH s
r� c C s | j �|�S )N)r rO )r
r r r r � infer_indexW s r� c C sd t �|| �}|s|}t j|gd�|_t| jd|d�d �}t|tj�sTt j
d| |d��t|� | |��S )N)rE � __getitem__)r z(Could not find __getitem__ for {node!r}.)r r ) r> r� rI rJ r� rf r r Z BoundMethodr r rG )r
rp r r� r� r r r �instance_getitem` s r� c C sp i }|d kr|S x.| j D ]$}t|tj�r4|||j< q|||< qW | jd k rP| jng }x|D ]}|||j< qZW |S )N)rE r r r r rF )�callr Zcontext_lookupr� rF �keywordr r r rL u s
rL )N)N)N)N)N)N)NT)NT)N)N)N)N)N)N)F)F)N)N)N)N)N)N)N)N)[�__doc__r� r2 rx �astroidr r r> r r r r r Zastroid.interpreterr r
r ZAstroidManagerr� r �ModuleZ_inferr� r9 ZLambdar� ZSlicer Zraise_if_nothing_inferredr' ZListZTuple�Setr. r5 r, r7 r; rD Z path_wrapper�NameZ
AssignNamer� rQ ZCallrW ZImportr` Z
ImportFromrj � AttributeZ
AssignAttrrk ZGlobalr� rm rr Z Subscriptr ZBoolOpr� r� r� ZUnaryOpr� r� r� r� r� r� r� r� r� r� Zyes_if_nothing_inferredr� ZBinOpr� r� r� r� � Argumentsr� r� Z EmptyNoder� ZIndexr� rb ro rL r r r r �<module> s�
$ 83
6
#-,
