B
    0zf                @  s`  U d dl mZ d dl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	m
Z
 d dlmZmZmZmZ d dlmZmZ d dlmZ d dlmZ d dlmZ d d	lmZ d d
lmZ d dlmZ d dlm Z m!Z!m"Z"m#Z#m$Z$ d dl%Z%d dl%m&Z& d dl'm(Z( d dl)m*Z* d dl+m,Z,m-Z-m.Z.m/Z/ ej0dkr8d dlm1Z1 nd dl2m3Z3 dddddZ1e rnd dl4m5Z5m6Z6m7Z7 dZ8e9dZ:e%j;d  Z<ej0dkrej=Z>de?d< ne$ej=ej@f Z>de?d< G dd de#ZAG d d! d!e#ZBd"ZCd#ZDd$ZEd%ZFd&ZGd'eEfd(d)eCfd*eCfd+eCfd,d-d.d/d0eDfd1d'eEfd(d)eCfd*eCfd0eDfd1d2ZHd3eFd3d3eGd4ZIeJd5d6d7d8d9d:hZKdd3eCd$eCdeCd3d3d3d;d3d3d%dd3deFeGd3d3d3dd3d<ZLG d=d> d>e*ZMG d?d@ d@e&jNZOG dAdB dBejPZQdddCdDdEZRdFddGdHdIdJZSeJdKdLhZTdFddMdGdNdOdPZUeeUdQdRhdSZVeeUdeTdSZWeeUdTeTdSZXeeUdUeTdVhB dSZYeeUdWeTdSZZeeUdXdYhdSZ[eeUdZdKhdSZ\eeUd8eTdSZ]eeUd[eTdSZ^eeUd\eTdSZ_eeUd]d^heTB dSZ`eeUd_d`hdSZaeeUdadRhdSZbeeUdbdKdchdSZceeUdddcheTB dSZdeeUd5eTdSZeeeUd:eTdSZfdedMdfdgdhdiZgdedGddjdkZhdFdlddmdnZidedGddodpZjG dqdr dre#ZkdsdrddtduZldvdGddwdxZmdFdfddydzZneJd{d|d}d~dddddddddhZodddGdddZpdddddZqdddddZrddGdddZsdddddZtdfdGdGdddZuG dd de#ZvdddddZweG dd dZxG dd dejyZze{dZ|dddddZ}eG dd dZ~dZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdZdS )    )annotationsN)Counterdefaultdict)	ContainerIterableIteratorSequence)contextmanagersuppress)deepcopy)	dataclass)partial)chain)	iskeyword)Path)TYPE_CHECKINGAnyClassVar
NamedTupleUnion)checker)OptionManager)FlakesChecker)ClassDefinition
ClassScopeFunctionScopeModuleScope)   	   )unparse)	decompilezast.ASTstr)nodereturnc             C  s   t | dS )N
)r    strip)r"    r&   F/home/ankuromar296_gmail_com/.local/lib/python3.7/site-packages/pyi.pyr       s    r   )Literal	TypeAlias	TypeGuardz22.11.0z
flake8.pyir)   _LiteralMemberc               @  s.   e Zd ZU ded< ded< ded< ded< dS )Errorintlinenocolr!   messagetypeN)__name__
__module____qualname____annotations__r&   r&   r&   r'   r,   5   s   
r,   c               @  s   e Zd ZU ded< ded< dS )TypeVarInfor!   cls_namenameN)r2   r3   r4   r5   r&   r&   r&   r'   r6   <   s   
r6   zKeyType, ValueTypeZMyClassZKeyTypezYieldType, SendType, ReturnTypezYieldType, SendTypezcollections.Counter)zcollections.dequeTzcollections.defaultdictzcollections.ChainMapdict)	frozensetr9   )listr9   )setr9   )tuplezFoo, Barr1   )z&contextlib.AbstractAsyncContextManagerr9   )ztyping.Counterztyping.Dequeztyping.DefaultDictztyping.ChainMapztyping.Dictztyping.FrozenSetztyping.Listz
typing.Setztyping.Tupleztyping.Typeztyping.AsyncContextManagerztyping_extensions.Counterztyping_extensions.Dequeztyping_extensions.DefaultDictztyping_extensions.ChainMapztyping_extensions.Typez%typing_extensions.AsyncContextManagerr9   )	Awaitable	CoroutineAsyncIterableAsyncIteratorAsyncGeneratorProtocolruntime_checkableNewTypeoverloadTextNoReturnZ	ValueType)
ByteString
Collection	ItemsViewKeysViewMappingMappingViewMutableMappingMutableSequence
MutableSetr   
ValuesViewr   r   	GeneratorHashable
ReversibleSizedr@   rC   rB   rA   r?   Callabler   c                  s|   e Zd ZdddddZddd fddZd	ddd
dZddd fddZddd fddZdddddZ  Z	S )PyiAwareFlakesCheckerzast.AST | NoneNone)r"   r#   c               s     fdd d S )Nc                 s     S )N)
handleNoder&   )r"   parentselfr&   r'   <lambda>       z7PyiAwareFlakesChecker.deferHandleNode.<locals>.<lambda>)deferFunction)r]   r"   r\   r&   )r"   r\   r]   r'   deferHandleNode   s    z%PyiAwareFlakesChecker.deferHandleNodez
ast.Assignc               sJ   t | jtst | dS x|jD ]}| || q$W | |j| dS )aH  This is a custom implementation of ASSIGN derived from
        handleChildren() in pyflakes 1.3.0.

        The point here is that on module level, there's type aliases that we
        want to bind eagerly, but defer computation of the values of the
        assignments (the type aliases might have forward references).
        N)	
isinstancescoper   superASSIGNtargetsr[   ra   value)r]   r"   target)	__class__r&   r'   re      s    zPyiAwareFlakesChecker.ASSIGNzast.AnnAssignc             C  sb   |j r| |j| t| jts.| |j| |j r^t| jtrP| |j | n| |j | dS )z
        Annotated assignments don't have annotations evaluated on function
        scope, hence the custom implementation. Compared to the pyflakes
        version, we defer evaluation of the annotations (and values on
        module level).
        N)	rg   r[   rh   rb   rc   r   ra   
annotationr   )r]   r"   r&   r&   r'   	ANNASSIGN   s    zPyiAwareFlakesChecker.ANNASSIGNz
ast.Lambdac               s4   | j | j | _| _ t | | j | j | _| _ dS )a  This is likely very brittle, currently works for pyflakes 1.3.0.

        Deferring annotation handling depends on the fact that during calls
        to LAMBDA visiting the function's body is already deferred and the
        only eager calls to `handleNode` are for annotations.
        N)ra   r[   rd   LAMBDA)r]   r"   )ri   r&   r'   rl      s    zPyiAwareFlakesChecker.LAMBDAzast.ClassDefc               s   t jtst   d S x jD ]}|  q$W x jD ]}|  q@W x j	D ]}|  q\W 
t jr st jts fdd x jD ]}|  qW    t j  d S )Nc                 s
     S )N)ZhandleDoctestsr&   )r"   r]   r&   r'   r^      r_   z0PyiAwareFlakesChecker.CLASSDEF.<locals>.<lambda>)rb   rc   r   rd   CLASSDEFdecorator_listr[   basesra   keywordsZ	pushScoper   ZwithDoctestZ_in_doctestr   r`   bodyZpopScopeZ
