
    \j              	         d Z ddlmZ ddlmZmZ ddl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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m Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 ddl4m5Z5 ddl6m7Z7 ddl8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@ ddlAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZX  G d d          ZYdddddddddd~d2ZZ	 ddd4Z[	 ddd5Z\	 ddd6Z]dd8Z^dd<Z_dd>Z`dd@ZaddBZbddDZcddHZdddLZeddNZfddOZgddRZhdddSddVZiddXZjddZZk	 ddd]Zldd`ZmdddaddeZnddiZoddjZpddlZq	 	 dddpZrddsZs edteEu          ZtdddwZuddyZvddzZwdd|Zxdd}ZydS )z!Type checking of attribute access    )annotations)CallableSequence)TypeVarcast)message_registrystate)TypeCheckerSharedApi)erase_typevars)expand_self_typeexpand_type_by_instancefreshen_all_functions_type_vars)lookup_stdlib_typeinfo)map_instance_to_supertype)is_overlapping_types)MessageBuilder)modules_state)ARG_POSARG_STAR	ARG_STAR2EXCLUDED_ENUM_ATTRIBUTESSYMBOL_FUNCBASE_TYPESContext	Decorator
ExpressionFuncBaseFuncDef	IndexExprMypyFileNameExprOverloadedFuncDefSymbolTableTempNode	TypeAliasTypeInfoTypeVarLikeExprVaris_final_node)AttributeContext)
is_subtype)	bind_selferase_to_boundfreeze_all_type_varsfunction_typeget_all_type_varsmake_simplified_unionsupported_self_typetuple_fallback)AnyTypeCallableTypeDeletedTypeFunctionLikeInstanceLiteralTypeNoneType
OverloadedParamSpecTypePartialType
ProperType	TupleTypeTypeTypedDictType	TypeOfAnyTypeTypeTypeVarLikeTypeTypeVarTupleTypeTypeVarTypeUninhabitedType	UnionTypeget_proper_typeinstance_cachec                  V    e Zd ZdZddddddddd&dZd'dZd(d Zd)d"Zdddd#d*d%ZdS )+MemberContextzInformation and objects needed to type check attribute access.

    Look at the docstring of analyze_member_access for more information.
    NF)	self_typemodule_symbol_tableno_deferralis_selfrvaluesuppress_errorspreserve_type_var_ids	is_lvalueboolis_superis_operatororiginal_typer?   contextr   chkr
   rL   Type | NonerM   SymbolTable | NonerN   rO   rP   Expression | NonerQ   rR   returnNonec                   || _         || _        || _        || _        |p|| _        || _        || _        |j        | _        || _        |	| _	        |
| _
        ||sJ || _        || _        || _        d S N)rS   rU   rV   rW   rL   rX   rY   msgrM   rN   rO   rP   rQ   rR   )selfrS   rU   rV   rW   rX   rY   rL   rM   rN   rO   rP   rQ   rR   s                 T/var/www/app.qaans.com/backend/venv/lib/python3.11/site-packages/mypy/checkmember.py__init__zMemberContext.__init__Y   s    " # &*"3m7#6 &. &;"""    namestrr7   c                6    | j                             |          S r`   )rY   
named_type)rb   rf   s     rc   ri   zMemberContext.named_type~   s    x""4(((re   c                <    | j                             ||           d S r`   )rY   handle_cannot_determine_type)rb   rf   rX   s      rc   not_ready_callbackz MemberContext.not_ready_callback   s     --dG<<<<<re   ra   c                X    | j         s"| j                            || j                   d S d S r`   )rQ   ra   failrX   )rb   ra   s     rc   rn   zMemberContext.fail   s5    # 	-HMM#t|,,,,,	- 	-re   )rL   rS   rW   bool | Nonec                   t          | j        | j        | j        | j        | j        | j        | j        | j        | j	        | j
        | j        | j                  }|||_        |||_        |||_        |S )N)rS   rU   rV   rW   rX   rY   rL   rM   rN   rP   rQ   rR   )rK   rS   rU   rV   rW   rX   rY   rL   rM   rN   rP   rQ   rR   )rb   rL   rS   rW   mxs        rc   copy_modifiedzMemberContext.copy_modified   s     n](,Ln $ 8(; 0"&"<
 
 
  $BL $BL$,B	re   )rS   rT   rU   rT   rV   rT   rW   r?   rX   r   rY   r
   rL   rZ   rM   r[   rN   rT   rO   rT   rP   r\   rQ   rT   rR   rT   r]   r^   )rf   rg   r]   r7   )rf   rg   rX   r   r]   r^   )ra   rg   r]   r^   )rL   rZ   rS   ro   rW   rZ   r]   rK   )	__name__
__module____qualname____doc__rd   ri   rl   rn   rr    re   rc   rK   rK   S   s          "&26!$( %&+#; #; #; #; #; #;J) ) ) )= = = =- - - - "&!%%)       re   rK   NF)override_infoin_literal_contextrL   rM   rN   rO   rP   rQ   rf   rg   typr?   rX   r   rS   rT   rU   rV   rW   rY   r
   rx   TypeInfo | Nonery   rL   rZ   rM   r[   rN   rO   rP   r\   rQ   r]   c                   t          |||||||
|||||          }t          | |||          }t          |          }|	r#t          |t                    r|j        |j        S |S )a  Return the type of attribute 'name' of 'typ'.

    The actual implementation is in '_analyze_member_access' and this docstring
    also applies to it.

    This is a general operation that supports various different variations:

      1. lvalue or non-lvalue access (setter or getter access)
      2. supertype access when using super() (is_super == True and
         'override_info' should refer to the supertype)

    'original_type' is the most precise inferred or declared type of the base object
    that we have available. When looking for an attribute of 'typ', we may perform
    recursive calls targeting the fallback type, and 'typ' may become some supertype
    of 'original_type'. 'original_type' is always preserved as the 'typ' type used in
    the initial, non-recursive call. The 'self_type' is a component of 'original_type'
    to which generic self should be bound (a narrower type that has a fallback to instance).
    Currently, this is used only for union types.

    'module_symbol_table' is passed to this function if 'typ' is actually a module,
    and we want to keep track of the available attributes of the module (since they
    are not available via the type object directly)

    'rvalue' can be provided optionally to infer better setter type when is_lvalue is True,
    most notably this helps for descriptors with overloaded __set__() method.

    'suppress_errors' will skip any logic that is only needed to generate error messages.
    Note that this more of a performance optimization, one should not rely on this to not
    show any messages, as some may be show e.g. by callbacks called here,
    use msg.filter_errors(), if needed.
    )rS   rU   rV   rW   rX   rY   rL   rM   rN   rO   rP   rQ   )rK   _analyze_member_accessrH   
