3
]^]                @   s  d Z ddlZddlZddlZddlZddlZddlmZ ddlZddl	Zddl
ZddlmZ ddljZddlmZmZmZ ddlmZ ddlmZ ddlmZ G d	d
 d
ZG dd deZG dd deZG dd deZG dd deZG dd deZeeeeedZ ej!dZ"dZ#dsZ$e$e#ffZ%e&dtZ'ej(ej)ej*ej+fZ,d Z-ej.Z/d!e/ Z0d"d#hZ1d$d%hZ2e3e4d&d' duD d+d,d-gZ5d.d/d0d1d2Z6e&dvZ7e&dwZ8d4Z9d5d6 Z:d7d8 Z;d9d: Z<d;d< Z=d=d> Z>d?d@ Z?dAZ@dBdC ZAdxdDdEZBdFdG ZCdHdI ZDdJdK ZEG dLdM dMejFZGG dNdO dOeGZHG dPdQ dQeGZIdRdSdTdUdVdWdXdYdZd[h
ZJdRd\dTdUdVd]dXdYd^d_d`
ZKdadbdcdadadadadaddddd`
ZLdedf ZMG dgdh dheGZNG didj djeGZOG dkdl dleGZPdmdn ZQG dodp dpeGZRdqdr ZSdS )yzbasic checker for Python code    N)Pattern)CallSite)checkers
exceptions
interfaces)utils)is_property_setter_or_deleter)nodesc               @   s0   e Zd ZdZdZdZdZdZdZe	dd Z
dS )NamingStyleNc             C   s2   | j | j| j| j| j| j| j| j| j| jd
| S )N)
moduleconstclassfunctionmethodattrargumentvariableclass_attribute	inlinevar)MOD_NAME_RGXCONST_NAME_RGXCLASS_NAME_RGXDEFAULT_NAME_RGXCLASS_ATTRIBUTE_RGXCOMP_VAR_RGX)cls	name_type r   6/tmp/pip-build-8app2_gc/pylint/pylint/checkers/base.py	get_regexG   s    zNamingStyle.get_regex)__name__
__module____qualname__r   r   r   r   r   r   classmethodr   r   r   r   r   r
   ;   s   r
   c               @   sL   e Zd ZdZejdZejdZejdZejdZ	ejdZ
ejdZdS )	SnakeCaseStylez(Regex rules for snake_case naming style.z[a-z_][a-z0-9_]+$z([a-z_][a-z0-9_]*)$z(([a-z_][a-z0-9_]*)|(__.*__))$z[a-z_][a-z0-9_]*$z<(([a-z_][a-z0-9_]{2,})|(_[a-z0-9_]*)|(__[a-z][a-z0-9_]+__))$z!(([a-z_][a-z0-9_]{2,}|(__.*__)))$N)r    r!   r"   __doc__recompiler   r   r   r   r   r   r   r   r   r   r$   W   s   



r$   c               @   sL   e Zd ZdZejdZejdZejdZejdZ	ejdZ
ejdZdS )	CamelCaseStylez'Regex rules for camelCase naming style.z[a-z_][a-zA-Z0-9]+$z([a-z_][a-zA-Z0-9]*)$z (([a-z_][A-Za-z0-9]*)|(__.*__))$z[a-z_][A-Za-z0-9]*$z3(([a-z_][a-zA-Z0-9]{2,})|(__[a-z][a-zA-Z0-9_]+__))$z!([a-z_][A-Za-z0-9]{2,}|(__.*__))$N)r    r!   r"   r%   r&   r'   r   r   r   r   r   r   r   r   r   r   r(   d   s   




r(   c               @   sL   e Zd ZdZejdZejdZejdZejdZ	ejdZ
ejdZdS )PascalCaseStylez(Regex rules for PascalCase naming style.z[A-Z_][a-zA-Z0-9]+$z (([A-Z_][A-Za-z0-9]*)|(__.*__))$z0[A-Z_][a-zA-Z0-9]{2,}$|(__[a-z][a-zA-Z0-9_]+__)$z[A-Z_][a-zA-Z0-9]{2,}$N)r    r!   r"   r%   r&   r'   r   r   r   r   r   r   r   r   r   r   r)   o   s   




r)   c               @   sL   e Zd ZdZejdZejdZejdZejdZ	ejdZ
ejdZdS )UpperCaseStylez(Regex rules for UPPER_CASE naming style.z[A-Z_][A-Z0-9_]+$z(([A-Z_][A-Z0-9_]*)|(__.*__))$z/([A-Z_][A-Z0-9_]{2,})|(__[a-z][a-zA-Z0-9_]+__)$z[A-Z_][A-Z0-9_]{2,}$N)r    r!   r"   r%   r&   r'   r   r   r   r   r   r   r   r   r   r   r*   z   s   




r*   c               @   s   e Zd Zedd ZdS )AnyStylec             C   s
   t jdS )Nz.*)r&   r'   )r   r   r   r   r   r      s    zAnyStyle.get_regexN)r    r!   r"   r#   r   r   r   r   r   r+      s   r+   )
snake_caseZ	camelCase
PascalCase
UPPER_CASEanyz^___reversed____getitem____len__isis not==!=innot inzunittest.casez%s.typez_py_abc.ABCMetazabc.ABCMetaZexemptignorec             C   s   g | ]}d j t|gqS ).)joinBUILTINS).0xr   r   r   
<listcomp>   s    r?   setdictlistzset()z{}z[]>>=<<=)rE   z<=rC   z>=r!   ztyping.ForwardRefc             C   s   | }x|r"t |jtj r"|j}qW | s:tj|jt r>dS |jj}xP|jtjtj	fD ]:}x4|j
D ]*\}}|r|| jkrdS qf|| jkrfdS qfW qZW dS )z Detect that the given node (AssignName) is inside an
    exception handler and redefines an import from the tryexcept body.
    Returns True if the node redefines an import, False otherwise.
    FT)
isinstanceparentastroidExceptHandlerr   Zerror_of_typeImportErrornodes_of_class
ImportFromImportnamesname)nodecurrentZ	try_blockZimport_noderP   aliasr   r   r   _redefines_import   s    


rT   c             C   s@   | j }x4|dk	r:t|tjtjtjtjtjfr2dS |j }qW dS )z4return True if the node is inside a kind of for loopNTF)rH   rG   rI   ForListCompSetCompDictCompGeneratorExp)rQ   rH   r   r   r   in_loop   s    


rZ   c             C   s<   x6| D ].}t |ttfr(t||r4dS q||krdS qW dS )zUreturn true if the object is an element of <nested_list> or of a nested
    list
    TF)rG   rB   tuplein_nested_list)Znested_listobjZelmtr   r   r   r\      s    

r\   c             C   sL   t jt jf}| j}x4t|| s0| t|dg krF|} |j}|dkrP qW |S )z
    Returns the loop node that holds the break node in arguments.

    Args:
        break_node (astroid.Break): the break node of interest.

    Returns:
        astroid.For or astroid.While: the loop node holding the break node.
    orelseN)rI   rU   WhilerH   rG   getattr)Z
break_node
loop_nodesrH   r   r   r   _get_break_loop_node   s    
rb   c                sV   t jt jf}t jt jf}fddj||dD  t fddjt j|dD S )z
    Returns true if a loop may ends up in a break statement.

    Args:
        loop (astroid.For, astroid.While): the loop node inspected.

    Returns:
        bool: True if the loop may ends up in a break statement, False otherwise.
    c                s   g | ]}| kr|qS r   r   )r=   _node)loopr   r   r?   	  s   z%_loop_exits_early.<locals>.<listcomp>)
skip_klassc             3   s   | ]}t | kr|V  qd S )N)rb   )r=   rc   )inner_loop_nodesr   r   	<genexpr>  s   z$_loop_exits_early.<locals>.<genexpr>)rI   rU   r_   FunctionDefClassDefrL   r/   Break)rd   ra   Zdefinition_nodesr   )rf   rd   r   _loop_exits_early   s    