addBindingr   r8   )r]   r"   	decoratorZbaseNodeZkeywordNodestmt)ri   )r"   r]   r'   rm      s$    
zPyiAwareFlakesChecker.CLASSDEFzast.ASTc             C  s   dS )z]Null implementation.

        Lets users use `del` in stubs to denote private names.
        Nr&   )r]   r"   r&   r&   r'   handleNodeDelete   s    z&PyiAwareFlakesChecker.handleNodeDelete)
r2   r3   r4   ra   re   rk   rl   rm   rt   __classcell__r&   r&   )ri   r'   rY      s   rY   c                  s$   e Zd Zddd fddZ  ZS )PyiAwareFileCheckerr   )kwargsr#   c               s   | j dkr| jj}n| j }|dr~d|}tdk r^|d tkr~t| t|}t	|d< n |j
tkr~t| |jt	d}t j|f|S )N-z.pyizBReplacing FlakesChecker with PyiAwareFlakesChecker while checking    plugin)obj)filenameoptionsZstdin_display_nameendswithFLAKE8_MAJOR_VERSIONr   LOGinfor:   rY   r{   _replacerd   	run_check)r]   rz   rw   r|   Zlog_msg)ri   r&   r'   r      s    







zPyiAwareFileChecker.run_check)r2   r3   r4   r   ru   r&   r&   )ri   r'   rv      s   rv   c               @  s*   e Zd ZdZejdk r&dddddZdS )	LegacyNormalizerz6Transform AST to be consistent across Python versions.)r   r   z	ast.Indexzast.expr)r"   r#   c             C  s   |  | |jS )aH  Index nodes no longer exist in Python 3.9.

            For example, consider the AST representing Union[str, int].
            Before 3.9:
                Subscript(value=Name(id='Union'), slice=Index(value=Tuple(...)))
            3.9 and newer:
                Subscript(value=Name(id='Union'), slice=Tuple(...))
            )generic_visitrg   )r]   r"   r&   r&   r'   visit_Index  s    	
zLegacyNormalizer.visit_IndexN)r2   r3   r4   __doc__sysversion_infor   r&   r&   r&   r'   r     s   
r   )stringr#   c             C  s&   t | jd }t|t js t|jS )zHelper function for doctestsr   )astparserq   rb   ExprAssertionErrorrg   )r   exprr&   r&   r'   _ast_node_for(  s    r   zast.expr | Nonebool)r"   r8   r#   c             C  s   t | tjo| j|kS )zReturn True if `node` is an `ast.Name` node with id `name`

    >>> node = ast.Name(id="Any")
    >>> _is_name(node, "Any")
    True
    )rb   r   Nameid)r"   r8   r&   r&   r'   _is_name/  s    r   typingtyping_extensionszContainer[str])r"   r8   from_r#   c            C  sv   t | |rdS t| tjr$| j|ks(dS | j}t|tjrD|j|kS t|tjott|jtjot|jj d|j |kS )a  Determine whether `node` is an ast representation of `name`.

    Return True if `node` is either:
    1). Of shape `ast.Name(id=<name>)`, or;
    2). Of shape `ast.Attribute(value=ast.Name(id=<parent>), attr=<name>)`,
        where <parent> is a string that can be found within the `from_` collection of
        strings.

    >>> _is_AsyncIterator = partial(_is_object, name="AsyncIterator", from_=_TYPING_MODULES | {"collections.abc"})
    >>> _is_AsyncIterator(_ast_node_for("AsyncIterator"))
    True
    >>> _is_AsyncIterator(_ast_node_for("typing.AsyncIterator"))
    True
    >>> _is_AsyncIterator(_ast_node_for("typing_extensions.AsyncIterator"))
    True
    >>> _is_AsyncIterator(_ast_node_for("collections.abc.AsyncIterator"))
    True
    TF.)r   rb   r   	Attributeattrrg   r   r   )r"   r8   r   Z
node_valuer&   r&   r'   
_is_object<  s    

r   BaseExceptionbuiltins)r8   r   r   	TypedDictZmypy_extensionsr(   abstractmethodabcr   finalFinalSelfZ	_typeshedTracebackTypetypesobjectr   zcollections.abcrA   zast.exprz
str | None)	classnodemodulesr#   c            C  s|   t | tjr| jS t | tjrx| j}t |tjr@|j|kr@| jS t |tjrxt |jtjrx|jj d|j |krx| jS dS )a[  
    If `classnode` is an `ast.Name`, return `classnode.id`.

    If it's an `ast.Attribute`,check that the part before the dot
    is a module in `modules`.
    If it is, return the part after the dot; if it isn't, return `None`.

    If `classnode` is anything else, return `None`.

    >>> _get_name_of_class_if_from_modules(_ast_node_for('int'), modules={'builtins'})
    'int'
    >>> _get_name_of_class_if_from_modules(_ast_node_for('builtins.int'), modules={'builtins'})
    'int'
    >>> _get_name_of_class_if_from_modules(_ast_node_for('builtins.int'), modules={'typing'}) is None
    True
    r   N)rb   r   r   r   r   rg   r   )r   r   Zmodule_noder&   r&   r'   "_get_name_of_class_if_from_modulest  s    r   c             C  s   t | tdhB d}|dkS )aD  
    >>> _is_type_or_Type(_ast_node_for('type'))
    True
    >>> _is_type_or_Type(_ast_node_for('Type'))
    True
    >>> _is_type_or_Type(_ast_node_for('builtins.type'))
    True
    >>> _is_type_or_Type(_ast_node_for('typing_extensions.Type'))
    True
    >>> _is_type_or_Type(_ast_node_for('typing.Type'))
    True
    r   )r   >   Typer1   )r   _TYPING_MODULES)r"   r7   r&   r&   r'   _is_type_or_Type  s    r   zTypeGuard[ast.BinOp]c             C  s   t | tjot | jtjS )N)rb   r   BinOpopBitOr)r"   r&   r&   r'   _is_PEP_604_union  s    r   c             C  s   t | tjo| jd kS )N)rb   r   NameConstantrg   )r"   r&   r&   r'   _is_None  s    r   c               @  s,   e Zd ZU ded< ded< ddddZd	S )
ExitArgAnalysisr   is_union_with_Nonezast.expr | Nonenon_None_partr!   )r#   c             C  s0   | j d krd}nt| j }d| j d| dS )NrZ   z#ExitArgAnalysis(is_union_with_None=z, non_None_part=))r   r   dumpr   )r]   Znon_None_part_reprr&   r&   r'   __repr__  s    
zExitArgAnalysis.__repr__N)r2   r3   r4   r5   r   r&   r&   r&   r'   r     s   
r   z	ast.BinOpc             C  sN   t | jtjstt| jr*td| jdS t| jrBtd| jdS tdddS )a2  Return a two-item tuple analysing the annotation of an exit-method arg.

    The `node` represents a union type written as `X | Y`.

    >>> _analyse_exit_method_arg(_ast_node_for('int | str'))
    ExitArgAnalysis(is_union_with_None=False, non_None_part=None)
    >>> _analyse_exit_method_arg(_ast_node_for('int | None'))
    ExitArgAnalysis(is_union_with_None=True, non_None_part=Name(id='int', ctx=Load()))
    >>> _analyse_exit_method_arg(_ast_node_for('None | str'))
    ExitArgAnalysis(is_union_with_None=True, non_None_part=Name(id='str', ctx=Load()))
    T)r   r   FN)	rb   r   r   r   r   r   leftr   right)r"   r&   r&   r'   _analyse_exit_method_arg  s    