isinstancer7   last_known_value)rf   rz   rX   rS   rU   rV   rW   rY   rx   ry   rL   rM   rN   rO   rP   rQ   rq   resultpossible_literals                      rc   analyze_member_accessr      s    d 
#/'
 
 
B $D#r=AAF&v..'22 -900re   rq   c                V   t          |          }t          |t                    rt          | |||          S t          |t                    rt	          t
          j        |          S t          |t                    rt          | ||          S t          |t                    r%|
                                rt          | ||          S t          |t                    rt          | |||          S t          |t                    rt          | t!          |          ||          S t          |t"          t          f          rt          | |j        ||          S t          |t&                    rt)          | |||          S t          |t*                    rt-          | ||          S t          |t.                    rWt          |t0                    r+|j        r$t          | t5          |j                  ||          S t          | |j        ||          S t          |t8                    r@|j        s |j                            ||j                    t	          t
          j!                  S t          |tD                    rtE                      }|j#        |_#        |S tI          |j%        || |          S )N)
source_any)&rH   r~   r7   analyze_instance_member_accessr3   rA   from_another_anyrG   analyze_union_member_accessr6   is_type_obj#analyze_type_callable_member_accessrB   analyze_type_type_member_accessr>   r}   r2   r8   fallbackr@   analyze_typeddict_accessr9   analyze_none_member_accessrC   rE   valuesr0   upper_boundr5   rQ   ra   deleted_as_rvaluerX   
from_errorrF   	ambiguousreport_missing_attributerW   )rf   rz   rq   rx   	attr_types        rc   r}   r}      sz    #

C#x   "-dC]KKK	C	!	!  y1cBBBB	C	#	# *4b999	C	&	& 3??+<+< 24bAAA	C	"	" .tS"mLLL	C	#	# %dN3,?,?]SSS	C+|4	5	5 %dCL"mLLL	C	'	' 'c2}EEE	C	"	" )$R888	C	)	) c;'' 	CJ 	)+CJ77]   &dCOROOO	C	%	% ! 	6F$$S"*555y+,,,	C	)	) #%%	!m	#B$4c4DDDre   c           	        |j         j        rdS |j                                         5  |j                                        5 }|j                             ||          }|	 ddd           ddd           dS t          | ||                    |          |          }|                                 cddd           cddd           S # 1 swxY w Y   ddd           dS # 1 swxY w Y   dS )z7Check if the given type has the attribute when awaited.FNrL   )	rY   checking_missing_awaitchecking_await_setra   filter_errorsget_precise_awaitable_typer}   rr   has_new_errors)rf   rz   rq   rx   local_errorsaw_type_s          rc   may_be_awaitable_attributer     s    
v$ u		"	"	$	$ 1 1bf&:&:&<&< 1&33CFF?1 1 1 1 1 1 1 1 1 1 1 1 1 1 #'2++g+>>
 
  ..0001 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1sA   C$C!C$9:C3C$C	C$C	C$$C(+C(c                Z   |j         rt          t          j                  S |j                            | |||j        |j                  }|j                                        s2t          ||||          r |j        
                    |j        |           t          t          j                  S r`   )rQ   r3   rA   r   ra   has_no_attrrX   rM   prefer_simple_messagesr   possible_missing_await)rW   rz   rf   rq   rx   
error_codes         rc   r   r   -  s     
 -y+,,,##M3bj"J`aaJ6((** B%dC]CC 	BF))"*jAAA9'(((re   r7   c                   |j         }|r|}|                    |           }| dk    rO|j        sH|j        sA|r|j        s8|                    t
          j                   t          t          j	                  S t          j        rj|j        t          j        d         k    rO| t          j        d         k    r9|j        s2|j                             dj        t          j         |j                   |rlt%          |t&                    sV|j        r|j        st)          ||           |j        rt%          |t,                    sJ |j        d         }t%          |t&                    sJ |j        r1|j        j        r%|j                            |j        |j                   t=          | |j        ||          S |j        r&|j        s|j                            |j                   t%          |t,                    s$tA          ||!                    d                    }nq|j         G|j"        s'|j        r |#                    |j        |j                   t          t          j$                  S t%          |j         tJ                    sJ |j         }|j&        stO          |          }|j(        s}t%          |tR          t,          f          r|j*        rtW          ||j,                  }nDt[          ||j,        |j.        |j        | |j                  }t_          ||j,        |j.                  }ta          ||j1                  }te          ||          }tg          |           |S ti          | |||          S )Nrd   r      zOccurrence of '{}.{}'builtins.functionis_classmethod)5type
get_methodrU   is_finalrn   r   CANNOT_ACCESS_INITr3   rA   r   r	   find_occurrencesrf   rQ   ra   noteformatrX   r~   r   validate_super_callis_propertyr!   itemsrS   varis_settable_propertyrY   warn_deprecatedsetteranalyze_varcant_assign_to_methodr.   ri   rN   rl   special_formr:   rR   r   	is_staticr   is_trivial_selfbind_self_fastrL   check_self_argis_classr+   r   infor   r-   analyze_member_var_access)	rf   rz   rq   rx   r   methodgetter	signaturemember_types	            rc   r   r   A  s^    8D __T""Fz"+dm 	1V_ 	1 GG$78889/000
 	YI/222E*1---" . 	2+2E4JKRZXXX  )>j33 )>; 	,r1 	,+++ 	:f&788888\!_Ffi00000| B
 ? B&&v}bjAAAtVZb999< 	5 2 	5F((444&"344 
	$%fbmm<O.P.PQQII{" ~ C&, C))&+rzBBBy5666fk:66666I' 	C7	BBI 	_&7,=">?? _FDZ _*9blCC		*r|V_bj$PRPV 	 &ifo^^^	'V[99-i==[))) )sD"===re   noder   r^   c                   d}t          | t                    r
| j        rd}nt          | t                    r| j        r5t          | j        t                    r| j        n| j        j        }|j        }nG| j        s@| j        r9t          | j        d         t                    sJ | j        d         j        j        }|r2|j	        
                    | j        | j        j        |j                   d S d S )NFTr   )r~   r   is_trivial_bodyr!   implfuncr   r   r   ra   unsafe_superrf   r   rX   )r   rq   r   r   s       rc   r   r     s    L$   >T%9 >	D+	,	, >9 	> *49g > >R499DIND/LL! 	>dj 	>djmY77777:a=-=L C