rk   c             C   s.   | d k	o,| j d k	o,| j tko,|dkp,|tjkS )Nr   )	lastgroupEXEMPT_NAME_CATEGORIESr   INFERENCE_FAILURE)match	node_type
confidencer   r   r   _is_multi_naming_match  s    

rr   zbuiltins.propertyc             C   s>   t h}t }| dk	r6|j| j |jdd | jD  ||fS )zReturns a tuple of property classes and names.

    Property classes are fully qualified, such as 'abc.abstractproperty' and
    property names are the actual names, such as 'abstract_property'.
    Nc             s   s   | ]}|j d dd V  qdS )r:      N)rsplit)r=   propr   r   r   rg   +  s    z"_get_properties.<locals>.<genexpr>)BUILTIN_PROPERTYr@   updateproperty_classes)configry   property_namesr   r   r   _get_properties   s    r|   c             C   s   t |\}}| j sdS t| r$dS | jr4| jj}ng }xL|D ]D}t|tjsdt|tjr>|j	|kr>t
j|}|r>|j |kr>dS q>W dS )a\  Determine the name type whose regex the a function's name should match.

    :param node: A function node.
    :type node: astroid.node_classes.NodeNG
    :param config: Configuration from which to pull additional property classes.
    :type config: :class:`optparse.Values`

    :returns: One of ('function', 'method', 'attr')
    :rtype: str
    r   r   r   )r|   	is_methodr   
decoratorsr	   rG   rI   Name	Attributeattrnamer   
safe_inferqname)rQ   rz   ry   r{   r~   	decoratorinferredr   r   r   _determine_function_name_type0  s     



r   c             C   s   t tj| dkS )z
    Determine if the given `node` has abstract methods.

    The methods should be made abstract by decorating them
    with `abc` decorators.
    r   )lenr   Zunimplemented_abstract_methods)rQ   r   r   r   _has_abstract_methodsU  s    r   c       
      C   sN  i }xdD ]}y|| }W n t k
r6   tj Y nX i ||< |dkr
y0||d|   }|d | }d| || d	< W n  t k
r   d
|| d	< Y nX y(|d|  d | }d| || d< W q
 t k
r   d
|| d< Y q
X q
W d}xFdD ]>}|| }	||t|	d
d
|| jd	d|| jddf7 } qW | jtj|ddd dS )zymake a report of

    * percentage of different types documented
    * percentage of different types with a bad name
    r   r   r   r   r   undocumented_g      Y@z%.2fZpercent_documentedZNCbadname_Zpercent_badnametypenumber
old number
difference%documented%badname0   rs   )childrencolsZrheadersN)r   r   r   r   )r   r   r   r   r   r   )r   r   r   r   )KeyErrorr   ZEmptyReportErrorstrgetappendreporter_nodesZTable)
sectstats_Z
nice_statsrp   totalZ
documentedpercentlinesnewr   r   r   report_by_type_stats_  s<    

r   c             C   s@   | j r<x4| j jD ](}t|tjrt|jdd| jkrdS qW dS )zreturn True if the object is a method redefined via decorator.

    For example:
        @property
        def x(self): return self._x
        @x.setter
        def x(self, value): self._x = value
    rP   NTF)r~   r	   rG   rI   r   r`   exprrP   )rQ   r   r   r   r   redefined_by_decorator  s    	r   c               @   s   e Zd ZejZdZdS )_BasicCheckerbasicN)r    r!   r"   r   IAstroidChecker__implements__rP   r   r   r   r   r     s   r   c               @   s  e Zd Zdkdldmdndodpdddddqifdrdsdtdudvdwdxdydzd{d6d7d8d9d|ifd;Zejdd<d= Zd>d? Zejd%d(d@dA Zejd+dBdC Z	ejdddddd.d7dDdE Z
e
ZdFdG ZdHdI ZejddJdK ZejddLdM ZejddNdO Zejdd1dPdQ ZejddRdS Zejd"dTdU Zejd"dVdW ZejddXdY ZdZd[ Zejd4d\d] Zejdd^d_ Zd`da Zdbdc Zddde Zdfdg Zdhdi ZdjS )}BasicErrorChecker__init__ method is a generatorinit-is-generator^Used when the special class method __init__ is turned into a generator by a yield in its body.Explicit return in __init__return-in-initIUsed when the special class method __init__ has an explicit return value.%s already defined line %sfunction-redefined3Used when a function / class / method is redefined.%r not properly in loopnot-in-loop=Used when break or continue keywords are used outside a loop.Return outside functionreturn-outside-functionEUsed when a "return" statement is found outside a function or method.Yield outside functionyield-outside-functionDUsed when a "yield" statement is found outside a function or method.z%Return with argument inside generatorzreturn-arg-in-generatorzUsed when a "return" statement with an argument is found outside in a generator function or method (e.g. with some "yield" statements).Z
maxversion   #Use of the non-existent %s operatornonexistent-operatorzUsed when you attempt to use the C-style pre-increment or pre-decrement operator -- and ++, which doesn't exist in Python.1Duplicate argument name %s in function definitionduplicate-argument-nameCDuplicate argument names in function definitions are syntax errors.4Abstract class %r with abstract methods instantiatedabstract-class-instantiatedeUsed when an abstract class with `abc.ABCMeta` as metaclass has abstract methods and is instantiated.-Else clause on loop without a break statementuseless-else-on-loopLoops should only have an else clause if they can exit early with a break statement, otherwise the statements under else should be on the same scope as the loop itself..More than one starred expression in assignmenttoo-many-star-expressionshEmitted when there are more than one starred expressions (`*x`) in an assignment. This is a SyntaxError.4Starred assignment target must be in a list or tupleinvalid-star-assignment-targetFEmitted when a star expression is used as a starred assignment target.4Can use starred expression only in assignment targetstar-needs-assignment-targetCEmitted when a star expression is not used in an assignment target.Name %r is nonlocal and globalnonlocal-and-global0Emitted when a name is both nonlocal and global.0'continue' not supported inside 'finally' clausecontinue-in-finally]Emitted when the `continue` keyword is found inside a finally clause, which is a SyntaxError.&nonlocal name %s found without bindingnonlocal-without-binding^Emitted when a nonlocal variable does not have an attached name somewhere in the parent scopesz+Name %r is used prior to global declarationzused-prior-global-declarationzcEmitted when a name is used prior a global declaration, which results in an error since Python 3.6.Z
minversionr   )ZE0100ZE0101ZE0102ZE0103ZE0104ZE0105ZE0106ZE0107ZE0108ZE0110ZW0120ZE0112ZE0113ZE0114ZE0115ZE0116ZE0117ZE0118c             C   s   | j d| d S )Nr   )_check_redefinition)selfrQ   r   r   r   visit_classdef  s    z BasicErrorChecker.visit_classdefc             C   sH   d}x:|j  D ].}t|tjr(| j|S t|tjr|d7 }qW |dkS )Nr   rs   )ZiteredrG   rI   Tuple_too_many_starred_for_tupleStarred)r   Zassign_tupleZstarred_countelemr   r   r   r     s    
z-BasicErrorChecker._too_many_starred_for_tuplec             C   sV   |j d }t|j d tjr*| jd|d t|tjs:d S | j|rR| jd|d d S )Nr   zinvalid-star-assignment-target)rQ   ztoo-many-star-expressions)targetsrG   rI   r   add_messager   r   )r   rQ   Zassign_targetr   r   r   visit_assign  s    