r   z5ast.ClassDef | ast.FunctionDef | ast.AsyncFunctionDefc             C  s   t dd | jD S )Nc             s  s   | ]}t |V  qd S )N)	_is_final).0rr   r&   r&   r'   	<genexpr>  s    z+_is_decorated_with_final.<locals>.<genexpr>)anyrn   )r"   r&   r&   r'   _is_decorated_with_final  s    r   c             C  s$   t | tjsdS t| jtdhB dS )a  
    If the node represents a subscripted object from collections.abc or typing,
    return the name of the object.
    Else, return None.

    >>> _get_collections_abc_obj_id(_ast_node_for('AsyncIterator[str]'))
    'AsyncIterator'
    >>> _get_collections_abc_obj_id(_ast_node_for('typing.AsyncIterator[str]'))
    'AsyncIterator'
    >>> _get_collections_abc_obj_id(_ast_node_for('typing_extensions.AsyncIterator[str]'))
    'AsyncIterator'
    >>> _get_collections_abc_obj_id(_ast_node_for('collections.abc.AsyncIterator[str]'))
    'AsyncIterator'
    >>> _get_collections_abc_obj_id(_ast_node_for('collections.OrderedDict[str, int]')) is None
    True
    Nzcollections.abc)r   )rb   r   	Subscriptr   rg   r   )r"   r&   r&   r'   _get_collections_abc_obj_id  s    r   __iadd____isub____imul____imatmul____itruediv____ifloordiv____imod____ipow____ilshift____irshift____iand____ixor____ior__z&ast.FunctionDef | ast.AsyncFunctionDefzast.ClassDef)methodclassdefr#   c            C  s   t dd | jD rdS t| js&dS | j| j }}t| tjr^|dko\t	||jo\t
| S |tkrx|dk	ovt| S t	||jr|dkot
| S t|}dd |jD }|d	kr|d
kod|kS |dkr|dkod|kS dS )zGReturn `True` if `function` should be rewritten using `_typeshed.Self`.c             s  s   | ]}t |pt|V  qd S )N)_is_overload_is_abstractmethod)r   decor&   r&   r'   r     s    z-_has_bad_hardcoded_returns.<locals>.<genexpr>F
__aenter__N>   	__enter____new__c             S  s   h | ]}t |qS r&   )r   )r   	base_noder&   r&   r'   	<setcomp>/  s    z-_has_bad_hardcoded_returns.<locals>.<setcomp>__iter__>   r   r   r   	__aiter__>   rB   rA   rB   )r   rn   _non_kw_only_args_ofargsr8   returnsrb   r   AsyncFunctionDefr   r   _INPLACE_BINOP_METHODS_is_Selfr   ro   )r   r   method_namer   Zreturn_obj_namero   r&   r&   r'   _has_bad_hardcoded_returns  s.    


r   c             C  s   t ddt| S )z<Unparse a function node, and reformat it to fit on one line.z\s+ )resubr   )r"   r&   r&   r'   _unparse_func_node;  s    r   zlist[ast.expr | None]zTypeGuard[list[ast.Str]])seqr#   c             C  s   t dd | D S )Nc             s  s   | ]}t |tjV  qd S )N)rb   r   Str)r   itemr&   r&   r'   r   A  s    z(_is_list_of_str_nodes.<locals>.<genexpr>)all)r   r&   r&   r'   _is_list_of_str_nodes@  s    r   zast.Callc             C  s`   | j }t|dkrdS |d }t|tjs.dS |j}t|s@dS dd |D }tdd |D S )zEvaluate whether an assignment-based TypedDict should be rewritten using class syntax.

    Return `False` if the TypedDict appears as though it may be invalidly defined;
    type-checkers will raise an error in that eventuality.
       F   c             S  s   g | ]
}|j qS r&   )s)r   fieldr&   r&   r'   
<listcomp>]  s    z%_is_bad_TypedDict.<locals>.<listcomp>c             s  s    | ]}|  ot| V  qd S )N)isidentifierr   )r   	fieldnamer&   r&   r'   r   `  s   z$_is_bad_TypedDict.<locals>.<genexpr>)r   lenrb   r   Dictkeysr   r   )r"   r   Ztyped_dict_annotationsZtyped_dict_fields
fieldnamesr&   r&   r'   _is_bad_TypedDictD  s    r   zast.argumentszlist[ast.arg])r   r#   c             C  s   t | dg }|| j S )zHReturn a list containing the pos-only args and pos-or-kwd args of `args`Zposonlyargs)getattrr   )r   Zpos_only_argsr&   r&   r'   r   e  s    r   )target_namein_classr#   c            C  s   | dkr|p| dko| S )N>   	__slots____match_args____all__r&   )r   r   r&   r&   r'   &_is_assignment_which_must_have_a_valuel  s    r   c               @  s>   e Zd ZU ded< ded< ded< ded< ded< d	ed
< dS )UnionAnalysisz defaultdict[str, list[ast.expr]]members_by_dumpr   dupes_in_unionzset[str]builtins_classes_in_unionmultiple_literals_in_unionnon_literals_in_unionzlist[_LiteralMember]combined_literal_membersN)r2   r3   r4   r5   r&   r&   r&   r'   r   t  s   
r   zSequence[ast.expr])membersr#   c       	      C  s   d}t t}t }g }g }xh| D ]`}|t| | t|dhd}|dk	rX|| t|tj	r|t
|jr|||j q d}q W x0|D ](}t|tjr||j q|| qW t|tdd | D |t|dk||d	S )
a  Return a tuple providing analysis of a given sequence of union members.

    >>> union = _ast_node_for('Union[int, memoryview, memoryview, Literal["foo"], Literal[1]]')
    >>> members = union.slice.elts if sys.version_info >= (3, 9) else union.slice.value.elts
    >>> analysis = _analyse_union(members)
    >>> len(analysis.members_by_dump["Name(id='memoryview', ctx=Load())"])
    2
    >>> analysis.dupes_in_union
    True
    >>> "int" in analysis.builtins_classes_in_union
    True
    >>> "float" in analysis.builtins_classes_in_union
    False
    >>> analysis.multiple_literals_in_union
    True
    >>> analysis.non_literals_in_union
    True
    >>> unparse(ast.Tuple(analysis.combined_literal_members))
    "('foo', 1)"
    Fr   )r   NTc             s  s   | ]}t |d kV  qdS )r   N)r   )r   lstr&   r&   r'   r     s    z!_analyse_union.<locals>.<genexpr>r   )r  r  r  r  r  r  )r   r<   r=   r   r   appendr   addrb   r   _is_Literalrg   sliceTupleextendeltsr   r   valuesr   )	r  r  r  r  Zliterals_in_unionr  memberZname_if_builtins_clsliteralr&   r&   r'   _analyse_union}  s2    