DIty~rzBBBBBC Cre   r6   c                   |j         d         j        }t          |t                    sJ t          |t                    rt          |          }t          |t                    r|j        }t          |t                    r|j        }t          |t                    rJ|j
        s-t          || ||j         d         j        |j                  }|r|S t          | |j        |          S J d|            )Nr   )original_varsmcs_fallbackFzUnexpected type )r   ret_typer~   r=   r>   r2   r@   r   r8   r7   rV   analyze_class_attribute_access	variablesr}   )rf   rz   rq   r   r   s        rc   r   r     s     y|$Hh
+++++(I&& ,!(++(M** %$(K(( %$(H%% 6~ 	 4$#)A,2HWZWc  F  %dCL"===5555555re   rB   c                &   d }|                     d          }t          |j        t                    r	|j        }n.t          |j        t                    rE|j                                        5  t          | |||          cd d d            S # 1 swxY w Y   nt          |j        t                    rt          |j        j
                  }t          |t                    r|}nt          |t                    r1t          | t          j        ||j        |j                  ||          S t          |t                     rt#          |          }nt          |t                    rC|j                                        5  t          | |||          cd d d            S # 1 swxY w Y   nt          |j        t                     rt#          |j                  }nt          |j        t$                    r&|j                                        r|j        j        }nOt          |j        t                    r5t          |j        j        t                    r|j        j        j        j        }d}||j        j        p|}|rO|j        sHt1          || |||          }|r2t          t          |          t                    r|j        j        s|S d}|j                            |          5  t          | |||          cd d d            S # 1 swxY w Y   d S )Nbuiltins.type)linecolumnF)r   rx   T)r   )ri   r~   itemr7   r3   ra   r   r}   rE   rH   r   rG   rB   make_normalizedr   r   r>   r2   r6   r   r   r   metaclass_typerV   r   fallback_to_any)	rf   rz   rq   rx   r   r   r   ignore_messagesr   s	            rc   r   r     s    D}}_--H#(H%% 5x	CHg	&	& 5V!!## 	M 	M)$"mLL	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M 	M	CHk	*	* 5%ch&:;;k8,, 	QDDY// 	Q)(38CJWWW	   Y// 	Q!+..DDW-- 	Q%%'' Q Q-dHb-PPQ Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q	CHi	(	( 5ch''	CHl	+	+ 50D0D0F0F 5x 	CHh	'	' 5chmX.. 	58=%4DO9+7x 
'BN 
'/$
 
 
  	'v66@@ 'TYE^ ' #'			O		<	< I I%dHb-HHI I I I I I I I I I I I I I I I I Is6   .BBB FF#&F#'LL
L
rG   c           	     *   |j                                         5  g }|                                D ]<}|                    |          }|                    t          | ||                     =	 d d d            n# 1 swxY w Y   t          |          S )Nr   )ra   disable_type_namesrelevant_itemsrr   appendr}   r0   )rf   rz   rq   resultssubtypeitem_mxs         rc   r   r     s    		"	"	$	$ K K))++ 	K 	KG&&&99GNN1$IIJJJJ	KK K K K K K K K K K K K K K K !)))s   AA;;A?A?r9   c           	         | dk    rKt          d|                    d                    }t          g g g ||                    d                    S t          | |                    d          |          S )N__bool__Fzbuiltins.boolr   r   )	arg_types	arg_kinds	arg_namesr   r   builtins.object)r8   ri   r4   r}   )rf   rz   rq   literal_falses       rc   r   r     s    z#EBMM/4R4RSSS"]]#677
 
 
 	
 &dBMM:K,L,LbQQQre   ityper   r%   c           
     	   |                     |           }|r|j        nd}|j                            ||j                   |}d}t          |t                    r>|j        }|j        j	        o|j
         }|j        r|j        st          |j        |           t          |t                    r
J d            t          |t                    r$|j        j                            |j                   t          |t&          t(          t          t*          f          rC|j        j                            ||j        |j                  }t3          | |          }||_        t          |t2                    r^||          j        }	|j        r5|j                                        st;          | ||j        |j                   t?          | ||||	|          S |s| dvr|j         s|j!        |j        sdD ]}
|"                    |
          }|r|j        j        dk    rtG          |||
|	          }tI          ||j                  }tK          tM          ||                    }t          |tN                    r|j(        }n|}|j        j         d
|  }|j        j)        *                    |          }|r= |tW          tK          |j,                  ||j        |j        |j                            }|c S n|"                    d          }|r|j        j        dk    rtG          ||d|-                    d          	          }tI          ||j                  }tK          tM          ||                    }t          |tN                    r%t]          |j/                  dk    r|j/        d         S |j0        j1        rte          tf          j4                  S |j5        r,| |j5        j6        v r|j5        j7        s|j5        j6        |          S |j        r@|j        s9|j        8                    | |j                   te          tf          j9                  S tu          |j,        || |          }|j!        | |j!        v rz|j!        |          j;        sh|j!        |          j        }ty          |           }|=                    |j                   ||_        |j        j        >                    ||j                  S |S )zAnalyse attribute access that does not target a method.

    This is logically part of analyze_member_access and the arguments are similar.

    original_type is the type of E in the expression E.var
    NFzDid not expect a function)r   implicitr   )__getattr____setattr____getattribute__)r   r   r   defnr   rf   rq   .r   )rS   r   )lvalue)?getr   rY   r   rX   r~   r   r   r   r   
decoratorsrU   rQ   r   r   r   module_refsaddfullnamer%   r$   r&   expr_checkeranalyze_static_referencerS   r'   r   r   get_final_contextcheck_final_memberra   r   rV   rM   r   $analyze_decorator_or_funcbase_accessr   rH   r   r4   r   pluginget_attribute_hookr)   rW   rr   lenr   r   r   r3   rA   r   extra_attrsattrsmod_nameundefined_in_superclassr   r   module_publicr    set_lineanalyze_ref_expr)rf   r   r   rq   r   vvvr   rz   r   method_namer   bound_methodgetattr_typer   r   hooksetattr_meth
bound_typesetattr_typeretes                         rc   r   r     s    88D>>D#		tAF1bj)))	
BO"i   -F'1G"-6G; 	-r1 	-,,,!W 211111!X + 	qz***"xHoFGG 
 f!::2rz2<XX3!S >6:& < 	? 8 8 : : 	?tT262:>>>4E2Rabbbb56JJJ K"*
 | ,	6B " "55
  "fk26GGG#G#5{r$ $ $L 4E6;GGC#23J<Y\3]3]#^#^L!,== .!-!6!- #)+"6????H6=;;HEED 	!%, /0@ A A & " "
 " " " "MMM="@  ??=99L 