zBasicErrorChecker.visit_assignc             C   sr   t |jtjrdS t |jtjtjtjtjfr2dS |j }t |tj	sJdS |j
|ks`|j
j|rn| jd|d dS )z@Check that a Starred expression is used in an assignment target.Nzstar-needs-assignment-target)rQ   )rG   rH   rI   CallListr   SetDictZ	statementAssignvalueZ	parent_ofr   )r   rQ   stmtr   r   r   visit_starred%  s    zBasicErrorChecker.visit_starredc       	      C   sF  | j | | j| t| rBtj| rB| j|j r:dp<d| |jtj	tj
tjfd}|j r|jdkr|j r| jd|d n.dd |D }td	d
 |D r| jd|d tjt}td |jj|jjg}x$tjj|D ]}||j j| qW xH|j D ]<}t|dkrx&|D ]}| jd|j||jfd qW qW d S )Nr   r   )re   __init__zinit-is-generator)rQ   c             S   s   g | ]
}|j qS r   )r   )r=   rr   r   r   r?   Q  s    z7BasicErrorChecker.visit_functiondef.<locals>.<listcomp>c             s   s   | ]}t j|s|V  qd S )N)r   Zis_none)r=   vr   r   r   rg   S  s    z6BasicErrorChecker.visit_functiondef.<locals>.<genexpr>zreturn-in-initrs   zduplicate-argument-name)linerQ   args)_check_nonlocal_and_global_check_name_used_prior_globalr   r   Z(is_registered_in_singledispatch_functionr   r}   rL   rI   Returnrh   ri   rP   Zis_generatorr   r/   collectionsdefaultdictrB   filterr   
kwonlyargs	itertoolschainfrom_iterabler   valuesr   lineno)	r   rQ   Zreturnsr   Zarg_clusters	argumentsargZargument_duplicatesr   r   r   r   visit_functiondef9  s4    




z#BasicErrorChecker.visit_functiondefc                s    fdd j tjD }|s"d S x^ j tjD ]N}|j  k	rBq0|j}|j|}|sXq0|j}|r0||jkr0| jd||fd q0W d S )Nc                s*   i | ]"}|j D ]}|j  kr||qqS r   )rO   scope)r=   childrP   )rQ   r   r   
<dictcomp>k  s   
zCBasicErrorChecker._check_name_used_prior_global.<locals>.<dictcomp>zused-prior-global-declaration)rQ   r   )	rL   rI   Globalr   r   rP   r   
fromlinenor   )r   rQ   Zscope_globals	node_namerP   Zcorresponding_globalZglobal_linenor   )rQ   r   r   i  s    

z/BasicErrorChecker._check_name_used_prior_globalc                s    fddt jj}t|fdd jtjD }|s>dS t|fdd jtjD }x$|j|D ]}| j	d|f d qlW dS )	z.Check that a name is both nonlocal and global.c                s   | j   kS )N)r   )rR   )rQ   r   r   
same_scope  s    z@BasicErrorChecker._check_nonlocal_and_global.<locals>.same_scopec             3   s   | ]} |r|j V  qd S )N)rO   )r=   r  )r  r   r   rg     s   z?BasicErrorChecker._check_nonlocal_and_global.<locals>.<genexpr>Nc             3   s   | ]} |r|j V  qd S )N)rO   )r=   r  )r  r   r   rg     s   znonlocal-and-global)r   rQ   )
r   r   r   r@   rL   rI   Nonlocalr  intersectionr   )r   rQ   Z	from_iter	nonlocalsglobal_varsrP   r   )rQ   r  r   r     s    

z,BasicErrorChecker._check_nonlocal_and_globalc             C   s"   t |j tjs| jd|d d S )Nzreturn-outside-function)rQ   )rG   framerI   rh   r   )r   rQ   r   r   r   visit_return  s    zBasicErrorChecker.visit_returnc             C   s   | j | d S )N)_check_yield_outside_func)r   rQ   r   r   r   visit_yield  s    zBasicErrorChecker.visit_yieldc             C   s   | j | d S )N)r  )r   rQ   r   r   r   visit_yieldfrom  s    z!BasicErrorChecker.visit_yieldfromc             C   s   | j |d d S )Ncontinue)_check_in_loop)r   rQ   r   r   r   visit_continue  s    z BasicErrorChecker.visit_continuec             C   s   | j |d d S )Nbreak)r  )r   rQ   r   r   r   visit_break  s    zBasicErrorChecker.visit_breakc             C   s   | j | d S )N)_check_else_on_loop)r   rQ   r   r   r   	visit_for  s    zBasicErrorChecker.visit_forc             C   s   | j | d S )N)r  )r   rQ   r   r   r   visit_while  s    zBasicErrorChecker.visit_whilec             C   s@   |j dkr<t|jtjr<|jj |j kr<| jd||j d d dS )z9check use of the non-existent ++ and -- operator operatorz+-znonexistent-operator   )rQ   r   N)oprG   operandrI   UnaryOpr   )r   rQ   r   r   r   visit_unaryop  s    
zBasicErrorChecker.visit_unaryopc             C   sz   |j  }xN|jd krP t|tjtjfs>| jd|f|d d S ||jkrT|jj  }q
d S t|tjsv| jd|f|d d S )Nznonlocal-without-binding)r   rQ   )r   rH   rG   rI   ri   rh   r   locals)r   rQ   rP   Zcurrent_scoper   r   r   _check_nonlocal_without_binding  s    


z1BasicErrorChecker._check_nonlocal_without_bindingc             C   s    x|j D ]}| j|| qW d S )N)rO   r  )r   rQ   rP   r   r   r   visit_nonlocal  s    z BasicErrorChecker.visit_nonlocalc             C   s@   y$x|j j D ]}| j|| qW W n tjk
r:   dS X dS )zS Check instantiating abstract class with
        abc.ABCMeta as metaclass.
        N)funcinfer!_check_inferred_class_is_abstractrI   InferenceError)r   rQ   r   r   r   r   
visit_call  s
    zBasicErrorChecker.visit_callc             C   s   t |tjsd S tj|}||kr&d S t|}|s6d S |j }|d kr~x2|j D ]&}|j dkrP| j	d|j
f|d P qPW d S |j tkr| j	d|j
f|d d S )Nzabc.ABCzabstract-class-instantiated)r   rQ   )rG   rI   ri   r   Znode_frame_classr   	metaclass	ancestorsr   r   rP   ABC_METACLASSES)r   r   rQ   klassZabstract_methodsr%  ancestorr   r   r   r"    s&    
z3BasicErrorChecker._check_inferred_class_is_abstractc             C   s(   t |j tjtjfs$| jd|d d S )Nzyield-outside-function)rQ   )rG   r  rI   rh   Lambdar   )r   rQ   r   r   r   r    s    z+BasicErrorChecker._check_yield_outside_funcc             C   s0   |j r,t| r,| jd||j d jd d dS )z>Check that any loop with an else clause has a break statement.zuseless-else-on-loopr   rs   )rQ   r   N)r^   rk   r   r   )r   rQ   r   r   r   r    s
    z%BasicErrorChecker._check_else_on_loopc             C   s   |j }xr|rxt|tjtjfr,||jkr,dS t|tjtjfr@P t|tjrp||j	krpt|tj
rp| jd|d |j }qW | jd||d dS )z/check that a node is inside a for or while loopNzcontinue-in-finally)rQ   znot-in-loop)rQ   r   )rH   rG   rI   rU   r_   r^   ri   rh   Z
TryFinally	finalbodyContinuer   )r   rQ   r  rc   r   r   r   r     s    


z BasicErrorChecker._check_in_loopc       
      C   s  |j j }|j|j }tdd |D |}||k	o>tj|| rt|tjr\|jt	kr\dS t
j|rjdS y|j|}W n tk
r   Y nBX x>|d| D ].}t
j|}|rt|tjr|j tkrdS qW tj| ddd}	|	r|	j|jrdS | jd|||jfd dS )z:check for redefinition of a function / method / class namec             s   s   | ]}t j|s|V  qd S )N)r   is_overload_stub)r=   localr   r   r   rg   <  s    z8BasicErrorChecker._check_redefinition.<locals>.<genexpr>Nzdummy-variables-rgx)defaultzfunction-redefined)rQ   r   )rH   r  r  rP   nextrI   Zare_exclusiverG   ri   REDEFINABLE_METHODSr   r-  index
ValueErrorr   Instancer   TYPING_FORWARD_REF_QNAME
lint_utilsZget_global_optionro   r   r  )
r   Z	redeftyperQ   Zparent_frameZredefinitionsZdefined_selfZredefinition_indexZredefinitionr   Zdummy_variables_rgxr   r   r   r   5  s:    



z%BasicErrorChecker._check_redefinitionN)r   r   r   )r   r   r   )r   r   r   )r   r   r   )r   r   r   )r   r   r   )r   r   )r   r   r   )r   r   r   )r   r   r   )r   r   r   )r   r   r   )r   r   r   )r   r   r   )r   r   r   )r   r   r   )r   r   r   )r   r   )r    r!   r"   msgsr   check_messagesr   r   r   r   r   visit_asyncfunctiondefr   r   r  r  r  r  r  r  r  r  r  r  r$  r"  r  r  r  r   r   r   r   r   r     s                                   	'
%r   c               @   s(  e Zd ZdZejZdZddddddddddddddddddd9Zd:d;e	ffZ
d<d= Zd>d? Zejd(d+d@dA Zejd(d+dBdC Zejd(d+dDdE ZdFdG ZdHdI ZdJdK Zejd
dddLdM ZedNdO ZedPdQ ZejddRdS ZejddTdU ZeZdVdW ZejdddXdY ZejddZd[ Zejddd\d] Zejdd^d_ Z ejdd`da Z!dbdc Z"ejddd4d7ddde Z#ejd"dfdg Z$ejddhdi Z%djdk Z&dldm Z'dndo Z(f fdpdqZ)drds Z*ejd%dtdu Z+dvdw Z,dxdy Z-ejd.d1dzd{ Z.ejd1d|d} Z/d~S )BasicCheckera*  checks for :
    * doc strings
    * number of arguments, local variables, branches, returns and statements in
    functions, methods
    * required module attributes
    * dangerous default values as arguments
    * redefinition of function / method / class
    * uses of the global statement
    r   Unreachable codeunreachablebUsed when there is some code behind a "return" or "raise" statement, which will never be accessed.&Dangerous default value %s as argumentdangerous-default-value_Used when a mutable value as list or dictionary is detected in a default value for an argument.!Statement seems to have no effectpointless-statementEUsed when a statement doesn't have (or at least seems to) any effect.String statement has no effectpointless-string-statementUsed when a string is used as a statement (which of course has no effect). This is a particular case of W0104 with its own message so you can easily disable it if you're using those strings as documentation, instead of comments.&Expression "%s" is assigned to nothingexpression-not-assignedqUsed when an expression that is not a function call is assigned to nothing. Probably something else was intended.Lambda may not be necessaryunnecessary-lambdaUsed when the body of a lambda expression is a function call on the same argument list as the lambda itself; such lambda expressions are in all but a few cases replaceable with the function being called in the body of the lambda.Duplicate key %r in dictionaryduplicate-keyDUsed when a dictionary expression binds the same key multiple times.Use of exec	exec-used~Used when you use the "exec" statement (function for Python 3), to discourage its usage. That doesn't mean you cannot use it !Use of eval	eval-usedUsed when you use the "eval" function, to discourage its usage. Consider using `ast.literal_eval` for safely evaluating strings containing Python expressions from untrusted sources. 3%s statement in finally block may swallow exceptionlost-exceptionUsed when a break or a return statement is found inside the finally clause of a try...finally block: the exceptions raised in the try clause will be silently swallowed instead of being re-raised.;Assert called on a 2-item-tuple. Did you mean 'assert x,y'?assert-on-tupleA call of assert on a tuple will always evaluate to true if the tuple is not empty, and will always evaluate to false if it is.?Following "as" with another context manager looks like a tuple.confusing-with-statement2  Emitted when a `with` statement component returns multiple values and uses name binding with `as` only for a part of those values, as in with ctx() as a, b. This can be misleading, since it's not clear if the context manager returns a tuple or if the node without a name binding is another context manager.3Using a conditional statement with a constant valueusing-constant-testEmitted when a conditional statement (If or ternary if) uses a constant value for its test. This might not be what the user intended to do.gUsing a conditional statement with potentially wrong function or method call due to missing parentheses$missing-parentheses-for-call-in-testsEmitted when a conditional statement (If or ternary if) seems to wrongly call a function due to missing parentheses(Assigning the same variable %r to itselfself-assigning-variable<Emitted when we detect that a variable is assigned to itself$Redeclared variable %r in assignmentredeclared-assigned-nameMEmitted when we detect that a variable was redeclared in the same assignment./The first reversed() argument is not a sequencebad-reversed-sequenceUsed when the first argument to reversed() builtin isn't a sequence (does not implement __reversed__, nor __getitem__ and __len__$format function is not called on strmisplaced-format-functionEmitted when format function is not called on str object. e.g doing print("value: {}").format(123) instead of print("value: {}".format(123)). This might not be what the user intended to do.)ZW0101ZW0102ZW0104ZW0105ZW0106ZW0108ZW0109ZW0122ZW0123ZW0150ZW0199ZW0124ZW0125ZW0126ZW0127ZW0128ZE0111ZE0119ZRP0101zStatistics by typec             C   s   t j| | d | _d | _d S )N)r   r   r   _tryfinallys)r   linterr   r   r   r     s    zBasicChecker.__init__c             C   s    g | _ | jjddddd| _dS )z2initialize visit variables and statistics
        r   )r   r   r   class_N)rq  rr  	add_statsr   )r   r   r   r   open  s    zBasicChecker.openc             C   s   | j ||j d S )N)_check_using_constant_testtest)r   rQ   r   r   r   visit_if  s    zBasicChecker.visit_ifc             C   s   | j ||j d S )N)rv  rw  )r   rQ   r   r   r   visit_ifexp  s    zBasicChecker.visit_ifexpc             C   s&   |j r"x|j D ]}| j|| qW d S )N)Zifsrv  )r   rQ   Zif_testr   r   r   visit_comprehension  s    z BasicChecker.visit_comprehensionc       
      C   s0  t jt jjt jt jt jt jjt j	t j