r  c               @  sB   e Zd ZU dZdZded< eddddZed	dd
dZ	dS )NestingCounterz9Class to help the PyiVisitor keep track of internal stater   r-   nestingzIterator[None])r#   c          	   c  s.   |  j d7  _ z
d V  W d |  j d8  _ X d S )Nr   )r  )r]   r&   r&   r'   enabled  s    
zNestingCounter.enabledr   c             C  s
   t | jS )z<Determine whether the level of nesting is currently non-zero)r   r  )r]   r&   r&   r'   active  s    zNestingCounter.activeN)
r2   r3   r4   r   r  r5   r	   r  propertyr  r&   r&   r&   r'   r    s   
r  c               @  sj  e Zd ZddddddZddd	d
ZedddddZdddddddZdddddZdddddZ	dddddddZ
dddd d!Zedd"dd#d$Zdddd%d&Zd'ddd(d)Zdd*ddd+d,d-Zd*ddd.d/Zd0ddd1d2Zd3ddd4d5Zd6ddd7d8Zd9ddd:d;Zed<Zed=Zd>ddd?d@dAZd>dddBdCZdDddEdFdGZdHddIdJdKZddHddLdMdNZddHddLdOdPZdQdddRdSZdTdddUdVZ dWdddXdYdZZ!d[ddd\d]Z"dddd^d_Z#d`dddadbZ$dcdddd`d"deddfdgdhZ%d`dddidjZ&dkdddldmZ'dndddodpdqZ(dndddrdsdtZ)dudvddwdxdyZ*dudvddwdzd{Z+duddd|d}Z,duddd~dZ-dddddZ.dndddddZ/dndd*ddddZ0dndd*ddddZ1dnddddZ2dnddddZ3dddddZ4dddddZ5ddddddZ6ddddZ7dddddZ8dS )
PyiVisitorNzPath | NonerZ   )r|   r#   c             C  sl   |d krt dn|| _g | _i | _g | _g | _i | _i | _t | _	t
 | _t
 | _t
 | _t
 | _d | _d S )Nz(none))r   r|   errorstypevarlike_defsprotocol_defsclass_based_typeddictsassignment_based_typeddictstypealias_declsr   all_name_occurrencesr  string_literals_allowedin_functionr   visiting_argcurrent_class_node)r]   r|   r&   r&   r'   __init__  s    zPyiVisitor.__init__r!   )r#   c             C  s   | j j d| jdS )Nz
(filename=r   )ri   r2   r|   )r]   r&   r&   r'   r     s    zPyiVisitor.__repr__z
str | None)object_namer#   c          	   C  s   | t krBt |  }d|  d| d|  d| d	}d|  d| d}nJ| tkrdd|  d}d|  d}n(| d	krvd
}d}n| dkrd}d}ndS tj||dS )z
        Return the appropriate error message for a bad import/attribute-access from typing_extensions.
        Return `None` if it's an OK import/attribute-access.
        z"collections.abc.[z]" (or "typing.z]" in Python 2-compatible code)z"typing_extensions.z]"z"typing."r   z"typing.ClassVar[T]"z"typing_extensions.ClassVar[T]"ContextManagerzb"contextlib.AbstractContextManager[T]" (or "typing.ContextManager[T]" in Python 2-compatible code)z%"typing_extensions.ContextManager[T]"N)good_syntax
bad_syntax) _BAD_COLLECTIONSABC_Y023_IMPORTS_BAD_TYPING_Y023_IMPORTSY023format)r&  slice_contents
suggestionr+  r&   r&   r'   _get_Y023_error_message  s    z"PyiVisitor._get_Y023_error_messagezast.Attribute | ast.ImportFrom)r"   module_namer&  r#   c       
      C  s  | d| }|t krPt | \}}tjd| d| dd| d| dd}n&|dkr|tkrt| }|d krtdn
d| d}tjd	| | dd
| | dd}n|tkr|dkrtjdt dd| dt dd}n|dkrtjddd}n|dkr| |}	|	d krd S |	}nX|dkr.t}nH|dkrHt	j|dd}n.|dkrbt	j|dd}n|dkrrt
}nd S | || d S )Nr   r(  r'  z]")r*  r+  r    ]z"collections.abc.z"typing.OrderedDictz"collections.OrderedDict[ztyping.ContextManagerz&"contextlib.AbstractContextManager[T]"z"typing.ContextManager[T]"r   zcollections.namedtupleztyping.Optionalz'"int | None" instead of "Optional[int]")
old_syntaxexampleztyping.Unionz("int | str" instead of "Union[int, str]"ztyping.Text)_BAD_Y022_IMPORTSY022r/  _BAD_Y027_IMPORTSY027r   _MAPPING_SLICEr2  Y024Y037Y039error)
r]   r"   r3  r&  fullnameZgood_cls_nameparamserror_messager0  analysisr&   r&   r'   _check_import_or_attribute  sJ    








z%PyiVisitor._check_import_or_attributezast.Attribute)r"   r#   c             C  s8   |  | |j}t|tjs d S | j||j|jd d S )N)r"   r3  r&  )r   rg   rb   r   r   rF  r   r   )r]   r"   thingr&   r&   r'   visit_AttributeC  s    
zPyiVisitor.visit_Attributezast.ImportFromc             C  s   |j }|d krd S dd |jD }|dkrPd|krL|d jdkrL| |t d S |dkrpd|krl| |t d S x|D ]}| ||| qvW |dkrd|kr| |t d S )	Nc             S  s   i | ]}||j qS r&   )r8   )r   r{   r&   r&   r'   
<dictcomp>S  s    z/PyiVisitor.visit_ImportFrom.<locals>.<dictcomp>zcollections.abcSetAbstractSet
__future__r   r   )modulenamesZasnamerA  Y025Y044rF  Y038)r]   r"   r3  Zimported_namesr&  r&   r&   r'   visit_ImportFromM  s"    
zPyiVisitor.visit_ImportFromz
ast.Assignzast.expr)r"   functionr&  r#   c             C  sL   t |td}|dkrH|dr6t||d}|| j|< n| |t| dS )zAttempt to find assignments to TypeVar-like objects.

        TypeVars should usually be private.
        If they are private, they should be used at least once
        in the file in which they are defined.
        )r   >   TypeVarTypeVarTuple	ParamSpec_)r7   r8   N)r   r   
startswithr6   r  rA  Y001r/  )r]   r"   rS  r&  r7   Ztarget_infor&   r&   r'   "_check_for_typevarlike_assignmentsh  s    	
z-PyiVisitor._check_for_typevarlike_assignmentszast.Assign | ast.AnnAssignc             C  sD   t |}t|}tjdd|_t |}tj||d}| || d S )N.)rg   )r7  
new_syntax)r   r   r   Constantrg   Y015r/  rA  )r]   r"   r7  Zcopy_of_noder[  rD  r&   r&   r'   _Y015_errorz  s    zPyiVisitor._Y015_errorr   c             C  s   | j }t| tjr*|r&t|tjs&dS dS t|tjtjtjfrDdS t|tjrpt|j	tj
rpt|jtjrpdS t|tjtjfrt|tjs|j d k	rdS dS )NTF)rg   rb   r   	AnnAssignEllipsisNumr   BytesUnaryOpr   USuboperandr\  r   )r"   
assignmentr&   r&   r'   _Y015_violation_detected  s     
z#PyiVisitor._Y015_violation_detectedc          	   C  s:  | j jr| | d S t|jdkrT|jd }t|tjrB|j}qd| 	|t
 d }n| 	|t
 d }t|| jjd}|r| j  | | W d Q R X n