6 1 :>O O OA%&''%'88	  
 0|7HII./FzSV/W/WXXlL99 6c,BX>Y>Y\]>]>]'1"55z! /y-...  1TU%6%<<< ) 	1$*400	{ 2- 
&&tRZ888y+,,,&r'7bII "....*40> / &t,1AAJJrz"""AF6&77",7OOO
re   ra   r   ctxc                    |j         D ]J}|j                            |           }|r,t          |j                  r|                    | d|           KdS )z?Give an error if the name being assigned was declared as final.T)attr_assignr  N)mronamesr   r(   r   cant_assign_to_final)rf   r   ra   r  basesyms         rc   r   r     sk     F FjnnT"" 	F=** 	F$$Tt$EEEF Fre   descriptor_typec           
        t          j                  }| }t          |           } t          | t                    r t	          fd| j        D                       S t          | t                    s|S j        s| j        	                    d          s|S j        r*| j        	                    d          rt          |           S j        r| j        	                    d          s|S | j                            d          }|h                    t          j                            |                     j        j                                       t'          t(          j                  S t-          || d                    |                     }t1          | |j                  }t5          ||          }t          |t6                    r5|                                r!|j        d         j        }t=                      }n-t          |t>                    r|j         }t=                      }n|}j!        j"        #                    | d          }	j!        j"        $                    |	|tK          |j&                  tK          t?          j'        |          j&                  gtP          tP          gj&        | 	          }j!        j"        )                    |tK          |j&                  tK          t?          j'        |          j&                  gtP          tP          gj&        | |	
          \  }
}j!        *                    |j&                   t          |          }t          |t&                    r|S t          |tV                    sh                    t          j                            |                     j        j                                       t'          t(          j                  S |j        S )a]  Type check descriptor access.

    Arguments:
        descriptor_type: The type of the descriptor attribute being accessed
            (the type of ``f`` in ``a.f`` when ``f`` is a descriptor).
        mx: The current member access context.
    Return:
        The return type of the appropriate ``__get__/__set__`` overload for the descriptor.
    c                0    g | ]}t          |          S rw   )analyze_descriptor_access).0rz   rq   s     rc   
<listcomp>z-analyze_descriptor_access.<locals>.<listcomp>  s$    QQQC&sB//QQQre   __get____set__Nr   r   r   rX   object_typer'  callable_name),rH   rL   r~   rG   r0   r   r7   rS   r   has_readable_memberanalyze_descriptor_assignr   rn   r   DESCRIPTOR_GET_NOT_CALLABLEr   str_with_optionsra   optionsr3   rA   r   r   rr   r   r   r   r6   r   r   r9   rB   r   rY   r   method_fullnametransform_callee_typer#   rX   r   r   
check_callr   r4   )r  rq   instance_typeorig_descriptor_type
dunder_getr  rz   dunder_get_type
owner_typer)  r   inferred_dunder_get_types    `          rc   r   r     s    $BL11M*%o66O/9-- $$QQQQ?;PQQQ
 
 	
 22 $##< $ 4 H H S S $## 
| >,@@KK >("===	| $O0DDYOO $## %00;;J
8??00@@ 	
 	
 	

 y+,,,7o66	  L $OZ_
E
EC-lC@@O-.. #=3L3L3N3N #"(+4
 

	M8	,	, #"'
 

"
F'77SSMf)??]BJ777X-j992:NNN	
 
'

# @ 
 
O #%&"5"@"@]BJ777X-j992:NNN	
 
'

## #A 
# 
#A F:rz222./GHH*G44 (''.== -
8??00@@ 	
 	
 	

 y+,,,#,,re   c           	     :   t          |j                  }| j                            d          }|m|                    t
          j                            |                     |j	        j
                            j                   t          t          j                  S t          || d|                    d|                     }t#          | |j                  }t'          ||          }|j        j                            | d          }|j        p,t1          t          t          j                  |j                  }|j        j                            ||t1          ||j                  |gt8          t8          g|j        |           }|}	|j	                                        5  |j        j                            |t1          ||j                  |	gt8          t8          g|j        | |          \  }
}d d d            n# 1 swxY w Y   t          |          }t?          |t@                    r-t1          t          t          j                  |j                  }	|j        j                            |t1          ||j                  |	gt8          t8          g|j        | |           |j        !                    ||j                   t?          |t@                    rtE          |j#                  dk     rt          t          j                  S |j#        d	         S )
Nr$  F)rS   rL   r   r%  r&  r(     r   )$rH   rL   r   r   rn   r   DESCRIPTOR_SET_NOT_CALLABLEr   r-  ra   r.  valuer3   rA   r   r   rr   r   r   r   rY   r   r/  rP   r#   r   rX   r0  r   r   r1  r~   r4   r   r  r   )r  rq   r2  
dunder_setr  rz   dunder_set_typer)  rP   type_contextr   inferred_dunder_set_types               rc   r+  r+    s#   #BL11M %00;;J
8??00@@ 	
 	
 	

 y+,,,7eGG	  L $OZ_
E
EC-lC@@OF'77SSMYW(79+A#B#BBJWWWFf)??	-	4	4	4f=	'

# @  O L					 
 
&(f&9&D&DmRZ888,GgJ'' 'E '
 '
##
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  //GHH*L99 U	(> ? ?TTTF""	-	4	4	4lC	'

## #    F:rz222 />> -$.//!33y+,,,#-a00s   &AHH	Hr   r'   c                    | j         | j        j        v o-| j        j        | j                  j        | u o| j         o| j         S )z;Return if var is an instance variable according to PEP 526.)rf   r   r  r   is_classvaris_inferred)r   s    rc   is_instance_varrC  M  sN     	CHN" 	 HN38$)S0	 	  re   r   r   r   c          	     b   |}t          ||j                  }|j        r|j        r|j        }||j        r|j        }n|j        }|rmt          |t                    r'|j	        
                    ||j        ||j                  S |j        rb|j        s[|j        r-|j        s&|j                            | |j        |j                   |j        r |j                            | |j                   t%          |||||          }d}	|j        rt)          |          r|j        r{t-          |          }t          |t.                    r|                                s|}	n@|j        r7|                    ||d          }
t-          t5          d||
                    }	n|}	t          |	t.                    rH|	                                s4|j        r-|j        s&|j        s|j                            |j                   |	r|j        sg }t          |	t:                    r|	j        n|	gD ]~}t-          |          }t          |t.                    r0|                                r|j        rtA          |||| ||          }nt%          |||||          }|!                    |           t;          j"        |          }nG|j        s'|j#        s |$                    |j%        |j                   tM          tN          j(                  }|j        j)         d|  }|j	        j*        +                    |          }|j        j,        r|j        s| |j        j-        v r,| dvr(t]          | |          }|                    |          }nHt          t-          |          x}t^                    r$|j        j)        d	k    r|j0        r|j0        d
         }|r-|s+|j        j1        rt)          |          ste          ||          }|r= |tg          t-          |j4                  ||j        |j        |j	                            }|S )a  Analyze access to an attribute via a Var node.

    This is conceptually part of analyze_member_access and the arguments are similar.
    itype is the instance type in which attribute should be looked up
    original_type is the type of E in the expression E.var
    if implicit is True, the original Var was created as an assignment to self
    if is_trivial_self is True, we can use fast path for bind_self().
    NF)rW   rL   rS   __call__r   >   rf   r;  r   r   enum.nonmemberr   )5r   r   r   rS   setter_typeis_readyr   r~   r<   rY   handle_partial_var_typerX   rQ   r   ra   read_only_propertyrA  cant_assign_to_classvarexpand_without_bindingis_initialized_in_classrC  rV   rH   r6   r   rr   r}   r   is_staticmethodrG   r   boundexpand_and_bind_callabler   
make_unionrN   rl   rf   r3   rA   r   r   r   r  is_enumenum_membersr8   r7   argsis_protocolr   r)   rW   )rf   r   r   rq   r   r   original_ityperz   r   	call_typedeco_mxbound_itemsctp_ctr   r   r  enum_literalp_results                      rc   r   r   Y  sw   $ N%eSX66E
 BL ?;3<;(Ch
 ,1c;'' 	V611#r|S"*UUU< 	A 2 	A Hs'? H))$
BJGGG A..tRZ@@@'S%LL (,	& 	 0D0D 	  	 !#&&C#|,,  S__5F5F  		  **W\*]]+,B:sT[,\,\]]			 i.. 	9y7L7L7N7N 	9| 9CO 9B<N 9,,RZ888  		7S0 		7K)3Iy)I)IZiooPY{ ) )&r**dL11 V4::<< V3? V3D#udBP_``DD1"c5.RTUUD""4(((()+66F| 	8BN 	8!!#(BJ777/00(#,,d,,H6=++H55D
x 
& 
&38(((T9J-J-J&te<<<L((,(GGFF?6#:#::xHEE	&&*::: ; ]1%F 7x 738#7 7OC<P<P 7*6266 
 01162<UWU[ 
 

 Mre   rW  c                    |j         st          |           } t          | |||          } t          | |          }t	          |           |S r`   )rR   r   expand_self_type_if_neededr   r-   )rz   r   r   rW  rq   expandeds         rc   rM  rM    sQ     # 3-c22
