Your IP : 216.73.216.85

Current Path : /opt/alt/python37/lib/python3.7/site-packages/pylint/checkers/__pycache__/
Upload File :
Current File : //opt/alt/python37/lib/python3.7/site-packages/pylint/checkers/__pycache__/variables.cpython-37.pyc

B

A!p\��@sdZddlZddlmZddlZddlZddlZddlZddlZddl	Z	ddl	m
Z
ddl	mZddl	mZddl
mZddlmZdd	lmZmZmZmZdd
lmZddlmZddlmZe�d
�ZdZe�d�ZejdkZ ddiZ!e"ddh�Z#dZ$dd�Z%dd�Z&edd�dd��Z'dd�Z(d d!�Z)d"d#�Z*d$d%�Z+d&d'�Z,d(d)�Z-d*d+�Z.d,d-�Z/d.d/�Z0d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEgifdFdGdHdDdIgifdJdKdLdM�Z1e�2dNdO�Z3GdPdQ�dQ�Z4GdRdS�dSe�Z5GdTdU�dUe5�Z6ejdk�r�e6Z5dVdW�Z7dS)Xz#variables checkers for Python code
�N)�	lru_cache)�
decorators)�modutils)�objects)�InferenceContext)�is_postponed_evaluation_enabled)�IAstroidChecker�	INFERENCE�INFERENCE_FAILURE�HIGH)�get_global_option)�BaseChecker)�utilsz^_{2}[a-z]+_{2}$�
__future__z_.*|^ignored_|^unused_)�rZ_py_abc�abcztyping.TYPE_CHECKINGZ
TYPE_CHECKINGzbuiltins.rangecCs^y|�|j�}Wntjk
r&dSXx0|j�|g�D]}t|tj�r8|jtkr8dSq8WdS)z9Check if the name is a future import from another module.NT)	�do_import_module�modname�astroid�AstroidBuildingException�locals�get�
isinstance�
ImportFrom�FUTURE)�stmt�name�moduleZ
local_node�r�J/opt/alt/python37/lib/python3.7/site-packages/pylint/checkers/variables.py�_is_from_future_importGsr cs$t|tj�o"t�fdd�|jD��S)zEReturns True if stmt in inside the else branch for a parent For stmt.c3s |]}|���p|�kVqdS)N)�	parent_of)�.0Z	else_stmt)rrr�	<genexpr>Wsz%in_for_else_branch.<locals>.<genexpr>)rr�For�anyZorelse)�parentrr)rr�in_for_else_branchTsr'i�)�maxsizec	Csbyt|�|��}Wnttfk
r*dSXy||}Wntk
rLdSXt|tj�r^|SdS)zget overridden method if anyN)�nextZlocal_attr_ancestors�
StopIteration�KeyErrorrr�FunctionDef)�klassrr&Z	meth_noderrr�overridden_method[sr.cCs`d}|��j}|��j|krH|j|jkr6d|��}q\|jr\d|j}n|jr\d|j|f}|S)zxreturn extra information to add to the message for unpacking-non-sequence
    and unbalanced-tuple-unpacking errors
    �z %sz defined at line %sz defined at line %s of %s)�rootr�lineno�	as_string)�node�inferedZmoreZinfered_modulerrr�_get_unpacking_extra_infoms
r5cCs�d}}|r|jr|j��}|r0|jr0|j��}t|tj�rVt|jtjtjf�spdSntdd�||fD��rpdSg}xP||fD]D}|}x:|r�t|tjtjf�s�|�	|�P|jr�|j��}q�Pq�Wq~W|r�t
t|��dkr�dS|j|jkS)a� Detect that the given frames shares a global
    scope.

    Two frames shares a global scope when neither
    of them are hidden under a function scope, as well
    as any of parent scope of them, until the root scope.
    In this case, depending from something defined later on
    will not work, because it is still undefined.

    Example:
        class A:
            # B has the same global scope as `C`, leading to a NameError.
            class B(C): ...
        class C: ...

    NFcss"|]}t|tjtjf�VqdS)N)rr�ClassDef�Module)r"�frrrr#�sz'_detect_global_scope.<locals>.<genexpr>�)
r&�scoperrr,�	Argumentsr%r6r7�append�len�setr1)r3�frame�defframeZ	def_scoper:Zbreak_scopes�sZparent_scoperrr�_detect_global_scope}s0





rBcCst�}||_|j|dd�S)NF)�asname)rZ
lookupname�infer)r3r�contextrrr�_infer_name_module�srFcCs�i}x�|��D]�\}}tdd�|D��r*qx||D]t}t|tjtjf�sHq0xZ|jD]P}d}|ddkrj|}n"|d�d�dks�||kr�|d}|rP||krP|||<qPWq0WqWt|��dd	�d
�S)z� Try to fix imports with multiple dots, by returning a dictionary
    with the import names expanded. The function unflattens root imports,
    like 'xml' (when we have both 'xml.etree' and 'xml.sax'), to 'xml.etree'
    and 'xml.sax' respectively.
    css*|]"}t|tj�o t|��tj�VqdS)N)rr�
AssignName�assign_type�	AugAssign)r"rrrrr#�sz#_fix_dot_imports.<locals>.<genexpr>Nr�*�.���cSs
|djS)Nr9)�
fromlineno)�arrr�<lambda>��z"_fix_dot_imports.<locals>.<lambda>)�key)	�itemsr%rrr�Import�names�find�sorted)�not_consumedrTr�stmtsr�importsZsecond_namerrr�_fix_dot_imports�s$

rZcCsZ|�tjtjf�}xB|D]:}x4|jD]*\}}|r>||krNdSq$|r$||kr$dSq$WqWdS)z�
    Detect imports in the frame, with the required
    *name*. Such imports can be considered assignments.
    Returns True if an import for the given name was found.
    TN)�nodes_of_classrrSrrT)rr?rYZimport_node�import_name�import_aliasrrr�_find_frame_imports�s
r^cCs6x0|jD]&\}}|r"||kr.dSq||krdSqWdS)NTF)rT)r�global_namesr\r]rrr�_import_name_is_global�sr`cCsdd�|D�}ttj�|��S)Ncss|]}t|j�VqdS)N)r>rT)r"rrrrr#sz)_flattened_scope_names.<locals>.<genexpr>)r>�	itertools�chain�
from_iterable)�iterator�valuesrrr�_flattened_scope_namessrfcs&����tj�}t�fdd�|D��S)zN
    Checks if name_node has corresponding assign statement in same scope
    c3s|]}|j�jkVqdS)N)r)r"rN)�	name_noderrr#sz$_assigned_locally.<locals>.<genexpr>)r:r[rrGr%)rgZassign_stmtsr)rgr�_assigned_locallysrhcCshtjtjtjtjf}xN|jtj|d�D]:}t�|j	�}t�
|�r&t|dd�dkr&|j|jkr&dSq&WdS)N)Z
skip_klassrrTF)
rr,r6rSrr[�Callr�
safe_infer�funcZis_builtin_object�getattrr1)rr:Z
skip_nodes�call�inferredrrr�_has_locals_call_after_nodes
ro)z#Using variable %r before assignmentzused-before-assignmentz=Used when a local variable is accessed before its assignment.)zUndefined variable %rzundefined-variablez,Used when an undefined variable is accessed.)z%Undefined variable name %r in __all__zundefined-all-variablez>Used when an undefined variable name is referenced in __all__.)z7Invalid object %r in __all__, must contain only stringszinvalid-all-objectz;Used when an invalid (non-string) object occurs in __all__.)zNo name %r in module %rzno-name-in-modulez-Used when a name cannot be found in a module.)z0Global variable %r undefined at the module levelzglobal-variable-undefinedzsUsed when a variable is defined through the "global" statement but the variable is not defined in the module scope.)z-Using global for %r but no assignment is donezglobal-variable-not-assignedzjUsed when a variable is defined through the "global" statement but no assignment to this variable is done.)zUsing the global statementzglobal-statementz�Used when you use the "global" statement to update a global variable. Pylint just try to discourage this usage. That doesn't mean you cannot use it !)z.Using the global statement at the module levelzglobal-at-module-levelzSUsed when you use the "global" statement at the module level since it has no effect)z	Unused %sz
unused-importz5Used when an imported module or variable is not used.)zUnused variable %rzunused-variablez-Used when a variable is defined but not used.)zUnused argument %rzunused-argumentz4Used when a function or method argument is not used.)z%Unused import %s from wildcard importzunused-wildcard-importz]Used when an imported module or variable is not used from a `'from X import *'` style import.)z-Redefining name %r from outer scope (line %s)zredefined-outer-namezDUsed when a variable's name hides a name defined in the outer scope.)zRedefining built-in %rzredefined-builtinz5Used when a variable or function override a built-in.)z/Redefining name %r from %s in exception handlerzredefine-in-handlerzHUsed when an exception handler assigns the exception to an existing name)z)Using possibly undefined loop variable %rzundefined-loop-variablez�Used when a loop variable (i.e. defined by a for loop or a list comprehension or a generator expression) is used outside the loop.zjPossible unbalanced tuple unpacking with sequence%s: left side has %d label(s), right side has %d value(s)zunbalanced-tuple-unpackingz>Used when there is an unbalanced tuple unpacking in assignmentZ	old_names)ZE0632zunbalanced-tuple-unpackingz%Attempting to unpack a non-sequence%szunpacking-non-sequencezKUsed when something which is not a sequence is used in an unpack assignment)ZW0633zunpacking-non-sequence)z Cell variable %s defined in loopzcell-var-from-loopz�A variable used in a closure is defined in a loop. This will result in all closures using the same value for the closed-over variable.)zPossibly unused variable %rzpossibly-unused-variablez�Used when a variable is defined but might not be used. The possibility comes from the fact that locals() might be used, which could consume or not the said variable)z"Invalid assignment to %s in methodzself-cls-assignmentzKInvalid assignment to self or cls in instance or class method respectively.)ZE0601ZE0602ZE0603ZE0604ZE0611ZW0601ZW0602ZW0603ZW0604ZW0611ZW0612ZW0613ZW0614ZW0621ZW0622ZW0623ZW0631ZW0632ZE0633ZW0640ZW0641ZW0642�
ScopeConsumerzto_consume consumed scope_typec@s\eZdZdZdd�Zdd�Zdd�Zedd	��Zed
d��Z	edd
��Z
dd�Zdd�ZdS)�
NamesConsumerzZ
    A simple class to handle consumed, to consume and scope type info of node locals
    cCstt�|j�i|�|_dS)N)rp�copyr�_atomic)�selfr3�
scope_typerrr�__init__�szNamesConsumer.__init__cCs^d�d�dd�|jj��D���}|d�d�dd�|jj��D���7}|d�|jj�7}|S)Nz
to_consume : {:s}
z, cSsg|]\}}d�||��qS)z{}->{})�format)r"rQ�valrrr�
<listcomp>�sz*NamesConsumer.__repr__.<locals>.<listcomp>zconsumed : {:s}
cSsg|]\}}d�||��qS)z{}->{})rw)r"rQrxrrrry�szscope_type : {:s}
)rw�joinrs�
to_consumerR�consumedru)rt�msgrrr�__repr__�szNamesConsumer.__repr__cCs
t|j�S)N)�iterrs)rtrrr�__iter__�szNamesConsumer.__iter__cCs|jjS)N)rsr{)rtrrrr{�szNamesConsumer.to_consumecCs|jjS)N)rsr|)rtrrrr|�szNamesConsumer.consumedcCs|jjS)N)rsru)rtrrrru�szNamesConsumer.scope_typecCs||j|<|j|=dS)z`
        Mark the name as consumed and delete it from
        the to_consume dictionary
        N)r|r{)rtrZnew_noderrr�mark_as_consumed�s
zNamesConsumer.mark_as_consumedcCsX|j}|j}|j�|�}|rTt|tj�rT||djkrT|djjd}|j|krTd}|S)Nr)rr&r{rrr�Assign�targets)rtr3r�parent_node�
found_node�lhsrrr�get_next_to_consume�s
z!NamesConsumer.get_next_to_consumeN)
�__name__�
__module__�__qualname__�__doc__rvr~r��propertyr{r|rur�r�rrrrrq�srqc@s�eZdZdZeZdZeZdZ	dddddd	�fd
ddd
dd	�fdddddd	�fdddddd	�fdddddd	�fde
dd
dd	�fdddddd	�ffZd�d!d"�Ze
jd#d$��Ze
jd%d&��Ze
jd'd(��Ze�d)�d*d+��Ze�d)�d,d-��Zd.d/�Ze�d0d1d2d3d4d5�d6d7��Zd8d9�Zed:d;��Zd<d=�Zd>d?�Zd@dA�ZdBdC�ZdDdE�ZdFdG�Z dHdI�Z!dJdK�Z"dLdM�Z#dNdO�Z$dPdQ�Z%dRdS�Z&dTdU�Z'dVdW�Z(dXdY�Z)dZd[�Z*e'Z+e*Z,e�d\d]d^d_d2�d`da��Z-dbdc�Z.ddde�Z/dfdg�Z0e�dh�didj��Z1dkdl�Z2dmdn�Z3edodp��Z4edqdr��Z5dsdt�Z6eje�dudv��Z7dwdx�Z8e�dy�dzd{��Z9e�dy�d|d}��Z:e�d~dd��d�d���Z;d�d��Z<d�d��Z=e=Z>e=Z?d�d��Z@d�d��ZAd�d��ZBd S)��VariablesCheckerz�checks for
    * unused variables / imports
    * undefined variables
    * redefinition of variable from builtins or from an outer scope
    * use of variable before assignment
    * __all__ consistency
    * self/cls assignment
    �	variablesrLzinit-importrZynz<y_or_n>zBTells whether we should check for unused import in __init__ files.)�default�type�metavar�helpzdummy-variables-rgxz;_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_Zregexpz<regexp>zYA regular expression matching the name of dummy variables (i.e. expected to not be used).zadditional-builtinsrZcsvz<comma separated list>z�List of additional names supposed to be defined in builtins. Remember that you should avoid defining new builtins when possible.�	callbacks)Zcb_�_cbz<callbacks>z|List of strings which can identify a callback function by name. A callback name must start or end with one of those strings.zredefining-builtins-modules)z	six.movesz
past.builtinszfuture.builtins�builtins�iozQList of qualified module names which can have objects that can redefine builtins.zignored-argument-nameszcArgument names that match this expression will be ignored. Default to name with leading underscore.zallow-global-unused-variablesTzGTells whether unused global variables should be treated as a violation.NcCs.t�||�d|_d|_g|_g|_d|_dS)NF)r
rv�_to_consumeZ_checking_mod_attr�_loop_variables�_type_annotation_names�_postponed_evaluation_enabled)rt�linterrrrrvPszVariablesChecker.__init__cCst|ddd�S)Nzanalyse-fallback-blocksF)r�)r)rtrrr�_analyse_fallback_blocks[sz)VariablesChecker._analyse_fallback_blockscCst|dgd�S)Nzignored-modules)r�)r)rtrrr�_ignored_modules_sz!VariablesChecker._ignored_modulescCst|ddd�S)Nzallow-global-unused-variablesT)r�)r)rtrrr�_allow_global_unused_variablescsz/VariablesChecker._allow_global_unused_variableszredefined-outer-namecs�dd�|j�tj�D�}|jj��fdd�|D�}xJ|D]B}x<|jD]2\}}||krDt||�sD|jd||j	f|d�PqDWq8W|j�
||f�dS)NcSsg|]
}|j�qSr)r)r"�varrrrryjsz.VariablesChecker.visit_for.<locals>.<listcomp>csg|]}��|�s|�qSr)�match)r"r�)�	dummy_rgxrrryoszredefined-outer-name)�argsr3)�targetr[rrG�config�dummy_variables_rgxr�r'�add_messagerMr<)rtr3Zassigned_to�variableZ	outer_forZouter_variablesr)r�r�	visit_forgs


zVariablesChecker.visit_forcCs|j��|�|�dS)N)r��pop�_store_type_annotation_names)rtr3rrr�	leave_fors
zVariablesChecker.leave_forcCsxt|d�g|_t|�|_xZ|j��D]L\}}t�|�r$t�|d�s$|�	|d�s$|dkr\q$|j
d||dd�q$WdS)znvisit module : update consumption analysis variable
        checks globals doesn't overrides builtins
        rrr�zredefined-builtin)r�r3N)rqr�rr�rrRr�
is_builtin�is_inside_except� _should_ignore_redefined_builtinr�)rtr3rrXrrr�visit_module�s
zVariablesChecker.visit_modulez
unused-importzunused-wildcard-importzredefined-builtinzundefined-all-variablezinvalid-all-objectzunused-variablecCs^t|j�dkst�|j��j}d|jkr4|�||�|�|�|jj	sP|j
rPdS|�|�dS)z$leave module: check globals
        r9�__all__N)r=r��AssertionErrorr�r{r�
_check_all�_check_globalsr�Zinit_import�package�_check_imports)rtr3rWrrr�leave_module�s

zVariablesChecker.leave_modulec	Csbt|�d��}|tjkrdS�x>t|dd�D�],}yt|���}Wntjk
rZw,YnX|tjkrhq,|jspq,t|tj	�r�t|j
t�s�|jd|�
�|d�q,|j
}||kr�||=q,||jkr,|js�|jd|f|d�q,tj�|j�d}tj�|�dkr,|jd	|}yt�|�d	��Wq,tk
�rD|jd|f|d�Yq,tk
�rXYq,Xq,WdS)
Nr��eltsrzinvalid-all-object)r�r3zundefined-all-variablerrvrK)r)Zigetattrr�UninferablerlrD�InferenceErrorr&rZConst�value�strr�r2rr��os�path�splitext�file�basenamerrZfile_from_modpath�split�ImportError�SyntaxError)rtr3rW�assigned�eltZelt_namer�rrrrr��sD



zVariablesChecker._check_allcCs(|j}t|tj�sdS|j}|��tkS)NF)r&rrZIf�testr2�TYPING_TYPE_CHECKS_GUARDS)r3r&r�rrr�_is_type_checking_import�s
z)VariablesChecker._is_type_checking_importcCsD|jr
dSx4|��D](\}}x|D]}|jd|f|d�q"WqWdS)Nzunused-variable)r�r3)r�rRr�)rtrWrZnodesr3rrrr��s