| | |d krd S t|tjst|j}t|tjr|j}t|r|dr|| j|< n| j|||d d S | |r"| |S |s6| ||| d S )Nr   r   )r   rW  )r"   rS  r&  )r"  r  r   r   rf   rb   r   r   r   rA  Y017r   r   r!  r  r   rg   Callfunc_is_TypedDictrX  r  rZ  rg  r^  _check_for_type_aliases)r]   r"   rh   r   Zis_special_assignmentrf  rS  r&   r&   r'   visit_Assign  sB    




zPyiVisitor.visit_Assignzast.AugAssignc          	   C  s`   |j |j }}| | t|drRt|jtjrR| j	  | | W dQ R X n
| | dS )z0Allow `__all__ += ['foo', 'bar']` in a stub filer   N)
rh   rg   visitr   rb   r   r   Addr!  r  )r]   r"   rh   rg   r&   r&   r'   visit_AugAssign  s    
zPyiVisitor.visit_AugAssignzast.Name)r"   rh   rf  r#   c             C  s^   t |tjtjfs"t|s"t|rZtj|tjdt d|dd}| 	|t
jt|d dS )a&  
        Check for assignments that look like they could be type aliases,
        but aren't annotated with `typing(_extensions).TypeAlias`.

        We avoid triggering Y026 for calls and = ... because there are various
        unusual cases where assignment to the result of a call is legitimate
        in stubs (`T = TypeVar("T")`, `List = _Alias()`, etc.).

        We also avoid triggering Y026 for aliases like `X = str`.
        It's ultimately nearly impossible to reliably detect
        whether these are type aliases or variable aliases,
        unless you're a type checker (and we're not).

        The only exceptions are the type aliases `X = (typing.)Any`
        (special-cased, because it is so common in a stub),
        and `X = None` (special-cased because it is so special).
        r)   )r   ctxr   )rh   rj   rg   simple)r1  N)rb   r   r   r   _is_Anyr   r_  r   LoadrA  Y026r/  r   )r]   r"   rh   rf  new_noder&   r&   r'   rl    s    z"PyiVisitor._check_for_type_aliasesc             C  s   | j |j  d7  < d S )Nr   )r   r   )r]   r"   r&   r&   r'   
visit_Name  s    zPyiVisitor.visit_Namezast.Callc          	   C  s   |j }| | t|r$| |tS t|rDt|r@| |t d S | j	   x|j
D ]}| | qXW W d Q R X x|jD ]}| | q|W d S )N)rj  rn  _is_NamedTuplerA  Y028rk  r   Y031r!  r  r   rp   )r]   r"   rS  argkwr&   r&   r'   
visit_Call  s    
zPyiVisitor.visit_Callzast.Constantc             C  s*   t |jtr&|jr&| jjs&| |t d S )N)rb   rg   r!   r!  r  rA  Y020)r]   r"   r&   r&   r'   visit_Constant  s    zPyiVisitor.visit_Constantzast.Strc             C  s   |j r| jjs| |t d S )N)r   r!  r  rA  r~  )r]   r"   r&   r&   r'   	visit_Str  s    zPyiVisitor.visit_Strzast.Exprc             C  s*   t |jtjr| |t n
| | d S )N)rb   rg   r   r   rA  Y021r   )r]   r"   r&   r&   r'   
visit_Expr  s    zPyiVisitor.visit_Exprz^_?[a-z]z^_.*[a-z]T\d?$zast.AnnAssign)r"   
alias_namer#   c             C  sR   |  | |dr|| j|< | j|r6| |t | j|rN| |t d S )NrW  )	r   rX  r  _Y042_REGEXmatchrA  Y042_Y043_REGEXY043)r]   r"   r  r&   r&   r'   _check_typealias)  s    


zPyiVisitor._check_typealiasc          	   C  s   |j }t|r2| j  | | W d Q R X d S |j}t|tjr|j	}t
|| jjdr| j  | | W d Q R X |jd kr| |tj|d d S t|rt|tjr| j||dS | | | |r| | d S )N)r   )var)r"   r  )rj   	_is_Finalr!  r  r   rh   rb   r   r   r   r   r   r  rg   rA  Y035r/  _is_TypeAliasr  rg  r^  )r]   r"   Znode_annotationZnode_targetr   r&   r&   r'   visit_AnnAssign2  s(    


zPyiVisitor.visit_AnnAssignzSequence[ast.expr])r  r#   c          	   C  s   |d }t |}x<|j D ].}t|dkr| |d tt|d  qW |js| 	| |j
rp| || | jjr| || d S )Nr   r   r   )r  r  r  r   rA  Y016r/  r   r  _check_for_Y051_violationsr  %_error_for_multiple_literals_in_unionr#  r  #_check_for_redundant_numeric_unions)r]   r  first_union_memberrE  Zmember_listr&   r&   r'   _check_union_membersL  s    "
zPyiVisitor._check_union_membersr   )rE  r#   c             C  s   t t}x|jD ]}t|tjr0|d | qt|tjrL|d | qt|tjrvt	|j
tkr|d | qt|tjrt	|jtkr|d | qW xH| D ]<\}}||jkr|d }| |tjdt| d|d qW d	S )
zLSearch for redundant unions fitting the pattern `str | Literal["foo"]`, etc.r!   bytesr-   r   r   zLiteral[r5  )Zliteral_subtypeZbuiltin_supertypeN)r   r<   r  rb   r   r   r	  rb  ra  r1   nr-   r   rg   r   itemsr  rA  Y051r/  r   )r]   rE  Zliteral_classes_presentr  clsliteralsZfirst_literal_presentr&   r&   r'   r  [  s(    
z%PyiVisitor._check_for_Y051_violations)r  rE  r#   c             C  s~   |j }g }|j}d|kr:d|kr(|d d|krR|d nd|krRd|krR|d x&|D ]\}}| |tj||d qXW d S )Ncomplexfloat)r  r  r-   )r-   r  )r-   r  )Zimplicit_subtypeZimplicit_supertype)r  r	  rA  Y041r/  )r]   r  rE  Zbuiltins_in_unionr  Z	add_errorsubtypeZ	supertyper&   r&   r'   r  u  s    
z.PyiVisitor._check_for_redundant_numeric_unionsc             C  sR   |j }tt|d}|jr.d| d}nd| d}| |tj|d d S )Nz()z%Combine them into one, e.g. "Literal[z]".z$Use a single Literal, e.g. "Literal[)r1  )	r  r   r   r  r%   r  rA  Y030r/  )r]   r  rE  Znew_literal_membersZnew_literal_slicer1  r&   r&   r'   r    s    z0PyiVisitor._error_for_multiple_literals_in_unionz	ast.BinOpc             C  s   t |jtjs| | d S |}g }x0t |tjrTt |jtjrT||j |j}q&W || |	  x|D ]}| 
| qnW | | d S )N)rb   r   r   r   r   r   r	  r   r   reversern  r  )r]   r"   currentr  r  r&   r&   r'   visit_BinOp  s    



zPyiVisitor.visit_BinOpzast.Subscriptc          	   C  sx   |j }t|td}| | |dkrJ| j  | |j W d Q R X d S t|jtj	rh| 
|j| n| |j d S )N)r   r(   )rg   r   r   rn  r!  r  r  rb   r   r  _visit_slice_tuple)r]   r"   Zsubscripted_objectZsubscripted_object_namer&   r&   r'   visit_Subscript  s    

zPyiVisitor.visit_Subscriptz	ast.Tuple)r"   r\   r#   c          	   C  s   |dkr |  |j | | nv|dkrt|jdkr| |jd  | j ( x |jdd  D ]}| | qbW W d Q R X q| | n
| | d S )Nr   	Annotatedr   r   )r  r  rn  r   r!  r  )r]   r"   r\   eltr&   r&   r'   r    s    zPyiVisitor._visit_slice_tuplezast.Ifc          	   C  s~   |j }| j  | | W d Q R X t|tjrNx$|jD ]}| | q:W n
| | x t	|j
|jD ]}| | qhW d S )N)testr!  r  rn  rb   r   BoolOpr  _check_if_expressionr   rq   Zorelse)r]   r"   r  Z
expressionliner&   r&   r'   visit_If  s    
zPyiVisitor.visit_Ifc             C  s   t |tjs| |t d S t|jdkr:| |t d S t |jtjrT| 	| ntt |jtj
rt|jjdr|jjdkr| | q|jjdkr| | q| |t q| |t n| |t d S )Nr   r   platformr   )rb   r   ComparerA  Y002r   comparatorsr   r   _check_subscript_version_checkr   r   rg   r   _check_platform_check_check_version_check)r]   r"   r&   r&   r'   r    s"    zPyiVisitor._check_if_expressionzast.Comparec             C  s   d}d }|j }t|tjr|j}t|tjrZt|jtrH|jdkrHd}q| |t	 d S nt|tj
r|jd k	sz|jd k	r| |t	 d S t|jtjrt|jjtr|jjdkr|jj}q| |t	 d S n| |t	 d S | j|||d d S )NFr   T)r   r   )must_be_singlecan_have_strict_equals)r   rb   r   r   r  ra  r  r-   rA  Y003Slicelowerstepupperr  )r]   r"   r  r  r   Zslcr&   r&   r'   r    s4    
z)PyiVisitor._check_subscript_version_checkF)r  r  z
int | None)r"   r  r  r#   c            C  s  |j d }|r4t|tjr&t|jts2| |t nt|tjsN| |t nt	dd |j
D sp| |t nt|j
dkr| |t |jd }t|tjtjfrnXt|tjtjfr|d k	rt|j
|kr| |tj|d n| |t n| |t d S )Nr   c             s  s   | ]}t |tjV  qd S )N)rb   r   ra  )r   r  r&   r&   r'   r   %  s    z2PyiVisitor._check_version_check.<locals>.<genexpr>r   )r  )r  rb   r   ra  r  r-   rA  r  r  r   r  r   Y004opsLtGtEEqNotEqY005r/  Y006)r]   r"   r  r  
comparatorcmpopr&   r&   r'   r    s&    

zPyiVisitor._check_version_checkc             C  st   |j d }t|tjtjfs,| |t d S |jd }t|tjrd|j	dkrp| |t
j|j	d n| |t d S )Nr   )linuxwin32cygwindarwin)r  )r  rb   r   r  r  rA  Y007r  r   r   Y008r/  )r]   r"   r  r  r&   r&   r'   r  7  s    


z PyiVisitor._check_platform_checkzast.ClassDefc          	   C  sJ  |j drP| jjsPx:|jD ]0}t|r6| j| P t|r| j	| P qW | j
}|| _
| j  | | W d Q R X || _
tdd |jD r| |t t|jdkr|jd }t|tjrt|jtjrd S t|tjr| |t d S xP|jD ]F}t|tjr| |t qt|tjrt|jtjr| |t qW d S )NrW  c             s  s   | ]}t |V  qd S )N)_is_builtins_object)r   r   r&   r&   r'   r   W  s    z,PyiVisitor.visit_ClassDef.<locals>.<genexpr>r   r   )r8   rX  r   r  ro   _is_Protocolr  r	  rk  r  r$  r  r   r   rA  Y040r   rq   rb   r   r   rg   r`  PassY009Y012Y013)r]   r"   baseZold_class_node	statementr&   r&   r'   visit_ClassDefG  s:    
zPyiVisitor.visit_ClassDefz&ast.FunctionDef | ast.AsyncFunctionDef)r"   r   r#   c               s0  j }t|}t|}|j}dddfdd |dk r|rr|j}|d kst|s d dt| d	 n d
 d t|j|d k r d d d |jkr d d dddd fdd}|dkrX|d j}	|	d kst|	rn\t	|	rLt