$S"c>
B
BC&sE22H"""Ore   functypec                    |j         st          |           } t          t          || |j                            }t          |t                    sJ |rt          ||j                  }nCt          ||j        |j	        |j
        ||j                  }t          ||j        |j	                  }t          ||          }t          |           |j        s|S t          |t                     r-|j        st%          t&          j                  S |j        d         }t          |t*                    s
J |            |j        r|j        r|j        |j        r|j        p,t7          t%          t&          j                  |j
                  }|j        j                            ||gt@          g|j
                  \  }	}
t          |
          }t          |t*                    sJ |j!        st%          t&          j                  S |j!        d         S |j"        S )Nr   r%  )#rR   r   rH   r   rL   r~   r6   r   r   r   rX   ra   r+   r   r-   r   r:   r   r3   rA   r   r4   r   rS   rH  r   rP   r#   r   rY   r   r1  r   r   r   )rb  r   r   rf   rq   r   rz   ra  type_ctxr   inferred_expandeds              rc   rQ  rQ    s    # =28<<
*3",GG
H
HCc<((((( ?S",//S",0BBJPTVXV\]]R\3+=>>&sE22H"""? (J'' % ~ 	19/000>!$h--77x777
 !BL !S_5P 	6yaHWY5K-L-LVXV`$a$a$aH#%6#6#A#A8*wi$ $ A  ''899Hh55555! 	1 9/000!!$$  re   tr   c                   t          |j                  }|j        sj|j        sc|j        }|rIt	          |t
                    r|j        }n,t	          |t                    rt          |j	                  }n|}t          || |          S t          t          |j                  dd          r6|j        }|rt	          |t
                    r|j        }t          || |          S |j        rY|j        |j        k    rI|j        j        =||j        j                                        k    rt          || |j        j                  S | S )zExpand special Self type in a backwards compatible manner.

    This should ensure that mixing old-style and new-style self-types work
    seamlessly. Also, re-bind new style self-types in subclasses if needed.
    F)allow_instancesallow_callable)rH   rL   rO   rU   r~   rB   r   r4   r   r   r   r1   r   r   rY   scopeactive_self_type)rf  rq   r   r   r   originalrepls          rc   r`  r`    sM    r|,,HJ  "+  | 	(H-- }Hl33 %h&788Q---	%%	
 
 
  | 	!
8X66 	!=DQ---

J#("" J ,RV\224444Q
(<===re   dispatched_arg_typer   c                b   | j         }|s| S g }|rt          j        |          }t          |          }|D ]}	|	j        r|	j        d         t          t          fvr|                    ||	|           | c S t          |	j        d                   }
t          |
t                    r;t          |t                    r&|
j        |j        u r|
j        rt          ||
          s|                    |	           |r|}g }|D ]}	t          |	j        d                   }
|dk    ot          |
t                    }|sQt!          |t#          t%          |
                    t'          d t)          |
          D                       d          r|                    |	           t          |
t*                    r|                    |	           t          |
t,                    rt.          |s!|                    |||d         ||           | S t3          |          dk    r|d         S t5          |          S )a  Check that an instance has a valid type for a method with annotated 'self'.

    For example if the method is defined as:
        class A:
            def f(self: S) -> T: ...
    then for 'x.f' we check that type(x) <: S. If the method is overloaded, we select
    only overloads items that satisfy this requirement. If there are no matching
    overloads, an error is generated.
    r   rE  c              3  B   K   | ]}t          |t                     V  d S r`   )r~   rE   r!  tvs     rc   	<genexpr>z!check_self_arg.<locals>.<genexpr>Y  s@       ! !46Jr;///! ! ! ! ! !re   T)always_covariantignore_pos_arg_namesr   )r   rB   r   rH   r   r   r   r   no_formal_selfr~   r7   r   rU  r   r   r4   r*   r   r,   anyr/   r;   rD   NotImplementedErrorincompatible_self_argumentr  r:   )rb  rn  r   rX   rf   ra   r   	new_itemsp_dispatched_arg_typer   selfargself_callables               rc   r   r      s   " NE I L&67JKK+,?@@  ~ 	!27H:M!M!MtT7333 OOO!$."344gx(( 	Z8Mx-X-X 	|4999gl9+,A7KK   	 & &!$."344