t jf	}t jt jt jf}t jt jt jt jt jf}d }t|t jf| | }t||stj|}|r| jd|d nt||r,d }t|t jr|j }nt|t jr|j|}|ry,x&|D ]}	|	t jkr| jd|d P qW W n t jk
r   Y nX | jd|d d S )Nzusing-constant-test)rQ   z$missing-parentheses-for-call-in-test)rI   ModuleZscoped_nodesrY   r*  rh   ri   bases	GeneratorZUnboundMethodBoundMethodr   r   r   r   BinOpBoolOpr  	SubscriptrG   Constr   r   r   Zinfer_call_resultUninferabler#  )
r   rQ   rw  Zconst_nodesstructsZexcept_nodesr   emitZcall_inferredZinf_callr   r   r   rv    sJ    







z'BasicChecker._check_using_constant_testc             C   s   | j d  d7  < dS )z<check module name, docstring and required arguments
        r   rs   N)r   )r   r   r   r   r   visit_module>  s    zBasicChecker.visit_modulec             C   s   | j d  d7  < dS )zWcheck module name, docstring and redefinition
        increment branch counter
        r   rs   N)r   )r   rQ   r   r   r   r   C  s    zBasicChecker.visit_classdefc             C   s"  |j }t|tjrt|j tr|j }t|tjtjtjfrt|tjrT|j	dkrTn2|j
 }|dk	r|j |krt|tjtjfrdS | jd|d dS t|tjtjtjtjfst|jtjr|jj|gkst|tjr|j tkrdS t|jtjr| jd||j d n| jd|d dS )z3Check for various kind of statements without effectr   Nzpointless-string-statement)rQ   zexpression-not-assigned)rQ   r   zpointless-statement)r   rG   rI   r  r   r   ri   r{  rh   rP   Zprevious_siblingr   	AnnAssignr   YieldAwaitEllipsisr   rH   Z	TryExceptbodyr/   rL   	as_string)r   rQ   r   r   Zsiblingr   r   r   