|	\}
}|
r>t|tjr>t|jr>t|jsX||	dd n||	dd |dkr|d j}|d kst|rn@t	|rt
|\}
}|
rt|s||dd n||dd |dkr,|d j}|d ks,t|rn@t	|r t
|\}
}|
rt|s,||dd n||dd d S )Nr!   rZ   )detailsr#   c               s    tj | d d S )N)r   r  )rA  Y036r/  )r  )r   r"   r]   r&   r'   error_for_bad_exit_methodw  s    z@PyiVisitor._check_exit_method.<locals>.error_for_bad_exit_method   zStar-args in an z0 method should be annotated with "object", not "r(  zRIf there are no star-args, there should be at least 3 non-keyword-only args in an z method (excluding "self")z&All arguments after the first 4 in an z! method must have a default valuez!All keyword-only arguments in an zast.exprzLiteral[(1, 2, 3)])annotation_node
arg_numberr#   c         	     sJ   dddg}||d  \}}d| d d| dt |  d		} |d
 d S )N)firstztype[BaseException] | None)secondzBaseException | None)thirdztypes.TracebackType | Noner   zThe z arg in an z" method should be annotated with "z" or "object", not "r(  )r  )r   )r  r  Zexit_arg_descriptionsarg_nameZcorrect_annotationZerror_msg_details)r  r   r&   r'   error_for_bad_annotation  s    "z?PyiVisitor._check_exit_method.<locals>.error_for_bad_annotationr   r   )r  r   )r   r   r   varargrj   r  r   defaultskw_defaultsr   r   rb   r   r   r   rg   _is_BaseExceptionr  _is_TracebackType)r]   r"   r   all_argsnon_kw_only_argsnum_argsvarargsZvarargs_annotationr  Zarg1_annotationr   r   Zarg2_annotationZarg3_annotationr&   )r  r   r"   r]   r'   _check_exit_methodo  sl    