*Pz'</P/P 	&J >'2233 ! ! !:KG:T:T! ! !   "&
 
 
 	& T""""// 	&T""""!122 	&%%	& &&%uQx	
 	
 	
 
9~~|i   re   )rx   r   r   r    Sequence[TypeVarLikeType] | Nonec          
        | j         }|r|}|j         d| }|j        j                            |          }|                    |          }	|	sk| j        r,|| j        j        v r| j        j        s| j        j        |         S |j	        s|j
        r(t          ||t          t          j                            S dS t          |	j        t"                    r*|	j        j        s|s|j                             |          rdS |j                            |	j        |j                   t          |	j        t*                    }
|
pt          |	j        t,                    }|j        ra|j        sZ|r|j                            |j                   t          |	j        t6                    r|                    t:          j                   |j        r;||j        v r2|                    t:          j         !                    |                     |	j"        rt          |	j        t"                    r|	j        j#        r=|                    t:          j$        !                    |	j        j%                             nS|j        sLtM          ||          s<|                    t:          j'        !                    |	j        j%                             |j        r5|j        (                                stS          |||j        |j                   |j*        r/|j        s(|
s&|s$tW          | ||          }|rt          |||          S |	j         }|r't          |tX                    rT|	j        }t          |t"                    sJ t          |||j        -                    ||j        ||j                            S t          |	j        t*                    r|	j        j.        j/        }n0t          |	j        t"          t`          f          r|	j        j/        }nd}|sd}ntc          | |          }t          |	j        t"                    r|J te          |j3                  }|	j        j         }ti          |	j        j/        j5        j6                  }|r5|	j        j/        j3        r$|7                    |	j        j/        j3                   t          |tp                     p|	j"        }|rY|ti          ts          |                    z  r:|	j        j        rt:          j:        }nt:          j;        }|                    |           ty          |||	j        | d          }t{          ||          }|reti          | j         j5        j6                  }|r+| j         j3        r|7                    | j         j3                   t}          |d |D                       }|
r$t          t*          |	j                  j@        jA        pKt          |	j        t`                    o|	j        jA        p%t          |	j        t"                    o|	j        jB        }te          |          }d}t          |	j        t*                    r|	j        j@        jC        o|	j        jD         }n-t          |	j        t          t          f          r|	j        jC        }t          |t                    r;|r9|s7|H                                s#t          ||j3        d|j        ||j                  }t          ||||||          }|
r1ty          ||t          t*          |	j                  j.        | |          }|}|j        st          ||          }t          |||          S t          |	j        t"                    r4|L                    ||j                   t          t          j                  S t          |	j        t6          t          t          t          f          r0|j        jP        Q                    |	j        |j        |j                  S |
rwt          |	j        t*                    sJ |	j        j         rt          |||	j        j                   S |L                    ||j                   t          t          jR                  S t          |	j        t`                    sJ t          |	j        |T                    d                    }|	j        jA        rt          |          }t          |||          S )	a   Analyze access to an attribute on a class object.

    itype is the return type of the class object callable, original_type is the type
    of E in the expression E.var, original_vars are type variables of the class callable
    (for generic classes).
    r   NT)r   c                    h | ]	}|j         