zVariablesChecker._check_globalscCs�t|�}t�}�x�|D�]|\}}�xp|jD�]d}|d}}|dkrH|}|d}	||krZq*|||	fkrhq*|�|�t|tj�s�t|tj�r�|js�t|tj�r�t	�
|�r�q*|	dkr�q*|	dkr�d|}
nd||	f}
|�|�s�|jd|
|d�q*t|tj�r*|jt
kr*t	�
|��rq*t||��rq*||jk�r,q*|dk�rH|jd	||d�q*|	dk�rbd
||jf}
n||j|	f}d|}
|�|�s*|jd|
|d�q*WqW|`dS)NrrJr9�_z	import %sz%s imported as %sz
unused-import)r�r3zunused-wildcard-importz%s imported from %sz%s imported from %s as %s)rZr>rT�addrrrSrr�SPECIAL_OBJ�searchr�r�rr r�r�)rtrWZlocal_names�checkedrrrYZ	real_nameZ
imported_nameZas_namer}�fieldsrrrr��sR





zVariablesChecker._check_importscCs|j�t|d��dS)z:visit class: update consumption analysis variable
        �classN)r�r<rq)rtr3rrr�visit_classdef&szVariablesChecker.visit_classdefcCs|j��dS)z:leave class: update consumption analysis variable
        N)r�r�)rtr�rrr�leave_classdef+szVariablesChecker.leave_classdefcCs|j�t|d��dS)z;visit lambda: update consumption analysis variable
        �lambdaN)r�r<rq)rtr3rrr�visit_lambda1szVariablesChecker.visit_lambdacCs|j��dS)z;leave lambda: update consumption analysis variable
        N)r�r�)rtr�rrr�leave_lambda6szVariablesChecker.leave_lambdacCs|j�t|d��dS)z<visit genexpr: update consumption analysis variable
        �
comprehensionN)r�r<rq)rtr3rrr�visit_generatorexp<sz#VariablesChecker.visit_generatorexpcCs|j��dS)z<leave genexpr: update consumption analysis variable
        N)r�r�)rtr�rrr�leave_generatorexpAsz#VariablesChecker.leave_generatorexpcCs|j�t|d��dS)z=visit dictcomp: update consumption analysis variable
        r�N)r�r<rq)rtr3rrr�visit_dictcompGszVariablesChecker.visit_dictcompcCs|j��dS)z=leave dictcomp: update consumption analysis variable
        N)r�r�)rtr�rrr�leave_dictcompLszVariablesChecker.leave_dictcompcCs|j�t|d��dS)z<visit setcomp: update consumption analysis variable
        r�N)r�r<rq)rtr3rrr�
visit_setcompRszVariablesChecker.visit_setcompcCs|j��dS)z<leave setcomp: update consumption analysis variable
        N)r�r�)rtr�rrr�
leave_setcompWszVariablesChecker.leave_setcompcCs�|j�t|d��|j�d�s.|j�d�s.dS|��j}x�|��D]�\}}t�	|�rVqB||kr�t
|tj�s�||d}t
|tj
�r�|jtkr�qB|j}|�||�s�|jd||f|d�qBt�|�rB|�|�sB|jd||d�qBWdS)zNvisit function: update consumption analysis variable and check locals
        �functionzredefined-outer-namezredefined-builtinNr)r�r3)r�r<rqr��is_message_enabledr0�globalsrRrr�rr�GlobalrrrrM�_is_name_ignoredr�r�r�)rtr3�globsrrZ
definition�linerrr�visit_functiondef]s(


z"VariablesChecker.visit_functiondefcCsJ|jj}t|tj�r"t|jtj�s.t|tj�r8|jj}n|}|oH|�|�S)N)	r�r�rrrGr&r;Zignored_argument_namesr�)rtrrZauthorized_rgx�regexrrrr�s
z!VariablesChecker._is_name_ignoredcs�|�||�rdSt�tj�rP|dkrPt�jd�dkrPt�jddtj�rPdSt|tjtjtj	f�rx|rxt
||�rxdStt�
���dd��jjD���}���}�j��}|r�t|tj�r�t�|�r�tnt}	nt}	||k�r�|�rD�jdkr�||dkr�dSt|�j�}
|
dk	�r&||
��k�r&dS�jtjk�rD�jdk�rDdSt�fdd	�|jjD���rddSt� ���rtdS|j!d
|||	d��n|j�r�t|jtj"tj#f��r�||k�r�dSt|tjtj	f��r�|j$d\}}|�p�|}t%|��&���r�d}
n�t|tj��r:|dk	�rd
||f}nd|}|j!d||d�dSt|tj	��r�|dk	�rdd||j'|f}nd||j'f}|j!d||d�dSd}
|j!|
||d�dS)N�	__class__r9rcSsg|]
}|j�qSr)r)r"�argrrrry�sz5VariablesChecker._check_is_unused.<locals>.<listcomp>�staticmethod)rv�__new__c3s&|]}�j�|�p�j�|�VqdS)N)r�
startswith�endswith)r"�cb)r3rrr#�sz4VariablesChecker._check_is_unused.<locals>.<genexpr>zunused-argument)r�r3�
confidencezpossibly-unused-variablez%s imported as %sz	import %sz
unused-import)r�r3z%s imported from %s as %sz%s imported from %szunused-variable)(r�rrr,r=rr6r�rSrr`�listrarb�argnamesr��
kwonlyargs�	is_methodr&r?rZhas_known_basesr	r
rr�r.rZ	PYMETHODSr%r�r�Z(is_registered_in_singledispatch_functionr�r�Z	AnnAssignrTror:r)rtrr3rr_�nonlocal_namesr�r�r-r�Z
overridden�qnamerCZmessage_namer}r)r3r�_check_is_unused�sz 








z!VariablesChecker._check_is_unusedc	Cs�|jr|�|j�|jr2x|jD]}|�|�q W|j��j}|j�d�sf|j�d�sf|j�d�sfdSt�	|�rtdS|�
�}|r�|��r�dSt|�
tj��}t|�
tj��}x*|��D]\}}|�|||d||�q�WdS)z4leave function: check function's locals are consumedzunused-variablezpossibly-unused-variablezunused-argumentNr)Ztype_comment_returns�_store_type_annotation_nodeZtype_comment_argsr�r�r{r�r�rZis_errorr�Zis_abstractrfr[rr��NonlocalrRr�)	rtr3Zargument_annotationrWr�r_r�rrXrrr�leave_functiondef�s&
z"VariablesChecker.leave_functiondefzglobal-variable-undefinedzglobal-variable-not-assignedzglobal-statementzglobal-at-module-levelc
	Cs&|��}t|tj�r&|jd|d�dS|��}d}|��j}x�|jD]�}y|�	|�}Wntj
k
rpg}YnXtdd�|�|d�D��}|s�|r�|jd||d	�d
}qDx\|D]<}	t|	tj
�r�|	j|jkr�|jd||d	�P|	��|kr�Pq�W|rD|jd||d	�d
}qDW|�r"|jd
|d�dS)z/check names imported exists in the global scopezglobal-at-module-level)r3NTcss|]}t|tjj�VqdS)N)rr�node_classesrS)r"�localrrrr#$sz0VariablesChecker.visit_global.<locals>.<genexpr>rzglobal-variable-not-assigned)r�r3Fzredefined-builtinzglobal-variable-undefinedzglobal-statement)r?rrr7r�r0r:rrTrl�
NotFoundErrorr%rrGrZspecial_attributes)
rtr3r?rZdefault_messageZlocals_rZassign_nodesZnot_defined_locally_by_importZanoderrr�visit_globals>	