visit_exprI  s0    
zBasicChecker.visit_exprc             c   sJ   xD|D ]<}t |tjr<t |jtjrB|jj| jjkrB|V  q|V  qW d S )N)rG   rI   r   r   r   rP   r   vararg)rQ   	call_argsr   r   r   r   _filter_vararg~  s    
zBasicChecker._filter_varargc             C   s>   | sdS x0| D ](}t |jtjr2|jj|kr6dS qdS qW dS )NTF)rG   r   rI   r   rP   )r   Zvariadic_namer   r   r   r   _has_variadic_argument  s    
z#BasicChecker._has_variadic_argumentc       	      C   sd  |j jrdS |j}t|tjs"dS t|jjtjrHt|jjjtjrHdS t	j
|}t|j j }t| j||j }|j jr| j|j|j jrdS |j jr| j|j|j jrdS n
|jrdS |jrdd |j jD }t|t|jkrdS t|jj|rdS t|t|krdS x<t||D ].\}}t|tjs6dS |j|jkrdS qW | jd|j|d dS )z6check whether or not the lambda is suspicious
        Nc             S   s   h | ]
}|j qS r   )rP   )r=   keywordr   r   r   	<setcomp>  s    z,BasicChecker.visit_lambda.<locals>.<setcomp>zunnecessary-lambda)r   rQ   )r   defaultsr  rG   rI   r   r   r   r   r   Z	from_callrB   r  kwargr  kwargsr  Zstarargskeywordsr   Zkeyword_argumentsr@   r   zipr   rP   r   r  )	r   rQ   callZ	call_siteZordinary_argsZnew_call_argsZlambda_kwargsr   Z
passed_argr   r   r   visit_lambda  sB    

zBasicChecker.visit_lambdac             C   s,   | j |j rdnd  d7  < | j| dS )zdcheck function name, docstring, arguments, redefinition,
        variable names, max locals
        r   r   rs   N)r   r}   _check_dangerous_default)r   rQ   r   r   r   r     s    zBasicChecker.visit_functiondefc             C   s   dd }x|j jD ]}yt|j }W n tjk
r>   wY nX t|tjr|j t	kr||krnt	|j  }ntt|tjs||r||r|j
 }qt|tjrd|j|j f }qd|j |j f }nd|j t	|j  f }| jd||fd qW d S )Nc             S   s   t | tjtjtjfS )N)rG   rI   r   r   r   )nr   r   r   <lambda>  s    z7BasicChecker._check_dangerous_default.<locals>.<lambda>z	%s() (%s)z%s (%s)zdangerous-default-value)rQ   r   )r   r  r0  r!  rI   r#  rG   r4  r   DEFAULT_ARGUMENT_SYMBOLSZpytyper   rP   r  r   )r   rQ   Zis_iterabler/  r   msgr   r   r   r    s(    
z%BasicChecker._check_dangerous_defaultc             C   s    | j | | j|dtjf dS )z1 - check is the node has a right sibling (if so, that's some
        unreachable code)
        2 - check is the node is inside the finally clause of a try...finally
        block
        returnN)_check_unreachable_check_not_in_finallyrI   rh   )r   rQ   r   r   r   r    s    
zBasicChecker.visit_returnc             C   s   | j | dS )z\check is the node has a right sibling (if so, that's some unreachable
        code)
        N)r  )r   rQ   r   r   r   r    s    zBasicChecker.visit_continuec             C   s$   | j | | j|dtjtjf dS )z1 - check is the node has a right sibling (if so, that's some
        unreachable code)
        2 - check is the node is inside the finally clause of a try...finally
        block
        r  N)r  r  rI   rU   r_   )r   rQ   r   r   r   r    s    
zBasicChecker.visit_breakc             C   s   | j | dS )z\check if the node has a right sibling (if so, that's some unreachable
        code)
        N)r  )r   rQ   r   r   r   visit_raise#  s    zBasicChecker.visit_raisec             C   s   | j d|d dS )z'just print a warning on exec statementsz	exec-used)rQ   N)r   )r   rQ   r   r   r   
visit_exec*  s    zBasicChecker.visit_execc             C   s   t |jtjsd S |jjdkr"d S tj|jj}|tjkr>d S |s|jj}t |tj	sZd S t |jtj
r|jjdkr| jd|d d S )Nformatprintzmisplaced-format-function)rQ   )rG   r   rI   r   r   r   r   r   r  r   r   rP   r   )r   Z	call_noder   Z	call_exprr   r   r    _check_misplaced_format_function/  s    
z-BasicChecker._check_misplaced_format_functionc             C   s~   | j | t|jtjrz|jj}||j kp6||j ksz|dkrP| jd|d n*|dkrd| j	| n|dkrz| jd|d dS )zovisit a Call node -> check if this is not a blacklisted builtin
        call and check for * or ** use
        execz	exec-used)rQ   reversedevalz	eval-usedN)
r  rG   r   rI   r   rP   r  rootr   _check_reversed)r   rQ   rP   r   r   r   r$  D  s    
zBasicChecker.visit_callc             C   s:   |j dkr6t|jtjr6t|jjdkr6| jd|d dS )z0check the use of an assert statement on a tuple.Nr  zassert-on-tuple)rQ   )ZfailrG   rw  rI   r   r   eltsr   )r   rQ   r   r   r   visit_assertX  s    
zBasicChecker.visit_assertc             C   sR   t  }xF|jD ]<\}}t|tjr|j}||kr@| jd||d |j| qW dS )z!check duplicate key in dictionaryzduplicate-key)rQ   r   N)r@   itemsrG   rI   r  r   r   add)r   rQ   keyskr   keyr   r   r   
visit_dictb  s    zBasicChecker.visit_dictc             C   s   | j j| dS )zupdate try...finally flagN)rq  r   )r   rQ   r   r   r   visit_tryfinallym  s    zBasicChecker.visit_tryfinallyc             C   s   | j j  dS )zupdate try...finally flagN)rq  pop)r   rQ   r   r   r   leave_tryfinallyq  s    zBasicChecker.leave_tryfinallyc             C   s"   |j  }|dk	r| jd|d dS )zcheck unreachable codeNr<  )rQ   )Znext_siblingr   )r   rQ   Zunreach_stmtr   r   r   r  u  s    zBasicChecker._check_unreachablec             C   s`   | j s
dS |j}|}xF|rZt|| rZt|drN||jkrN| jd||d dS |}|j}qW dS )zcheck that a node is not inside a finally clause of a
        try...finally statement.
        If we found before a try...finally bloc a parent which its type is
        in breaker_classes, we skip the whole check.Nr+  zlost-exception)rQ   r   )rq  rH   rG   hasattrr+  r   )r   rQ   r  Zbreaker_classes_parentrc   r   r   r   r  {  s    z"BasicChecker._check_not_in_finallyc          %   C   s  yt jt j|dd}W n t jk
r0   Y nX |tjkr@dS |dkrt|jd tjryt	|jd j
j }W n tjk
r   dS X t|dddkrt j|r| jd|d dS t|tjtjfrdS t|tjrX|jjdkot j|jr| jd|d dS td	d
 |jj D rXy|jt  W n$ tk
rR   | jd|d Y nX dS t|drxhtD ]B}x:|D ]0}y|j| W n tjk
r   P Y nX qtW P qjW | jd|d n| jd|d dS )z5 check that the argument to `reversed` is a sequence r   )positionNrP   iterzbad-reversed-sequence)rQ   rA   c             s   s"   | ]}|j d kotj|V  qdS )rA   N)rP   r   is_builtin_object)r=   r)  r   r   r   rg     s   z/BasicChecker._check_reversed.<locals>.<genexpr>r`   )r   r   Zget_argument_from_callZNoSuchArgumentErrorrI   r  rG   r   r   r0  r   r!  r#  r`   r  r   r   r   r4  Z_proxiedrP   r/   r&  r  REVERSED_PROTOCOL_METHODr   r  REVERSED_METHODSZNotFoundError)r   rQ   r   r   methodsmethr   r   r   r    sT    