S rw   )idrq  s     rc   	<setcomp>z1analyze_class_attribute_access.<locals>.<setcomp>  s    &B&B&Bru&B&B&Bre   F)r   r   r   )Vr   r   rY   r   get_class_attribute_hookr   r  r  r  r   meta_fallback_to_anyapply_class_attr_hookr3   rA   r   r~   r   r'   rA  r   rX   r   r   rS   rQ   ra   r   r%   rn   r   CANNOT_ASSIGN_TO_TYPEslotsCLASS_VAR_CONFLICTS_SLOTSr   r   r   !CANNOT_ACCESS_FINAL_INSTANCE_ATTRrf   defined_in_superclass CANNOT_ACCESS_INSTANCE_ONLY_ATTRr   r   rS  #analyze_enum_class_attribute_accessr<   rJ  r   r   r   r   rH   rL   setr   	type_varsr   rB   r/   GENERIC_CLASS_VAR_ACCESS!GENERIC_INSTANCE_VAR_CLASS_ACCESSr`  r   r   r   r   r   r   r   r   r   r!   r6   rP  r   add_class_tvarsr   rl   r$   r   r&   r   r   r   r.   ri   r   )r   rf   rq   r   rx   r   r   r   r  r   is_decorated	is_methodenum_class_attribute_typerf  symnode
super_infoisuperr'  prohibit_selfdef_varsprohibit_genericmessage
erase_varsr   r   r   rz   s                              rc   r   r   o  s    :D -(($((H6=11(;;D88D>>D  	5):)@!@!@$- 5(.t44 	T4#< 	T(T79;Q3R3RSSSt 	49c""	%  !!$''	 tF49bj111di33L?
49h ? ?I	| <B. < 	5F((444di** 	<GG$:;;; z Iddj((
 :AA$GGHHH} ^DIs33 ^9 	^ GG$FMMdin]]^^^^ 	^&;D$&G&G 	^GG$ELLTY^\\]]] 
| ;BF4466 ;4rvrz:::| NR\ N\ NY N$GtUW$X$X!$ 	N(T3LMMM	A d/a%% 	iGgs+++++(D"&88BL'SUS]^^  
 di++ 	*.)-*<JJ	C)>#?@@ 	JJJ  	BFF.ujAAFdi%% 	D%%%)",77K !%	 55M49>.899H 7!9 7TY^5666#-k8#D#DDU !Hs3DQ3G3G/H/H$H !9( Q.GGG.PG   *1b$)UTRRRA'622A
   D !:;;
  9UZ%9 9NN5:#7888"1&B&Bz&B&B&BCC Fd9di88=F )49&;<<SAS)$)S)) )	(	 	 Adi++ 	8"in<YTYEYAYOO	G->#?@@ 	8"i7Oq,''	Q	Q $	Q GGII		Q q",rz4PPA'+
 
 
  	*2tIty115u~  A | 	;.vr::F$Rv666	DIs	#	# /
dBJ///y-...$)h	8_MNN av";;DIrzSUS_``` 4$)Y/////9> 	1(T49>BBB!!$
3339/000$)%:;;;;;DIr}}5H'I'IJJ 9 	& %%C$Rs333re   r  )Callable[[AttributeContext], Type] | Noner   c           	         |r= |t          t          | j                  || j        | j        | j                            }|S r`   )r)   rH   rW   rS   rX   rY   )rq   r  r   s      rc   r  r  <  sO      
 01162<UWU[ 
 

 Mre   c                   |t           v rt          |j        | ||          S | j                            |          }|rT|j        rMt          |j                  }t          |t                    r$|j        j        dk    r|j	        r|j	        d         S || j        j
        vrd S t          ||           }|                     |          S )NrG  r   r   rF  )r   r   rW   r   r   rH   r~   r7   r   rU  rT  r8   rr   )r   rf   rq   r   properr]  s         rc   r  r  H  s     ''''(8%rJJJ:>>$D "	 " ++ vx((	"$(888 9 ;q>!5:***tte444L===re   r@   c           	        | dk    rt          |j        t                    rd|j        j                            ||j        j        d          \  }}|j        |z  }|r(|j        s!|j	        
                    ||j                   nt          t          j                  }t          |j                            d          |gt           t           gd d gt#                      |j                            d          |           S | dk    rYt          |j                            d          gt           gd gt#                      |j                            d          |           S t%          | |j        ||          S )	N__setitem__T)setitemr%  zbuiltins.strr   )r   r   r   r   r   rf   __delitem__)r~   rX   r   rY   r   visit_typeddict_index_exprindexreadonly_keysrQ   ra   readonly_keys_mutatedr3   rA   implementation_artifactr4   ri   r   r9   r}   r   )rf   rz   rq   rx   	item_type	key_namesassigned_readonly_keyss          rc   r   r   a  s    }bj),, 	C $&6#6#Q#QRZ%t $R $ $ Iy &)%6%B"% Yb.@ Y,,-CRZ,XXX  	 ABBIv((88)D(TlZZV&&':;;
 
 
 	
 
		v((889ifZZV&&':;;
 
 
 	
 "$b-HHHre   r=   r  Instance | Nonec                &   t          | t                    rng }j        st          |           } r6| j        s/|rt          | j                  } nt          | j        d          } t          |           } t          |            | 
                    t          |          t          | j                  z             S t          | t                    r#t          fd| j        D                       S t          |           } | S )a  Instantiate type variables during analyze_class_attribute_access,
    e.g T and Q in the following:

    class A(Generic[T]):
        @classmethod
        def foo(cls: Type[Q]) -> Tuple[T, Q]: ...

    class B(A[str]): pass
    B.foo()

    Args:
        t: Declared type of the method (or property)
        isuper: Current instance mapped to the superclass where method was defined, this
            is usually done by map_instance_to_supertype()
        is_classmethod: True if this method is decorated with @classmethod
        original_vars: Type variables of the class callable on which the method was accessed
        is_trivial_self: if True, we can use fast path for bind_self().
    Returns:
        Expanded method type with added type variables (when needed).
    NTr   )r   c                ^    g | ])}t          t          t          |                     *S ))r   )r   r4   r  )r!  r   r   r  rq   r   s     rc   r"  z#add_class_tvars.<locals>.<listcomp>  sO       
 	  #D&."Tabbb   re   )r~   r4   rR   r   is_boundr   rL   r+   r   r-   rr   listr   r:   r   )rf  r  r   rq   r   r   tvarss    ````  rc   r  r    sK   T !\"" 
!.!:' 	3/22A 	D!* 	D D"1bl33adCCC'622AQetAK7H7H)HIII	Az	"	" 	
      
 G  
 
 	
 #Av..Hre   r   Decorator | FuncBasec                   t          | t                    rt          || j        ||          S t	          | |j                            d                    }t          | t          t          f          r| j	        rt          ||j                  S t          ||j        | j        |j        ||j                  }t!          ||j        | j                  S )zAnalyzes the type behind method access.

    The function itself can possibly be decorated.
    See: https://github.com/python/mypy/issues/10409
    r   )rW   r   )r~   r   r   r   r.   rY   ri   r   r!   r   r   rL   r   r   rX   ra   r+   )r   r   rf   rq   rz   s        rc   r   r     s     $	"" 645"555
bf//0CDD
E
EC$"3455 1$:N 1c2<000
blDM2:tRV
T
TCST]SSSSre   F)rP  r   c                   t          | t                    r5fd| j        D             }t          t          t          |                    S t          | t
                    sJ | j        s| S | j        d         t          t          fv r| S | 
                    | j        dd         | j        dd         | j        dd         d          S )zReturn a copy of `method`, with the type of its first parameter (usually
    self or cls) bound to original_type.

    This is a faster version of mypy.typeops.bind_self() that can be used for methods
    with trivial self/cls annotations.
    c                0    g | ]}t          |          S rw   )r   )r!  crW   s     rc   r"  z"bind_self_fast.<locals>.<listcomp>  s#    HHHa=11HHHre   r   r   NT)r   r   r   r  )r~   r:   r   r   r  r4   r   r   r   r   rr   r   )r   rW   r   s    ` rc   r   r     s     &*%% *HHHH6<HHHAz%(()))fl+++++ x333"122&"122&"122&	     re   	op_methodc                2   t          |           } t          | t                    r|                                 } t          | t                    rdS t          | t
                    r-t          fd|                                 D                       S t          | t                    r3| 	                                r| j
        j                                      S t          | t                    r| j        }t          |t                    r|                                }t          |t
                    r-t          fd|                                D                       S t!          |          S t#          |           j                                      S )a  Does type have operator with the given name?

    Note: this follows the rules for operator access, in particular:
    * __getattr__ is not considered
    * for class objects we only look in metaclass
    * instance level attributes (i.e. extra_attrs) are not considered
    Tc              3  8   K   | ]}t          |          V  d S r`   )has_operatorr!  xr  s     rc   rs  zhas_operator.<locals>.<genexpr>  s-      LL!<9--LLLLLLre   c              3  8   K   | ]}t          |          V  d S r`   )meta_has_operatorr  s     rc   rs  zhas_operator.<locals>.<genexpr>  s.      VV1(I66VVVVVVre   )rH   r~   rC   values_or_boundr3   rG   allr   r6   r   r   r   r*  rB   r   rE   r  instance_fallback)rz   r  r   s    ` rc   r  r    s{    #

C#'' $!!###w t#y!! MLLLLs7I7I7K7KLLLLLL#|$$ @):): @| 44Y???#x   	2 xdK(( 	*''))DdI&& 	WVVVV@S@S@U@UVVVVVV y111S!!&::9EEEre   c                V   t          | t                    r| S t          | t                    rt          |           S t          | t          t
          f          r| j        S t          j        4t          dt          j                  }t          |g           t          _        t          j        S )Nr   )r~   r7   r>   r2   r8   r@   r   rI   r'  r   r   modules)rz   object_typeinfos     rc   r  r    s    #x   
#y!! #c"""#]344 |!)01BMDYZZ%-or%B%B"%%re   r   c                   t          |           } t          | t                    rdS t          |           } | j        j        }|*t          dt          j                  }t          |g           }|j        
                    |          S )NTr   )rH   r~   r3   r  r   r   r   r   r  r7   r*  )r   r  meta	type_types       rc   r  r  +  sy    4  D$   tT""D9#D|*?M<QRR		2&&9((333re   c                    | j         dd         D ]N}|j                            |          x}0|j        s)t	          |j        t                    r|j        j        r dS OdS )zPCheck if a variable has an explicit value at class level in any of superclasses.r   NTF)r  r  r   r   r~   r   r'   has_explicit_value)r   rf   r  r   s       rc   r  r  7  sj      JNN4(((D5= Z	3%?%? DID` tt5re   )"rf   rg   rz   r?   rX   r   rS   rT   rU   rT   rV   rT   rW   r?   rY   r
   rx   r{   ry   rT   rL   rZ   rM   r[   rN   rT   rO   rT   rP   r\   rQ   rT   r]   r?   r`   )
rf   rg   rz   r?   rq   rK   rx   r{   r]   r?   )
rf   rg   rz   r?   rq   rK   rx   r{   r]   rT   )rW   r?   rz   r?   rf   rg   rq   rK   rx   r{   r]   r?   )
rf   rg   rz   r7   rq   rK   rx   r{   r]   r?   )r   r   rq   rK   r]   r^   )rf   rg   rz   r6   rq   rK   r]   r?   )
rf   rg   rz   rB   rq   rK   rx   r{   r]   r?   )rf   rg   rz   rG   rq   rK   r]   r?   )rf   rg   rz   r9   rq   rK   r]   r?   )
rf   rg   r   r7   r   r%   rq   rK   r]   r?   )
rf   rg   r   r%   ra   r   r  r   r]   r^   )r  r?   rq   rK   r]   r?   )r  r7   rq   rK   r]   r?   )r   r'   r]   rT   )rf   rg   r   r'   r   r7   rq   rK   r   rT   r   rT   r]   r?   )rz   r?   r   r'   r   r7   rW  r7   rq   rK   r]   r?   )rb  r6   r   r'   r   r7   rf   rg   rq   rK   r   rT   r]   r?   )F)rf  r?   rq   rK   r   r'   r   r7   r   rT   r]   r?   )rb  r6   rn  r?   r   rT   rX   r   rf   rg   ra   r   r]   r6   )r   r7   rf   rg   rq   rK   r   r7   rx   r{   r   r~  r]   rZ   )rq   rK   r  r  r   r?   r]   rZ   )r   r7   rf   rg   rq   rK   r]   rZ   )
rf   rg   rz   r@   rq   rK   rx   r{   r]   r?   )NF)rf  r=   r  r  r   rT   rq   rK   r   r~  r   rT   r]   r?   )
r   r  r   r7   rf   rg   rq   rK   r]   r?   )r   r  rW   rZ   r]   r  )rz   r?   r  rg   r]   rT   )rz   r=   r]   r7   )r   r?   r  rg   r]   rT   )r   r%   rf   rg   r]   rT   )zrv   
__future__r   collections.abcr   r   typingr   r   mypyr   r	   mypy.checker_sharedr
   mypy.erasetyper   mypy.expandtyper   r   r   mypy.lookupr   mypy.maptyper   	mypy.meetr   mypy.messagesr   mypy.modules_stater   
mypy.nodesr   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   r&   r'   r(   mypy.pluginr)   mypy.subtypesr*   mypy.typeopsr+   r,   r-   r.   r/   r0   r1   r2   
mypy.typesr3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rK   r   r}   r   r   r   r   r   r   r   r   r   r   r   r+  rC  r   rM  rQ  r`  r   r   r  r  r   r  r   r  r   r  r  r  r  rw   re   rc   <module>r     s"   ' ' " " " " " " . . . . . . . .                 ( ( ( ( ( ( ( ( 4 4 4 4 4 4 ) ) ) ) ) )         
 / . . . . . 2 2 2 2 2 2 * * * * * * ( ( ( ( ( ( , , , , , ,                                             . ) ( ( ( ( ( $ $ $ $ $ $	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	                                                 6P P P P P P P Pz &*$!.2 $!#I I I I I IZ OS'E 'E 'E 'E 'EV OS1 1 1 1 1, &*) ) ) ) )(D> D> D> D>NC C C C#6 #6 #6 #6L5I 5I 5I 5Ip* * * *R R R RC C C CLF F F Fj- j- j- j-ZB1 B1 B1 B1J	 	 	 	$ !^ ^ ^ ^ ^ ^B   ,! ,! ,! ,!` MR) ) ) ) )XL! L! L! L!j &*6:J4 J4 J4 J4 J4 J4Z	 	 	 	> > > >2$I $I $I $IX 7;!C C C C CLT T T T" GC|$$$    2 F  F  F  FF
& 
& 
& 
&	4 	4 	4 	4     re   