zPyiVisitor._check_exit_method)r"   r7   r#   c             C  s   |j }t|}|j  tjdd|_t|jd }|dkrbtj	tjddtjddd|_
d}n tjdd|_
d| d	| d}tj|| d
| t|d}| || d S )Nr   )r   r   r   r1   )rg   r  z"__new__" methodsr(  z" methods in classes like "r   )methodsr   Zsuggested_syntax)r8   r   rn   clearr   r   r   r   r   r   rj   Y034r/  r   rA  )r]   r"   r7   r   Zcopied_nodeZ	first_argZreferrerrD  r&   r&   r'   _Y034_error  s     
zPyiVisitor._Y034_errorzast.FunctionDefzast.expr | None)r"   r   r#   c             C  s>   t |st|tjr:t |jr:tjdddd}| || d S )Nr   r   r   )iter_methodgood_clsbad_cls)_is_Iterablerb   r   r   rg   Y045r/  rA  )r]   r"   r   msgr&   r&   r'   _check_iter_returns  s
    zPyiVisitor._check_iter_returnsc             C  s>   t |st|tjr:t |jr:tjdddd}| || d S )Nr   rB   rA   )r  r  r  )_is_AsyncIterablerb   r   r   rg   r  r/  rA  )r]   r"   r   r  r&   r&   r'   _check_aiter_returns  s    zPyiVisitor._check_aiter_returnsc             C  s  |j }|j}| j}|d k	stt||dr:| j||j dS |j}|dkrT| ||S |dkrh| ||S |dkr~| j	||dS |j
rd S t|}|dkrt|dkrt|d	d
hdrtdd |jD s| |t n<|dkrt|dkrt|d jr| |tj|d d S )N)r   )r"   r7   r   r   >   __exit__	__aexit__)r"   r   >   r   __str__r   r!   r   )r   c             s  s   | ]}t |V  qd S )N)r   )r   r   r&   r&   r'   r   '  s    z7PyiVisitor._visit_synchronous_method.<locals>.<genexpr>>   __ne____eq__r   )r   )r8   r   r$  r   r   r  r   r  r  r  
kwonlyargsr   r   r   r   rn   rA  Y029rs  rj   Y032r/  )r]   r"   r   r  r   r   r  r&   r&   r'   _visit_synchronous_method  s0    
z$PyiVisitor._visit_synchronous_methodc             C  s    | j jr| | | | d S )N)r   r  r  _visit_function)r]   r"   r&   r&   r'   visit_FunctionDef/  s    
zPyiVisitor.visit_FunctionDefzast.AsyncFunctionDefc             C  sb   | j jrT| j}|d k	st|j}t||dr>| j||jd n|dkrT| j||d | | d S )N)r   )r"   r7   r  )r"   r   )	r   r  r$  r   r8   r   r  r  r  )r]   r"   r   r   r&   r&   r'   visit_AsyncFunctionDef4  s    z!PyiVisitor.visit_AsyncFunctionDef)r"   typevar_namer#   c             C  sR   t |}|j  t|}td| dd|}| |jjd tj	||d d S )Nz\br   r   )r  r[  )
r   rn   r  r   r   r   rA  r   Y019r/  )r]   r"   r  Zcleaned_methodr[  r&   r&   r'   _Y019_error?  s    

zPyiVisitor._Y019_errorzast.Name | ast.Subscript)r   first_arg_annotationreturn_annotationr#   c            C  s@   t |tjsd S |j|jkr d S |j}|dr<| || d S )NrW  )rb   r   r   r   rX  r  )r]   r   r  r  Zarg1_annotation_namer&   r&   r'   '_check_instance_method_for_bad_typevarsN  s    
z2PyiVisitor._check_instance_method_for_bad_typevarsc            C  s`   t |tjsd S t |jtjr(|jj}nd S t|jds<d S ||jkr\|dr\| 	|| d S )Nr1   rW  )
rb   r   r   r  r   r   r   rg   rX  r  )r]   r   r  r  Zcls_typevarr&   r&   r'   $_check_class_method_for_bad_typevars`  s    
z/PyiVisitor._check_class_method_for_bad_typevarsc             C  s   |j j }|sd S |j}t|tjs&d S |d j}t|tjtjfsFd S dd |jD }d|ksh|jdkrz| j	|||d nd|krd S | j
|||d d S )Nr   c             S  s   h | ]}t |tjr|jqS r&   )rb   r   r   r   )r   rr   r&   r&   r'   r     s   z1PyiVisitor.check_self_typevars.<locals>.<setcomp>classmethodr   )r   r  r  staticmethod)r   r   rb   r   r   rj   r   rn   r8   r  r  )r]   r"   Zpos_or_keyword_argsr  r  Zdecorator_namesr&   r&   r'   check_self_typevarsx  s,    


zPyiVisitor.check_self_typevarsc          	   C  s   | j   | | W d Q R X |j}t|dkrD| |d t nR|r|d }t|tj	rj| |t
 n,t|tjrt|jtjtjfs| |t | jjr| | d S )Nr   r   )r"  r  r   rq   r   rA  Y048rb   r   r  r  r   rg   r`  r   Y010r   r  r  )r]   r"   rq   r  r&   r&   r'   r    s    zPyiVisitor._visit_functionzast.argc          	   C  s:   t |jr| |t | j  | | W d Q R X d S )N)_is_NoReturnrj   rA  Y050r#  r  r   )r]   r"   r&   r&   r'   	visit_arg  s    