zBasicChecker._check_reversedc             C   sj   |j }|rfxZt||dd  D ]D\}}t|d tjr|d d krt|d tj r| jd|d qW d S )Nrs   r   zconfusing-with-statement)rQ   )r  r  rG   rI   
AssignNamer   r   )r   rQ   pairsZ	prev_pairpairr   r   r   
visit_with  s    zBasicChecker.visit_withc       	      C   s  |j  }|j}g }|j}t|d tjrBt|dkr8d S |d j}t|jtj	rjt|dkr`d S |jg}n:t|jtjrt|jj}t||ks|dkrd S |jj}xjt
||D ]\\}}t|tj	sqt|tjsqt|tjr|j|krq|j|jkr| jd|jf|d qW d S )Nr   rs   zself-assigning-variable)r   rQ   )r   r  r   rG   rI   r   r   r  r   r   r  r  ri   rP   r   )	r   rQ   r   Zscope_localsZ	rhs_namesr   Z	rhs_counttargetZlhs_namer   r   r   _check_self_assigning_variable  s6    

z+BasicChecker._check_self_assigning_variablec             C   s   x|D ]}t |tjsqg }xJ|jD ]@}t |tjrB| j|g q$t |tjr$|jdkr$|j|j q$W tj	|}x.|j
 D ]"\}}|dkr|| jd|f|d q|W qW d S )Nr   rs   zredeclared-assigned-name)r   rQ   )rG   rI   r   r  _check_redeclared_assign_namer  rP   r   r   Countermost_commonr   )r   r   r  Zfound_nameselementrO   rP   countr   r   r   r    s    

z*BasicChecker._check_redeclared_assign_namec             C   s   | j | | j|j d S )N)r  r  r   )r   rQ   r   r   r   r     s    
zBasicChecker.visit_assignc             C   s   | j |jg d S )N)r  r  )r   rQ   r   r   r   r    s    zBasicChecker.visit_forN)r;  r<  r=  )r>  r?  r@  )rA  rB  rC  )rD  rE  rF  )rG  rH  rI  )rJ  rK  rL  )rM  rN  rO  )rP  rQ  rR  )rS  rT  rU  )rV  rW  rX  )rY  rZ  r[  )r\  r]  r^  )r_  r`  ra  )rb  rc  rd  )re  rf  rg  )rh  ri  rj  )rk  rl  rm  )rn  ro  rp  )0r    r!   r"   r%   r   r   r   rP   r7  r   Zreportsr   ru  r   r8  rx  ry  rz  rv  r  r   r  staticmethodr  r  r  r   r9  r  r  r  r  r  r  r  r$  r  r  r  r  r  r  r  r  r  r  r   r  r   r   r   r   r:  g  s   	                                    24=&
;&r:  r   r   r   r   r   r   r   r   r   r   Zconstant	attributezclass attributezinline iteration)
r   r   r   r   r   r   r   r   r   r   r,   r.   r-   r/   c           	   C   s   g } xt tD ]t}t| }t| }|jdd}| jd|f |dttj dd|f df | jd|f d d	d
d||f df qW t	| S )Nr   -z%s-naming-stylechoicez<style>z'Naming style matching correct %s names.)r/  r   choicesmetavarhelpz%s-rgxregexpz<regexp>zHRegular expression matching correct %s names. Overrides %s-naming-style.)r/  r   r  r  )
sortedKNOWN_NAME_TYPESHUMAN_READABLE_TYPESDEFAULT_NAMING_STYLESreplacer   rB   NAMING_STYLESr  r[   )Zname_optionsr   Zhuman_readable_nameZdefault_styler   r   r   _create_naming_optionsD  s*    
r  c            
   @   sF  e Zd ZdMdNdOd
ZddPddddfddQddddfdf ddd dfd!d"d#d$d%dfd&dRdd(d)dffe  ZdSd,d-hiZd.d/ Zd0d1 Zd2d3 Z	e
jddd4d5 Zd6d7 Ze
jdddd8d9 Ze
jdddd:d; ZeZe
jddd<d= Ze
jdddd>d? Zd@dA ZdBdC ZdDdE ZejfdFdGZdHdI ZedJdK ZdLS )TNameCheckerBlack listed name "%s"blacklisted-nameDUsed when the name is listed in the black list (unauthorized names)."%s name "%s" doesn't conform to %sinvalid-nameiUsed when the name doesn't conform to naming rules associated to its type (constant, variable, class...).*Name %s will become a keyword in Python %sassign-to-new-keywordaUsed when assignment will become invalid in future Python release due to introducing new keyword.)ZC0102ZC0103ZW0111z
good-namesijr  exRunr   csvz<names>zJGood variable names which should always be accepted, separated by a comma.)r/  r   r  r  z	bad-namesfoobarbaztototututatazHBad variable names which should always be refused, separated by a comma.z
name-groupz<name1:name2>zrColon-delimited sets of names that determine each other's naming style when the name regexes allow several styles.zinclude-naming-hintFZynz<y_or_n>z?Include a hint for the correct naming format with invalid-name.zproperty-classesabc.abstractpropertyz<decorator names>zList of decorators that produce properties, such as abc.abstractproperty. Add to this list to register other decorators that produce valid properties. These decorators are taken in consideration only for invalid-name.r      asyncawaitc             C   s.   t j| | i | _i | _i | _i | _i | _d S )N)r   r   Z_name_category_name_group
_bad_names_name_regexps_name_hints)r   rr  r   r   r   r     s    zNameChecker.__init__c             C   st   | j jddddddddddd
| _x4| jjD ](}x"|jdD ]}d|f | j|< q<W q,W | j \}}|| _|| _	d S )Nr   )
Zbadname_moduleZbadname_classZbadname_functionZbadname_methodZbadname_attrZbadname_constZbadname_variableZbadname_inlinevarZbadname_argumentZbadname_class_attribute:zgroup_%s)
rr  rt  r   rz   
name_groupsplitr  _create_naming_rulesr  r  )r   groupr   regexpshintsr   r   r   ru    s"    
zNameChecker.openc             C   s   i }i }xt D ]x}d|f }t| j|}t| j|||< d|f }t| j|d }|d k	rb|||< |d k	rzd|j ||< qd| ||< qW ||fS )Nz%s_naming_stylez%s_rgxz
%r patternz%s naming style)r  r`   rz   r  r   pattern)r   r  r  r   Znaming_style_option_nameZnaming_style_nameZcustom_regex_setting_nameZcustom_regexr   r   r   r    s    


z NameChecker._create_naming_rulesc             C   s$   | j d|jjdd | i | _d S )Nr   r:   rs   rt   )_check_namerP   r  r  )r   rQ   r   r   r   r    s    zNameChecker.visit_modulec       	      C   s   x| j j D ]}t|dk rqtjt}tj}x0|j D ]$}|t| j| t	t||}q8W t|| dkrt
|| dd d}tj|dd   }n|| d }x|D ]}| j|  qW qW d S )Nr  rs   c             S   s   t dd | D S )Nc             s   s   | ]}|d  j V  qdS )r   N)r   )r=   warningr   r   r   rg     s    z=NameChecker.leave_module.<locals>.<lambda>.<locals>.<genexpr>)min)r  r   r   r   r    s    z*NameChecker.leave_module.<locals>.<lambda>)r  r   )r  r   r   r   r   rB   sysmaxsizer   r  r  r   r   _raise_name_warning)	r   rQ   Z
all_groupsgroupsZmin_warningsr  Zby_linewarningsr   r   r   r   leave_module  s     

zNameChecker.leave_modulec             C   sZ   | j |j| | jd|j| x6|jj D ](\}}t|j|s*| jd||d  q*W d S )Nr   r   r   )&_check_assign_to_new_keyword_violationrP   r   Zinstance_attrsr  r/   Zinstance_attr_ancestors)r   rQ   r   Zanodesr   r   r   r     s
    zNameChecker.visit_classdefc             C   s   | j |j| tj}|j rPtj|jj |jr4d S tj	|jj rJtj
ntj}| jt|| jd|j|| |jj}|d k	r| j|| d S )N)rz   )r	  rP   r   HIGHr}   r   Zoverrides_a_methodrH   r  has_known_bases	INFERENCErn   r   r   rz   r   _recursive_check_names)r   rQ   rq   r   r   r   r   r     s    zNameChecker.visit_functiondefc             C   s"   x|j D ]}| jd|| qW d S )Nr   )rO   r   )r   rQ   rP   r   r   r   visit_global'  s    zNameChecker.visit_globalc             C   s.  | j |j| |j }|j }t|tjr<| jd|j| nt|tjrt|tj	rt
| rttj|jtjr| jd|j| qt|s| jd|j| nt|tjr| jd|j| nnt|tjr|j|kr|j|j krt|s| jd|j| n0t|tjr*t|j|js*| jd|j| dS )z!check module level assigned namesr   r   r   r   r   N)r	  rP   r  assign_typerG   rI   ZComprehensionr   r{  r   rZ   r   r   r   ri   rT   rJ   rh   argnamesrB   Zlocal_attr_ancestors)r   rQ   r  r  r   r   r   visit_assignname,  s(    zNameChecker.visit_assignnamec             C   s>   x8|D ]0}t |tjr(| jd|j| q| j|j| qW dS )z.check names in a possibly recursive list <arg>r   N)rG   rI   r  r   rP   r  r  )r   r   rQ   r   r   r   r   r  H  s    
z"NameChecker._recursive_check_namesc             C   s   | j j||S )N)r  r   )r   rp   r   r   r   _find_name_groupP  s    zNameChecker._find_name_groupc             C   sh   t | }| j| }| jjr.|d| j| j 7 }|j ||f}| jd|||d | jd|   d7  < d S )Nz (%r pattern)zinvalid-name)rQ   r   rq   r   rs   )	r  r  rz   Zinclude_naming_hintr  r  
capitalizer   r   )r   rQ   rp   rP   rq   Z
type_labelZhintr   r   r   r   r  S  s    
zNameChecker._raise_name_warningc                s    fdd}t j|r,t j|\}}|r,dS || jjkr<dS || jjkrr| jd    d7  < | jd||d dS | j  }|j	|}	t
|	 |r| j }
| jj|
i }|j|	jg }|j| ||f |	dkr|| r| j| || dS )z(check for a name using the type's regexpc                s&    dkr"t j| }t|tjr"dS dS )Nr   TF)r   r   rG   rI   ri   )rQ   r   )rp   r   r    _should_exempt_from_invalid_name`  s
    