zVariablesChecker.visit_globalcs��fdd�}|���t�tjtjf�s*dSt|jtj�r<dSt|tj�rl|j�|���r�|j	d||j
d�n`|��}|}xRt|tj�s�||kr�P|j}qzW|���r�|�s�t���tj
�s�|j	d||j
d�dS)Ncst�jtj�o�jj�kS)N)rr&rrirkr)�
node_scoperr�_is_direct_lambda_call@szLVariablesChecker._check_late_binding_closure.<locals>._is_direct_lambda_callzcell-var-from-loop)r3r�)r:rr�Lambdar,r&r;�
Comprehensionr!r�rr$�	statementZReturn)rtr3Zassignment_noder�Zassign_scopeZ	maybe_forr)r�r�_check_late_binding_closure?s&

z,VariablesChecker._check_late_binding_closurecCs�|j�d�sdSdd�|�|�dD�}|rR|djs@|djrX|d���|�rXg}n|dd�}xLt|dd��D]8\}}||���|�r�t||��|�s�qv|�	|�qvW|}t
|�dkr�dS|d��}t|t
jt
jt
jf�r�|��|��k	s�dSt|t
j��s|jd||d�dSyt|j���}Wn(t
jk
�rX|jd||d�Yn�Xt|t
j��rz|��tk�rzdSt
jt
jt
jt
jtjf}	t||	��s�|jd||d�dSt|dt|dg��}
|
�s�|jd||d�dS)	Nzundefined-loop-variablecSsg|]}t|d�r|�qS)rH)�hasattr)r"rrrrrybsz2VariablesChecker._loopvar_name.<locals>.<listcomp>r9r)r�r3r�rR) r�r��lookupZis_statementr&r�r!�	enumerater'r<r=rHrrr$r�ZGeneratorExpr�r)rrDr�ZInstancer��
BUILTIN_RANGE�List�Tuple�Dict�SetrZ	FrozenSetrl)rtr3rZastmtsZ_astmts�irZassignrn�	sequences�elementsrrr�
_loopvar_name^sT	zVariablesChecker._loopvar_namecCst|tj�sdS|j|jjkS)NF)rrrrr�Zredefining_builtins_modules)rtrrrrr��sz1VariablesChecker._should_ignore_redefined_builtinzredefine-in-handlercCs<x6t�|j�D]&}t�|�\}}|r|jd||d�qWdS)Nzredefine-in-handler)r�r3)rZget_all_elementsrZclobber_in_exceptr�)rtr3rZ
clobberingr�rrr�visit_excepthandler�sz$VariablesChecker.visit_excepthandlercCst|��tj�r|�|�dS)N)rrHrrI�
visit_name)rtr3rrr�visit_assignname�sz!VariablesChecker.visit_assignnamecCs|�|�dS)N)r)rtr3rrr�
visit_delname�szVariablesChecker.visit_delnamecCs`d}t|tj�r\|��|kr\trP||jjkpZ||jjkpZ||jjkpZ||jj	kpZ|j�
|�}|S)NF)rrr,r��PY3Kr��annotationsZkwonlyargs_annotationsZvarargannotationZkwargannotationr!)r3r?�in_annotation_or_defaultrrr�_defined_in_function_definition�sz0VariablesChecker._defined_in_function_definitionc	
s d}	d}
d}||k	r"t|||�}	n�|jdkrJ�|jksDt���dr�d}	n~t|tj�sft|��tj�olt	|�}|s�|�
����dr�d}	||ko�t|tjj
�}n&�|jkr�t�fdd�|��D��}	|dk�r t|tj��r �|jk�r t|tj��o||jk�o|j�dj|jk}	n�t|tj��r�t|tj��r�t�rd||jk�rd|�|j��rdd}	}
|	�r�|j|jk�r�|j�dj|jk�r�d}	t|jtj��r|j|jk}	nd|�r�d}	nX|	�o�|j|jk}	|	�r|j|jk�rt|tj��r||k�r|�|��r||k	�rd}	|	|
|fS)NTFr9c3s$|]}t|tj�o�|jkVqdS)N)rrr�rT)r"�child)rrrr#�sz:VariablesChecker._is_variable_violation.<locals>.<genexpr>r�r)rBr&�scope_attrsrZbuiltin_lookuprr,r?r�rhr0rr�r�rr%�get_childrenr6r;�defaultsrMrZreturnsr!rr1)
r3r�defnoder�defstmtr?r@�base_scope_type�recursive_klass�
maybee0601�annotation_return�use_outer_definitionZ
forbid_lookupr)rr�_is_variable_violation�sZ




 

z'VariablesChecker._is_variable_violationcCsP|j}|����}|�||�}|r0|j��j}n|j}t|tj�sF|oL||kS)a
        Return True if the node is in a local class scope, as an assignment.

        :param node: Node considered
        :type node: astroid.Node
        :return: True if the node is in a local class scope, as an assignment. False otherwise.
        :rtype: bool
        )	rr�r:rr&rrrr6)rtr3rr?rZframe_localsrrr�_ignore_class_scope4sz$VariablesChecker._ignore_class_scopecCs�|��}|jdkr*|��j�d�r&t�dS|j}|��}t�	|�sXt�
|�sXt�||�rht|j
�d}nt|j
�d}|j
|j}�x0t|dd�D�]�}|j
|}|jdkr�||kr�|dkr�||dks�|�|�r�q�||jk�r&|jdkr�|�||��s&t�|j|d�}	|�||	�|�||�P|�|�}
|
dk�r<q�t�|j|d�}	|	dk	�rR|�||	�|	��}|��}||k�o�|�|��o�t|tj��o�|j|jk}
|
�r�t�|��r�t�	|��r�|��j��|k	�r�P|�|||	||||||
�	\}}}|�rq�|�rRt� |��sRt�!||d	��sR||k�o>t|tj"tj#f�}|
�s`|�s`|�s`t|tj$��r�t�%|t&��sR|j'�r�|�r�||��j(k�sR|j)d
||d�n�|dk�r�|j'�r�t|tj*��sR|j)d
||d�n�|dk�rRt|tj��r6||j(k�r6t|jtj+��r$|j|jk�r4|j)d
||d�n|j)d
||d�n|jdk�rR|j)d
||d�|�,||
�|�||�Pq�W|tj-j.k�s�t�/|��s�||j0j1k�s�t�%|t&��s�|j)d
||d�dS)zbcheck that a name is defined if the current scope and doesn't
        redefine a built-in
        Nz.py�r9rLr�r�r)�	NameErrorzundefined-variable)r�r3r�zused-before-assignment)r3r�)2r�rMr0r�r�r�rr:rZis_default_argumentZis_func_decoratorZis_ancestor_namer=r�ru�ranger!r|�$_has_homonym_in_upper_function_scopeZ
assign_parentrrr�r{r?r!rrr6Zis_inside_lambdar&r Zis_defined_beforeZ
are_exclusiveZDelNamerGZDeleteZnode_ignores_exceptionr#r�rr�r,r;r�r7rr�r��additional_builtins)rtr3rrr?Zstart_indexrr	Zcurrent_consumerrr�rr@rrrrZdefined_by_stmtrrrrYs�












zVariablesChecker.visit_namecCs<x6|j|ddd�D]}|jdkr|j|jkrdSqWdS)a�
        Return True if there is a node with the same name in the to_consume dict of an upper scope
        and if that scope is a function

        :param node: node to check for
        :type node: astroid.Node
        :param index: index of the current consumer inside self._to_consume
        :type index: int
        :return: True if there is a node with the same name in the to_consume dict of an upper scope
                 and if that scope is a function
        :rtype: bool
        r9NrLr�TF)r�rurr{)rtr3�indexZ	_consumerrrrr%s
z5VariablesChecker._has_homonym_in_upper_function_scopezno-name-in-modulec	Cs||jst�|�rdSxb|jD]X\}}|�d�}ytt||d��}Wntjk
r\wYnX|�	|||dd��qWdS)z check modules attribute accessesNrKrr9)
r�r�is_from_fallback_blockrTr�r)rFrZResolveError�_check_module_attrs)rtr3rr��partsrrrr�visit_import+s
zVariablesChecker.visit_importcCs�|jst�|�rdS|j�d�}y|�|d�}Wntjk
rHdSX|�|||dd��}|shdSx0|j	D]&\}}|dkr�qp|�|||�d��qpWdS)z check modules attribute accessesNrKrr9rJ)
r�rr(rr�rrrr)rT)rtr3Z
name_partsrrr�rrr�visit_importfrom;sz!VariablesChecker.visit_importfromzunbalanced-tuple-unpackingzunpacking-non-sequencezself-cls-assignmentcCsv|�|�t|jdtjtjf�s&dS|jd��}y&t�|j	�}|dk	rX|�
|||�Wntjk
rpdSXdS)z�Check unbalanced tuple unpacking for assignments
        and unpacking non-sequences as well as in case self/cls
        get assigned.
        rN)�_check_self_cls_assignrr�rrr�iteredrrjr��_check_unpackingr�)rtr3r�r4rrr�visit_assignPs
zVariablesChecker.visit_assigncCsBt|tj�r|j�|j�n"|j�tdd�|�tj�D���dS)Ncss|]}|jVqdS)N)r)r"�
annotationrrrr#lsz?VariablesChecker._store_type_annotation_node.<locals>.<genexpr>)	rr�Namer�r<r�extendr�r[)rt�type_annotationrrrr�dsz,VariablesChecker._store_type_annotation_nodecCs|j}|sdS|�|j�dS)N)r4r�)rtr3r4rrrr�rsz-VariablesChecker._store_type_annotation_namescs�dd�|jD��|��}t�fdd�|jD��}|rB|��j��}t|tjj�rd|�	�rdd|�
�kshdS|��}|sxdS|d}dd�|jD�}||kr�|jd	||d
�dS)z&Check that self/cls don't get assignedcSsh|]}t|tj�r|j�qSr)rrrGr)r"r�rrr�	<setcomp>}sz:VariablesChecker._check_self_cls_assign.<locals>.<setcomp>c3s,|]$}t|tj�r�t|j�@r|VqdS)N)rrr�r>rT)r"r)�assign_namesrrr#�sz:VariablesChecker._check_self_cls_assign.<locals>.<genexpr>zbuiltins.staticmethodNrcss"|]}t|tjj�r|jVqdS)N)rrr�rGr)r"r�rrrr#�szself-cls-assignment)r3r�)
r�r:r%�bodyr&rrZscoped_nodesr,r�Zdecoratornamesr�r�)rtr3r:Znonlocals_with_same_nameZargument_namesZ
self_cls_nameZtarget_assign_namesr)r6rr-{s(


z'VariablesChecker._check_self_cls_assigncCs�t�|�rdSt�|�rdS|tjkr*dSt|jtj�rZt|jtj	�rZ|jj
|jjkrZdSt|tjtj
f�r�|��}t|�t|�kr�tdd�|D��r�dS|jd|t||�t|�t|�fd�n"t�|�s�|jd|t||�fd�dS)zS Check for unbalanced tuple unpacking
        and unpacking non sequences.
        Ncss|]}t|tj�VqdS)N)rrZStarred)r"r�rrrr#�sz4VariablesChecker._check_unpacking.<locals>.<genexpr>zunbalanced-tuple-unpacking)r3r�zunpacking-non-sequence)rZis_inside_abstract_classZis_comprehensionrr�rr&r;r�r2r�varargrrr.r=r%r�r5Zis_iterable)rtr4r3r�rerrrr/�s4



z!VariablesChecker._check_unpackingcCs�t|tj�st|��x�|r�|�d�}|dkr2d}Py(t|�|�d���}|tjkrXdSWqtj	k
r�|j
|jkr|dS|jd||j
f|d�dStj
k
r�dSXqW|r�|r�|j
nd}|jd|d�|�|fd�dSt|tj�r�|SdS)z�check that module_names (list of string) are accessible through the
        given module
        if the latest access name corresponds to a module, return it
        r�__dict__Nzno-name-in-module)r�r3rK)r3r�)rrr7r�r�r)rlrDr�r�rr�r�r�rz)rtr3r�module_namesrrrrrr)�s4


z$VariablesChecker._check_module_attrs)N)Cr�r�r�r�rZ__implements__r�MSGSZmsgs�priority�IGNORED_ARGUMENT_NAMES�optionsrvrZcachedpropertyr�r�r�rZcheck_messagesr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�Zvisit_asyncfunctiondefZleave_asyncfunctiondefr�rrr�r
rrrr r!rr%r+r,r0r�r�Zleave_assignZ
leave_withr-r/r)rrrrr��s�

0<"_/Hl%A"*r�csLeZdZdZdd�Zdd�Z�fdd�Z�fdd	�Zd
d�Zdd
�Z	�Z
S)�VariablesChecker3kz!Modified variables checker for 3kcCs|j�t|d��dS)z=visit dictcomp: update consumption analysis variable
        r�N)r�r<rq)rtr3rrr�visit_listcomp�sz!VariablesChecker3k.visit_listcompcCs|j��dS)z=leave dictcomp: update consumption analysis variable
        N)r�r�)rtr�rrr�leave_listcomp�sz!VariablesChecker3k.leave_listcompcs|�|�tt|��|�dS)N)�_check_metaclasses�superr?r�)rtr3)r�rrr��s
z$VariablesChecker3k.leave_functiondefcs|�|�tt|��|�dS)N)rBrCr?r�)rtr3)r�rrr�s
zVariablesChecker3k.leave_modulecCsVg}x.|��D]"}t|tj�r|�|�||��qWx|D]\}}|�|d�q:WdS)z. Update consumption analysis for metaclasses. N)rrrr6r3�_check_classdef_metaclassesr�)rtr3r|Z
child_node�scope_localsrrrrrBsz%VariablesChecker3k._check_metaclassesc	Cs*|js
gSg}|��}d}t|jtj�r2|jj}n|r@|��j}d}t�||�}|r�x<|j	ddd�D](\}}}|�|�}|rf|�
||f�PqfW|dk�r&|�s&d}t|jtj�r�|jj}nt|jtj�r�|j��}|dk	�r&|tj
jk�s&t�|��s&||jjk�s&||jk�s&|jd||fd�|S)NrLzundefined-variable)r3r�)Z
_metaclass�	metaclassrrr2rr0�METACLASS_NAME_TRANSFORMSrr�r<�	Attributer2r7rrr�r�r&rr�)	rtr-r�r|rFr�foundrEr�rrrrDs<





z.VariablesChecker3k._check_classdef_metaclasses)r�r�r�r�r@rAr�r�rBrD�
__classcell__rr)r�rr?�s
r?cCs|�t|��dS)z-required method to auto register this checkerN)Zregister_checkerr�)r�rrr�register@srK)8r�rr�	functoolsrra�collectionsr��sys�rerrrrZastroid.contextrZpylint.checkers.utilsrZpylint.interfacesrr	r
rZpylint.utilsrZpylint.checkersr
r�compiler�rr=�version_inforrG�	frozensetr�rr r'r.r5rBrFrZr^r`rfrhror;�
namedtuplerprqr�r?rKrrrr�<module>$s�



A#

CP