zPyiVisitor.visit_argzast.argumentsc             C  s~   |  | |jt|j d  }xXtt||jt|j|jD ]8\}}|d krPq>t|t	j
s>| ||jd krptnt q>W d S )N)r   r   r   r  r   zipr  r  rb   r   r`  rA  rj   Y014Y011)r]   r"   r   r{  defaultr&   r&   r'   visit_arguments  s    
"zPyiVisitor.visit_argumentszast.AST)r"   r0   r#   c             C  s   | j t|j|j|t d S )N)r  r	  r,   r.   
col_offsetPyiTreeChecker)r]   r"   r0   r&   r&   r'   rA    s    zPyiVisitor.errorc       
      C  s&  x>| j  D ]0\\}}}| j| dkr| |tj||d qW x4| jD ]*}| j|j dkrH| |tj|jd qHW x6| j	D ],}|j}| j| dkr~| |t
j|d q~W x8| j D ]*\}}| j| dkr| |t
j|d qW x8| j D ]*\}}	| j| dkr| |	tj|d qW dS )a  
        After the AST tree has been visited,
        analyse whether there are any unused things in this module.

        We currently check for unused
        - TypeVars
        - ParamSpecs
        - TypeVarTuples
        - Aliases
        - Protocols
        - TypedDicts
        r   )Ztypevarlike_clsr  r   )Zprotocol_name)Ztypeddict_name)r  N)r  r  r   rA  Y018r/  r  r8   Y046r  Y049r  r  Y047)
r]   r7   r  Zdef_nodeprotocolZclass_based_typeddictZtd_nameZtd_noder  aliasr&   r&   r'   _check_for_unused_things  s$    z#PyiVisitor._check_for_unused_thingszIterator[Error])treer#   c             c  s"   |  | |   | jE d H  d S )N)rn  r  r  )r]   r  r&   r&   r'   run  s    
zPyiVisitor.run)N)9r2   r3   r4   r%  r   r
  r2  rF  rH  rR  rZ  r^  rg  rm  rp  rl  rw  r}  r  r  r  r   compiler  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  rA  r  r   r&   r&   r&   r'   r    sh    ?
-
!	

	,(i(#!r  z+#\s*type:\s*(?!\s?ignore)([^#]+)(\s*#.*?)?$r   zIterator[Error])pathr#   c          	   c  s   | j dd }xt|ddD ]p\}}| }|dr:qt|}|sJq|d }yt	| W n t
k
r|   wY nX t|dttV  qW d S )NzUTF-8)encodingr   )start#r   )	read_text
splitlines	enumerater%   rX  _TYPE_COMMENT_REGEXsearchgroupr   r   SyntaxErrorr,   Y033r  )r"  Z	stublinesr.   r  cleaned_liner  Ztype_commentr&   r&   r'   _check_for_type_comments  s    

r/  c               @  s   e Zd ZU dZded< eZded< dZded< dZd	ed
< dZ	ded< ddddZ
edddddZeddddddZdS )r  z
flake8-pyizClassVar[str]r8   versionNzast.Module | Noner  z(none)r!   r|   zargparse.Namespace | Noner}   zIterable[Error])r#   c             c  sX   | j d k	stt| j}|jdkrTt|E d H  t | j }t|d	|E d H  d S )Nz.pyi)r|   )
r  r   r   r|   suffixr/  r   rn  r  r   )r]   r"  r  r&   r&   r'   r     s    

zPyiTreeChecker.runr   rZ   )parserr#   c          	   C  s   t |jtjr|jjdd nHxF|jD ]<}|jdkr&d|_|j|jd< |j|	 _|j|jj
|j< q&W ttj |jddddd	d
 W dQ R X dS )z@This is brittle, there's multiple levels of caching of defaults.z
*.py,*.pyi)r|   z
--filenamer  z--no-pyi-aware-file-checkerF
store_trueTz/don't patch flake8 with .pyi-aware file checker)r  actionZparse_from_confighelpN)rb   r2  argparseArgumentParserset_defaultsr}   Zlong_option_namer  Zoption_kwargsZto_optparser  destr
   optparseOptionConflictError
add_option)r  r2  optionr&   r&   r'   add_options  s    
zPyiTreeChecker.add_optionszargparse.Namespace)
optmanagerr}   r#   c             C  s   |j stt_dS )z@This is also brittle, only checked with flake8 3.2.1 and master.N)Zno_pyi_aware_file_checkerrv   r   FileChecker)r  r?  r}   
extra_argsr&   r&   r'   parse_options.  s    zPyiTreeChecker.parse_options)r2   r3   r4   r8   r5   __version__r0  r  r|   r}   r   r	  r>  rB  r&   r&   r&   r'   r    s   
r  z)Y001 Name of private {} must start with _zQY002 If test must be a simple comparison against sys.platform or sys.version_infoz(Y003 Unrecognized sys.version_info checkz=Y004 Version comparison must use only major and minor versionz:Y005 Version comparison must be against a length-{n} tuplez.Y006 Use only < and >= for version comparisonsz$Y007 Unrecognized sys.platform checkz'Y008 Unrecognized platform "{platform}"z0Y009 Empty body should contain "...", not "pass"z*Y010 Function body must contain only "..."z5Y011 Default values for typed arguments must be "..."z'Y012 Class body must not contain "pass"z0Y013 Non-empty class body must not contain "..."z/Y014 Default values for arguments must be "..."zDY015 Bad default value. Use "{new_syntax}" instead of "{old_syntax}"z Y016 Duplicate union member "{}"z$Y017 Only simple assignments allowedz3Y018 {typevarlike_cls} "{typevar_name}" is not usedzJY019 Use "_typeshed.Self" instead of "{typevar_name}", e.g. "{new_syntax}"z5Y020 Quoted annotations should never be used in stubsz/Y021 Docstrings should not be included in stubsz?Y022 Use {good_syntax} instead of {bad_syntax} (PEP 585 syntax)z.Y023 Use {good_syntax} instead of {bad_syntax}z@Y024 Use "typing.NamedTuple" instead of "collections.namedtuple"z`Y025 Use "from collections.abc import Set as AbstractSet" to avoid confusion with "builtins.set"zJY026 Use typing_extensions.TypeAlias for type aliases, e.g. "{suggestion}"z?Y027 Use {good_syntax} instead of {bad_syntax} (PEP 585 syntax)z+Y028 Use class-based syntax for NamedTupleszFY029 Defining __repr__ or __str__ in a stub is almost always redundantz6Y030 Multiple Literal members in a union. {suggestion}z9Y031 Use class-based syntax for TypedDicts where possiblezQY032 Prefer "object" to "Any" for the second parameter in "{method_name}" methodsz[Y033 Do not use type comments in stubs (e.g. use "x: int" instead of "x = ... # type: int")z~Y034 {methods} usually return "self" at runtime. Consider using "_typeshed.Self" in "{method_name}", e.g. "{suggested_syntax}"zbY035 "{var}" in a stub file must have a value, as it has the same semantics as "{var}" at runtime.z2Y036 Badly defined {method_name} method: {details}zFY037 Use PEP 604 union types instead of {old_syntax} (e.g. {example}).zvY038 Use "from collections.abc import Set as AbstractSet" instead of "from typing import AbstractSet" (PEP 585 syntax)z'Y039 Use "str" instead of "typing.Text"zLY040 Do not inherit from "object" explicitly, as it is redundant in Python 3z{Y041 Use "{implicit_supertype}" instead of "{implicit_subtype} | {implicit_supertype}" (see "The numeric tower" in PEP 484)z<Y042 Type aliases should use the CamelCase naming conventionzAY043 Bad name for a type alias (the "T" suffix implies a TypeVar)zFY044 "from __future__ import annotations" has no effect in stub files.zJY045 "{iter_method}" methods should return an {good_cls}, not an {bad_cls}z+Y046 Protocol "{protocol_name}" is not usedz*Y047 Type alias "{alias_name}" is not usedz7Y048 Function body should contain exactly one statementz-Y049 TypedDict "{typeddict_name}" is not usedzQY050 Use "typing_extensions.Never" instead of "NoReturn" for argument annotationszKY051 "{literal_subtype}" is redundant in a union with "{builtin_supertype}")rL  r   r6  r   loggingr:  r   r   collectionsr   r   collections.abcr   r   r   r   
contextlibr	   r
   copyr   dataclassesr   	functoolsr   	itertoolsr   keywordr   pathlibr   r   r   r   r   r   r   Zflake8r   Zflake8.options.managerr   Zflake8.plugins.pyflakesr   Zpyflakes.checkerr   r   r   r   r   r   Zast_decompilerr    r   r(   r)   r*   rC  	getLoggerr   __version_info__r   r   r+   r5   r  r,   r6   r=  Z_TYPE_SLICEZ_COUNTER_SLICEZ_COROUTINE_SLICEZ_ASYNCGEN_SLICEr9  r,  r;   r-  r;  rY   r@  rv   NodeTransformerr   r   r   r   r   r  r  rx  rk  r  r   rs  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  NodeVisitorr  r!  r)  r/  r  rY  r  r  r  r  r  r  r  r  r  r  r  r  r  r]  r  rh  r  r  r~  r  r:  r.  r>  rO  ru  r<  ry  r  r  rz  r  r-  r  r  r  r?  rQ  r@  r  r  r  r  rP  r  r  r  r  r  r  r  r&   r&   r&   r'   <module>   s   

\
!",!	8        ,
2