zANameChecker._check_name.<locals>._should_exempt_from_invalid_nameNr   rs   zblacklisted-name)rQ   r   )r   Zis_inside_exceptZclobber_in_exceptrz   Z
good_namesZ	bad_namesr   r   r  ro   rr   r  r  
setdefaultrl   r   r  )r   rp   rP   rQ   rq   r  Z
clobberingr   r  ro   r  Zbad_name_groupr  r   )rp   r   r   ]  s(    



zNameChecker._check_namec             C   s2   | j || j}|d k	r.| jd|||ftjd d S )Nzassign-to-new-keyword)rQ   r   rq   )_name_became_keyword_in_versionKEYWORD_ONSETr   r   r
  )r   rP   rQ   Zkeyword_first_versionr   r   r   r	  }  s    
z2NameChecker._check_assign_to_new_keyword_violationc             C   s<   x6|j  D ]*\}}| |kr
tj|k r
djtt|S q
W d S )Nr:   )r  r  version_infor;   mapr   )rP   rulesversionr  r   r   r   r    s    z+NameChecker._name_became_keyword_in_versionN)r  r  r  )r  r  r  )r  r  r  )r  r  r  r  r  r   )r  r  r  r  r  r  )r  )r   r  )r    r!   r"   r7  r  optionsr  r   ru  r  r   r8  r  r  r   r   r9  r  r  r  r  r  r   r
  r   r	  r  r  r   r   r   r   r  f  sh         

 r  c            	   @   s   e Zd Zddddd)gifddd	dd*gifddddd+gifddddd,gifdZdeddddfdd-ddddffZdd Zejdddd  Z	ejddd!d" Z
ejddd#d$ ZeZd%ejfd&d'Zd(S ).DocStringCheckerzEmpty %s docstringzempty-docstringz^Used when a module, function, class or method has an empty docstring (it would be too easy ;).	old_namesW0132old-empty-docstringzMissing module docstringzmissing-module-docstringzMUsed when a module has no docstring.Empty modules do not require a docstring.C0111missing-docstringzMissing class docstringzmissing-class-docstringzMUsed when a class has no docstring.Even an empty class must have a docstring.z$Missing function or method docstringzmissing-function-docstringznUsed when a function or method has no docstring.Some special methods like __init__ do not require a docstring.)ZC0112ZC0114ZC0115ZC0116zno-docstring-rgxr  z<regexp>zcRegular expression which should only match function or class names that do not require a docstring.)r/  r   r  r  zdocstring-min-lengthrs   intz<int>z[Minimum line length for functions/classes that require docstrings, shorter ones are exempt.c             C   s   | j jddddd| _d S )Nr   )Zundocumented_moduleZundocumented_functionZundocumented_methodZundocumented_class)rr  rt  r   )r   r   r   r   ru    s
    zDocStringChecker.openc             C   s   | j d| d S )Nr   )_check_docstring)r   rQ   r   r   r   r    s    zDocStringChecker.visit_modulec             C   s$   | j jj|jd kr | jd| d S )Nr   )rz   no_docstring_rgxro   rP   r$  )r   rQ   r   r   r   r     s    zDocStringChecker.visit_classdefc             C   s   | j jj|jd kr|j r dnd}t|r0d S t|jj t	j
rd}tj|jj r\tjntj}x8|jj j D ]&}|j|krrt||j t	jrrd}P qrW | j||| |d n$t|jj t	jr| j|| nd S d S )Nr   r   FT)report_missingrq   )rz   r%  ro   rP   r}   r   rG   rH   r  rI   ri   r   r  r   r  rn   r&  rh   r$  r{  )r   rQ   ZftypeZ
overriddenrq   r)  r   r   r   r     s$    z"DocStringChecker.visit_functiondefTc       
      C   s\  |j }|dkr$|sdS tj||j }|dkr:| r:dS | jj}|dkr^|dkr^||k r^dS | jd|   d7  < |jrt|jd t	j
rt|jd jt	jrtj|jd jj}t|t	jrt|jt	jr|jjdkrdS |jjdkrdS |dk rd	}	n|d
krd}	nd}	| j|	||d n4|j sX| jd|   d7  < | jd||f|d dS )z(check the node has a non empty docstringNr   rs   r   r   r   unicodebyteszmissing-module-docstringr   zmissing-class-docstringzmissing-function-docstring)rQ   rq   zempty-docstring)rQ   r   rq   rt   )r   r'  r(  )docr   Zget_node_last_linenor   rz   Zdocstring_min_lengthr   r  rG   rI   Exprr   r   r   r   r~  Zboundr4  rP   r   strip)
r   rp   rQ   r&  rq   Z	docstringr   	max_linesr   messager   r   r   r$    s>    



z!DocStringChecker._check_docstringN)r  r   )r!  r"  )r!  r"  )r!  r"  rt   )r    r!   r"   r7  NO_REQUIRED_DOC_RGXr  ru  r   r8  r  r   r   r9  r   r
  r$  r   r   r   r   r    s@   


r  c               @   s*   e Zd ZdZdd	iZejddd ZdS )
PassCheckerz/check if the pass statement is really necessaryZW0107Unnecessary pass statementunnecessary-pass@Used when a "pass" statement that can be avoided is encountered.c             C   sF   t |jj|dks4t|jtjtjfrB|jjd k	rB| jd|d d S )Nrs   zunnecessary-pass)rQ   )	r   rH   Zchild_sequencerG   rI   ri   rh   r)  r   )r   rQ   r   r   r   
visit_pass6  s    zPassChecker.visit_passN)r0  r1  r2  )r    r!   r"   r%   r7  r   r8  r3  r   r   r   r   r/  +  s     r/  c             C   s"   t | tjo t| jdko | j S )zSIs this a call with exactly 1 argument,
    where that argument is positional?
    rs   )rG   rI   r   r   r   r  )r  r   r   r   _is_one_arg_pos_call?  s    r4  c               @   s   e Zd ZdZd*d+dd	d
dd,gifd-d.d/dZd0ddZdd Zdd Zdd  Zd!d" Z	e
jddd	dddd#d$ Zd%d& Zd'd( Zd)S )1ComparisonCheckera  Checks for comparisons

    - singleton comparison: 'expr == True', 'expr == False' and 'expr == None'
    - yoda condition: 'const "comp" right' where comp can be '==', '!=', '<',
      '<=', '>' or '>=', and right can be a variable, an attribute, a method or
      a function
    Comparison to %s should be %ssingleton-comparisonQUsed when an expression is compared to singleton values like True, False or None.Comparison should be %smisplaced-comparison-constantUsed when the constant is placed on the left side of a comparison. It is usually clearer in intent to place it in the right hand side of the comparison.z5Using type() instead of isinstance() for a typecheck.zunidiomatic-typecheckzThe idiomatic way to perform an explicit typecheck in Python is to use isinstance(x, Y) rather than type(x) == Y, type(x) is Y. Though there are unusual situations where these give different results.r  W0154old-unidiomatic-typecheckComparison to literalliteral-comparisonUsed when comparing an object to a literal, which is usually what you do not want to do, since you can compare to a different literal than what was expected altogether.Redundant comparison - %scomparison-with-itself/Used when something is compared against itself.;Comparing against a callable, did you omit the parenthesis?comparison-with-callableThis message is emitted when pylint detects that a comparison with a callable was made, which might suggest that some parenthesis were omitted, resulting in potential unwanted behaviour.)ZC0121ZC0122ZC0123ZR0123ZR0124ZW0143Fc             C   s   |j dkr.|sd}nd}| jd|d|fd nZ|j dkr\|sBd}nd}| jd|d|fd n,|j d kr|spd	}nd
}| jd|d |fd d S )NTzjust 'expr'zjust 'not expr'zsingleton-comparison)rQ   r   Fz
'not expr'z'expr'z'expr is None'z'expr is not None')r   r   )r   Z	singletonZ	root_nodenegative_check
suggestionr   r   r   _check_singleton_comparison{  s$    


z-ComparisonChecker._check_singleton_comparisonc             C   sv   t jt jt jt jf}t||}d}t|t jr\t|jtsD|jdkrHdS t|jt	t
ttf}|sd|rr| jd|d dS )zMCheck if we compare to a literal, which is usually what we do not want to do.FNzliteral-comparison)rQ   )rI   r   r   r   r   rG   r  r   boolr(  r   r#  floatr   )r   literalrQ   r	   Zis_other_literalZis_constr   r   r   _check_literal_comparison  s    
z+ComparisonChecker._check_literal_comparisonc             C   sF   t |tjrd S tj||}d|j ||jf }| jd||fd d S )Nz%s %s %rzmisplaced-comparison-constant)rQ   r   )rG   rI   r  REVERSED_COMPSr   r  r   r   )r   rQ   leftrightoperatorrH  r   r   r   _check_misplaced_constant  s
    z+ComparisonChecker._check_misplaced_constantc             C   s   |j }|jd d }|jd d }t|tjrHt|tjrH|j}|j}n$t|tjrlt|tjrl|j}|j}||krd|||f }| jd||fd dS )zCheck if identifier is compared against itself.
        :param node: Compare node
        :type node: astroid.node_classes.Compare
        :Example:
        val = 786
        if val == val:  # [comparison-with-itself]
            pass
        r   rs   z%s %s %szcomparison-with-itself)rQ   r   N)	rO  opsrG   rI   r  r   r   rP   r   )r   rQ   left_operandright_operandrQ  rH  r   r   r   _check_logical_tautology  s    	

z*ComparisonChecker._check_logical_tautologyc                sl   |j d d }|tkrd S tjtjf |j|j d d  }}t fdd||fD dkrh| jd|d d S )Nr   rs   c             3   s"   | ]}t tj| rd V  qdS )rs   N)rG   r   r   )r=   r  )bare_callablesr   r   rg     s   z?ComparisonChecker._check_callable_comparison.<locals>.<genexpr>zcomparison-with-callable)rQ   )rS  COMPARISON_OPERATORSrI   rh   r~  rO  sumr   )r   rQ   rQ  rT  rU  r   )rW  r   _check_callable_comparison  s    
z,ComparisonChecker._check_callable_comparisonc             C   s   | j | | j| | j| t|jdkr0d S |j}|jd \}}|tkrht|tj	rh| j
|||| |dkrt|tj	r| j|| nt|tj	r| j|| |dkrt|tj	r| j||dd |d	kr| j|| d S )
Nrs   r   z==z!=T)rG  r3   is not)r3   r[  )rZ  rV  _check_unidiomatic_typecheckr   rS  rO  rX  rG   rI   r  rR  rI  rM  )r   rQ   rO  rQ  rP  r   r   r   visit_compare  s&    	


zComparisonChecker.visit_comparec             C   s8   |j d \}}|tkr4|j}t|r4| j|||| d S )Nr   )rS  TYPECHECK_COMPARISON_OPERATORSrO  r4  _check_type_x_is_y)r   rQ   rQ  rP  rO  r   r   r   r\    s
    z.ComparisonChecker._check_unidiomatic_typecheckc             C   s   t j|j}t|tjo"|j tks(dS |dkrzt|rzt j|j}t|tjrz|j tkrzt j|j	d }t|t
szdS | jd|d dS )z(Check for expressions like type(x) == Y.Nr3   is notr   zunidiomatic-typecheck)rQ   )r3   r`  )r   r   r   rG   rI   ri   r   
TYPE_QNAMEr4  r   LITERAL_NODE_TYPESr   )r   rQ   rO  rQ  rP  Z	left_funcZ
right_funcZ	right_argr   r   r   r_   	  s    
z$ComparisonChecker._check_type_x_is_yN)r6  r7  r8  )r9  r:  r;  )r<  r=  )r>  r?  r@  )rA  rB  rC  )rD  rE  rF  )F)r    r!   r"   r%   r7  rI  rM  rR  rV  rZ  r   r8  r]  r\  r_  r   r   r   r   r5  F  sD       
      
r5  c             C   sX   | j t|  | j t|  | j t|  | j t|  | j t|  | j t|  dS )z-required method to auto register this checkerN)Zregister_checkerr   r:  r  r  r/  r5  )rr  r   r   r   register	  s    rc  )r1   r2   )r3   r4   r5   r6   r7   r8   )r@   rA   rB   )r5   r6   rE   rC   rF   rD   )r!   )N)Tr%   builtinsr   r   r&   r  typingr   rI   Zastroid.basesZastroid.scoped_nodesZastroid.argumentsr   Zpylint.utilsr   r6  Zpylintr   r   r   Zpylint.checkersZpylint.checkers.utilsr   Zpylint.reporters.ureportsr	   r   r
   r$   r(   r)   r*   r+   r  r'   r.  r  ZSEQUENCE_PROTOCOL_METHODSr  	frozensetr^  r  r   r   r   rb  ZUNITTEST_CASEr    r<   ra  r'  rm   rA   r  r  rN  rX  r1  r5  rT   rZ   r\   rb   rk   rr   rw   r|   r   r   r   r   ZBaseCheckerr   r   r:  r  r  r  r  r  r  r/  r4  r5  rc  r   r   r   r   <module>&   s   


	
%
(   K     :"  -  Q