
    6 fh                   F   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Zd dl	Z	d dl
Z
d dlmZmZmZ d dlZd dlmZmZ d dlmZ ej        d"d
            ZdZdZdZdZ	 d#d$dZ G d d          Zd%dZ G d de
j                  Zd&dZ  G d  d!e
j                  Z!dS )'    )annotationsN)AnyCallableIterator)parse_options
test_stubs)root_dirmod_namestrreturnIterator[str]c              #    K   t          j                    }t          j                                        }t          j                    5 }	 t          j        |           t          j        d         |k    r t          j                            d|           |V  |                                t          _        | t          j	        v rt          j	        | = t          j        |           nR# |                                t          _        | t          j	        v rt          j	        | = t          j        |           w xY w	 d d d            d S # 1 swxY w Y   d S )Nr   )
osgetcwdsyspathcopytempfileTemporaryDirectorychdirinsertmodules)r
   currentcurrent_syspathtmps       L/var/www/equiseq/venv/lib/python3.11/site-packages/mypy/test/teststubtest.pyuse_tmp_dirr      sU     ikkGhmmooO		$	&	& #
	HSMMMx{c!!3'''III&++--CH3;&&K)HW	 '++--CH3;&&K)HW                 s-   E	AC%AE%AD44EE	E	test_modulea  
Any = object()

class _SpecialForm:
    def __getitem__(self, typeargs: Any) -> object: ...

Callable: _SpecialForm = ...
Generic: _SpecialForm = ...
Protocol: _SpecialForm = ...
Union: _SpecialForm = ...

class TypeVar:
    def __init__(self, name, covariant: bool = ..., contravariant: bool = ...) -> None: ...

class ParamSpec:
    def __init__(self, name: str) -> None: ...

AnyStr = TypeVar("AnyStr", str, bytes)
_T = TypeVar("_T")
_T_co = TypeVar("_T_co", covariant=True)
_K = TypeVar("_K")
_V = TypeVar("_V")
_S = TypeVar("_S", contravariant=True)
_R = TypeVar("_R", covariant=True)

class Coroutine(Generic[_T_co, _S, _R]): ...
class Iterable(Generic[_T_co]): ...
class Iterator(Iterable[_T_co]): ...
class Mapping(Generic[_K, _V]): ...
class Match(Generic[AnyStr]): ...
class Sequence(Iterable[_T_co]): ...
class Tuple(Sequence[_T_co]): ...
class NamedTuple(tuple[Any, ...]): ...
def overload(func: _T) -> _T: ...
a  
from typing import Generic, Mapping, Sequence, TypeVar, overload

T = TypeVar('T')
T_co = TypeVar('T_co', covariant=True)
KT = TypeVar('KT')
VT = TypeVar('VT')

class object:
    __module__: str
    def __init__(self) -> None: pass
    def __repr__(self) -> str: pass
class type: ...

class tuple(Sequence[T_co], Generic[T_co]):
    def __ge__(self, __other: tuple[T_co, ...]) -> bool: pass

class dict(Mapping[KT, VT]): ...

class function: pass
class ellipsis: pass

class int: ...
class float: ...
class bool(int): ...
class str: ...
class bytes: ...

class list(Sequence[T]): ...

def property(f: T) -> T: ...
def classmethod(f: T) -> T: ...
def staticmethod(f: T) -> T: ...
a  
import sys
from typing import Any, TypeVar, Iterator

_T = TypeVar('_T')

class EnumMeta(type):
    def __len__(self) -> int: pass
    def __iter__(self: type[_T]) -> Iterator[_T]: pass
    def __reversed__(self: type[_T]) -> Iterator[_T]: pass
    def __getitem__(self: type[_T], name: str) -> _T: pass

class Enum(metaclass=EnumMeta):
    def __new__(cls: type[_T], value: object) -> _T: pass
    def __repr__(self) -> str: pass
    def __str__(self) -> str: pass
    def __format__(self, format_spec: str) -> str: pass
    def __hash__(self) -> Any: pass
    def __reduce_ex__(self, proto: Any) -> Any: pass
    name: str
    value: Any

class Flag(Enum):
    def __or__(self: _T, other: _T) -> _T: pass
    def __and__(self: _T, other: _T) -> _T: pass
    def __xor__(self: _T, other: _T) -> _T: pass
    def __invert__(self: _T) -> _T: pass
    if sys.version_info >= (3, 11):
        __ror__ = __or__
        __rand__ = __and__
        __rxor__ = __xor__
stubruntimeoptions	list[str]config_file
str | Nonec                v   t          t                    5 }t          dd          5 }|                    t                     d d d            n# 1 swxY w Y   t          dd          5 }|                    t
                     d d d            n# 1 swxY w Y   t          dd          5 }|                    t                     d d d            n# 1 swxY w Y   t          t           dd          5 }|                    |            d d d            n# 1 swxY w Y   t          t           dd          5 }|                    |           d d d            n# 1 swxY w Y   |rTt          t           dd          5 }|                    |           d d d            n# 1 swxY w Y   |dt           dgz   }t          j                    }t          j
        |          5  t          t          t          g|z             d	
           d d d            n# 1 swxY w Y   t          |                                                    t           j                            |          t           j        z   d                              |t           j        z   d                    cd d d            S # 1 swxY w Y   d S )Nzbuiltins.pyiwz
typing.pyizenum.pyiz.pyi.pyz_config.iniz--mypy-config-fileT)use_builtins_fixtures )r   TEST_MODULE_NAMEopenwritestubtest_builtins_stubstubtest_typing_stubstubtest_enum_stubioStringIO
contextlibredirect_stdoutr   r   remove_color_codegetvaluereplacer   r   realpathsep)r   r    r!   r#   tmp_dirfoutputs          r   run_stubtestr<      sj    
%	&	& 
'.#&& 	,!GG*+++	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	, 	,,$$ 	*GG()))	* 	* 	* 	* 	* 	* 	* 	* 	* 	* 	* 	* 	* 	* 	**c"" 	(aGG&'''	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	( 	(%+++S11 	QGGDMMM	 	 	 	 	 	 	 	 	 	 	 	 	 	 	%***C00 	AGGG	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	Y)666<< %$$$% % % % % % % % % % % % % % %!5:J7W7W7W XXG'// 	` 	`}&6%7'%ABBZ^____	` 	` 	` 	` 	` 	` 	` 	` 	` 	` 	` 	` 	` 	` 	` OOWRW%%g..7<<WWWrvEUWY=Z=Z
 
%
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
s  J.AJ.A	J.A	J.(BJ.B	J.B	J.*CJ.C	J.C	J.4D
J.D	J.D	J.9EJ.E	J."E	#J. F"J."F&	&J.)F&	*9J.#(HJ.H	J.H	BJ..J25J2c                      e Zd ZddZdS )	Caser   r   r    errorr$   c                0    || _         || _        || _        d S Nr   r    r?   )selfr   r    r?   s       r   __init__zCase.__init__   s    	


    N)r   r   r    r   r?   r$   )__name__
__module____qualname__rD    rE   r   r>   r>      s(             rE   r>   fnCallable[..., Iterator[Case]]Callable[..., None]c                     d fd}|S )zrun_stubtest used to be slow, so we used this decorator to combine cases.

    If you're reading this and bored, feel free to refactor this and make it more like
    other mypy tests.

    argsr   kwargsr   Nonec                 L   t           | i |          }t                      }|D ]~}|j        
|j        }|dk    rt          }n)|                    t           d          st           d| }||vsJ d                    |                      |                    |           t          d                    d |D                       d                    d |D                       dg          }t          |	                                          }||k    s
J |            d S )	Nr)   .z_collect_cases merges cases into a single stubtest invocation; we already expect an error for {}z

c              3  n   K   | ]0}t          j        |j                            d                     V  1dS 
N)textwrapdedentr   lstrip.0cs     r   	<genexpr>z.collect_cases.<locals>.test.<locals>.<genexpr>   s:      QQaX_QV]]4-@-@AAQQQQQQrE   c              3  n   K   | ]0}t          j        |j                            d                     V  1dS rT   )rV   rW   r    rX   rY   s     r   r\   z.collect_cases.<locals>.test.<locals>.<genexpr>   s<      WWA	0@0@0F0F G GWWWWWWrE   --generate-allowlistr   r    r!   )
listsetr?   r*   
startswithformataddr<   join
splitlines)	rN   rO   casesexpected_errorsr[   expected_errorr;   actual_errorsrJ   s	           r   testzcollect_cases.<locals>.test   sc   RR((())%% 	0 	0AwWN##!1#..2B/E/E/EFF H$4!G!G~!G!G!888))/)?)? 988 ////QQ5QQQQQKKWWQVWWWWW+,
 
 
 F--//00////////rE   )rN   r   rO   r   r   rP   rI   )rJ   rk   s   ` r   collect_casesrl      s(    8 8 8 8 8 82 KrE   c                     e Zd Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Z	ed+d	            Z
ed+d
            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Zed+d            Z ed+d             Z!ed+d!            Z"ed+d"            Z#ed+d#            Z$ed+d$            Z%ed+d%            Z&ed+d&            Z'ed+d'            Z(ed+d(            Z)ed+d)            Z*d*S ),StubtestUnitr   Iterator[Case]c              #  Z   K   t          ddd           V  t          ddd           V  d S )Nz*def f(number: int, text: str) -> None: ...zdef f(number, text): passrB   zc
            class X:
                def f(self, number: int, text: str) -> None: ...
            zR
            class X:
                def f(self, number, text): pass
            r>   rC   s    r   test_basic_goodzStubtestUnit.test_basic_good   sl      =/
 
 
 	
 	
 	

  

 

 

 
	
 
	
 
	
 
	
 
	
rE   c              #     K   t          ddd          V  t          ddd          V  t          dd	d
          V  d S )Nz!def mistyped_class() -> None: ...zclass mistyped_class: passmistyped_classrB   zclass mistyped_fn: ...zdef mistyped_fn(): passmistyped_fnzU
            class X:
                def mistyped_var(self) -> int: ...
            zC
            class X:
                mistyped_var = 1
            zX.mistyped_varrq   rr   s    r   
test_typeszStubtestUnit.test_types   s      40"
 
 
 	
 	
 	

 )3LTa
 
 
 	
 	
 	
  #

 

 

 
	
 
	
 
	
 
	
 
	
rE   c              #     K   t          ddd          V  t          ddd           V  t          ddd           V  t          d	d
d           V  d S )Nzdef bar() -> int: ...zasync def bar(): return 5barrB   zasync def foo() -> int: ...zdef foo(): return 5zdef baz() -> int: ...zdef baz(): return 5zasync def bingo() -> int: ...zasync def bingo(): return 5rq   rr   s    r   test_coroutineszStubtestUnit.test_coroutines  s      /9T\abbbbbb5?T\`aaaaaa/9NVZ[[[[[[0:W_c
 
 
 	
 	
 	
 	
 	
rE   c              #     K   t          ddd          V  t          ddd           V  t          ddd	          V  t          d
dd          V  t          ddd           V  d S )N,def bad(number: int, text: str) -> None: ...z def bad(num, text) -> None: passbadrB   7def good_posonly(__number: int, text: str) -> None: ...z$def good_posonly(num, /, text): passz6def bad_posonly(__number: int, text: str) -> None: ...z$def bad_posonly(flag, /, text): passbad_posonlyzk
            class BadMethod:
                def f(self, number: int, text: str) -> None: ...
            zU
            class BadMethod:
                def f(self, n, text): pass
            zBadMethod.fze
            class GoodDunder:
                def __exit__(self, t, v, tb) -> None: ...
            zo
            class GoodDunder:
                def __exit__(self, exc_type, exc_val, exc_tb): pass
            rq   rr   s    r   test_arg_namezStubtestUnit.test_arg_name  s      ?6
 
 
 	
 	
 	

 J:
 
 
 	
 	
 	

 I:
 
 
 	
 	
 	

   

 

 

 
	
 
	
 
	
  

 

 

 
	
 
	
 
	
 
	
 
	
rE   c              #     K   t          ddd          V  t          ddd          V  t          dd	d
          V  t          ddd           V  t          ddd          V  t          ddd          V  d S )Nz7def runtime_kwonly(number: int, text: str) -> None: ...z)def runtime_kwonly(number, *, text): passruntime_kwonlyrB   z7def stub_kwonly(number: int, *, text: str) -> None: ...z#def stub_kwonly(number, text): passstub_kwonlyz7def stub_posonly(__number: int, text: str) -> None: ...z$def stub_posonly(number, text): passstub_posonlyr~   z'def good_posonly(number, /, text): passz8def runtime_posonly(number: int, text: str) -> None: ...z*def runtime_posonly(number, /, text): passruntime_posonlyz<def stub_posonly_570(number: int, /, text: str) -> None: ...z(def stub_posonly_570(number, text): passstub_posonly_570rq   rr   s    r   test_arg_kindzStubtestUnit.test_arg_kind4  s     J?"
 
 
 	
 	
 	

 J9
 
 
 	
 	
 	

 J: 
 
 
 	
 	
 	

 J=
 
 
 	
 	
 	

 K@#
 
 
 	
 	
 	

 O>$
 
 
 	
 	
 	
 	
 	
rE   c              #     K   t          ddd           V  t          ddd          V  t          ddd	          V  t          d
dd          V  t          ddd          V  t          ddd          V  d S )Nz$def f1(text: str = ...) -> None: ...zdef f1(text = 'asdf'): passrB   z$def f2(text: str = ...) -> None: ...zdef f2(text): passf2zdef f3(text: str) -> None: ...zdef f3(text = 'asdf'): passf3z$def f4(text: str = ...) -> None: ...zdef f4(text = None): passf4z&def f5(data: bytes = ...) -> None: ...zdef f5(data = 'asdf'): passf5z
            from typing import TypeVar
            _T = TypeVar("_T", bound=str)
            def f6(text: _T = ...) -> None: ...
            zdef f6(text = None): passf6rq   rr   s    r   test_default_presencez"StubtestUnit.test_default_presenceU  s     71
 
 
 	
 	
 	

 7AU]a
 
 
 	
 	
 	
 11
 
 
 	
 	
 	

 7/
 
 
 	
 	
 	

 91
 
 
 	
 	
 	

 
 0
 
 
 	
 	
 	
 	
 	
rE   c              #    K   t          ddd          V  t          ddd           V  t          ddd	          V  t          d
dd          V  t          ddd          V  t          ddd           V  t          ddd           V  t          ddd          V  t          ddd          V  t          ddd           V  d S )Nz$def f1(text: str = 'x') -> None: ...zdef f1(text = 'y'): passf1rB   z(def f2(text: bytes = b"x'") -> None: ...zdef f2(text = b"x'"): passz(def f3(text: bytes = b"y'") -> None: ...zdef f3(text = b"x'"): passr   z%def f4(text: object = 1) -> None: ...zdef f4(text = 1.0): passr   z(def f5(text: object = True) -> None: ...zdef f5(text = 1): passr   z(def f6(text: object = True) -> None: ...zdef f6(text = True): passz,def f7(text: object = not True) -> None: ...zdef f7(text = False): passz,def f8(text: object = not True) -> None: ...zdef f8(text = True): passf8z*def f9(text: object = {1: 2}) -> None: ...zdef f9(text = {1: 3}): passf9z+def f10(text: object = [1, 2]) -> None: ...zdef f10(text = [1, 2]): passrq   rr   s    r   test_default_valuezStubtestUnit.test_default_valuex  s     7.
 
 
 	
 	
 	

 <1
 
 
 	
 	
 	

 <1
 
 
 	
 	
 	

 8.
 
 
 	
 	
 	

 ;,
 
 
 	
 	
 	

 ;/
 
 
 	
 	
 	

 ?0
 
 
 	
 	
 	

 ?/
 
 
 	
 	
 	

 =1
 
 
 	
 	
 	

 >2
 
 
 	
 	
 	
 	
 	
rE   c              #     K   t          ddd           V  t          ddd          V  t          ddd	          V  t          d
dd          V  t          ddd           V  d S )Nz
            class Good:
                @classmethod
                def f(cls, number: int, text: str) -> None: ...
            zq
            class Good:
                @classmethod
                def f(cls, number, text): pass
            rB   ze
            class Bad1:
                def f(cls, number: int, text: str) -> None: ...
            zq
            class Bad1:
                @classmethod
                def f(cls, number, text): pass
            zBad1.fz
            class Bad2:
                @classmethod
                def f(cls, number: int, text: str) -> None: ...
            zs
            class Bad2:
                @staticmethod
                def f(self, number, text): pass
            zBad2.fz
            class Bad3:
                @staticmethod
                def f(cls, number: int, text: str) -> None: ...
            zr
            class Bad3:
                @classmethod
                def f(self, number, text): pass
            zBad3.fz_
            class GoodNew:
                def __new__(cls, *args, **kwargs): ...
            z`
            class GoodNew:
                def __new__(cls, *args, **kwargs): pass
            rq   rr   s    r   test_static_class_methodz%StubtestUnit.test_static_class_method  s     

 
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
 

 
 
 
 	
 	
 	
 

 
 
 
 	
 	
 	
  

 

 

 
	
 
	
 
	
 
	
 
	
rE   c              #     K   t          ddd           V  t          ddd          V  t          ddd	          V  t          d
dd          V  t          ddd          V  d S )Nzdef f1(a, *, b, c) -> None: ...zdef f1(a, *, b, c): passrB   zdef f2(a, *, b) -> None: ...zdef f2(a, *, b, c): passr   zdef f3(a, *, b, c) -> None: ...zdef f3(a, *, b): passr   zdef f4(a, *, b, c) -> None: ...zdef f4(a, b, *, c): passr   zdef f5(a, b, *, c) -> None: ...zdef f5(a, *, b, c): passr   rq   rr   s    r   test_arg_mismatchzStubtestUnit.test_arg_mismatch  s      2<V^b
 
 
 	
 	
 	
 /9S[_
 
 
 	
 	
 	
 2<S[_
 
 
 	
 	
 	
 2<V^b
 
 
 	
 	
 	
 2<V^b
 
 
 	
 	
 	
 	
 	
rE   c              #    K   t          ddd           V  t          ddd          V  t          ddd           V  t          d	d
d          V  t          ddd           V  t          ddd          V  t          ddd          V  t          ddd          V  t          ddd          V  t          ddd          V  t          ddd          V  t          d d!d"          V  t          d#d$d           V  t          d%d&d'          V  t          d(d)d           V  t          d*d+d,          V  t          d-d.d/          V  d S )0Nz$def f1(*args, **kwargs) -> None: ...zdef f1(*args, **kwargs): passrB   z$def f2(*args, **kwargs) -> None: ...zdef f2(**kwargs): passr   zdef g1(a, b, c, d) -> None: ...zdef g1(a, *args): passz&def g2(a, b, c, d, *args) -> None: ...zdef g2(a): passg2z&def g3(a, b, c, d, *args) -> None: ...zdef g3(a, *args): passzdef h1(a) -> None: ...zdef h1(a, b, c, d, *args): passh1zdef h2(a, *args) -> None: ...zdef h2(a, b, c, d): passh2zdef h3(a, *args) -> None: ...zdef h3(a, b, c, d, *args): passh3z"def j1(a: int, *args) -> None: ...zdef j1(a): passj1zdef j2(a: int) -> None: ...zdef j2(a, *args): passj2zdef j3(a, b, c) -> None: ...zdef j3(a, *args, c): passj3z def k1(a, **kwargs) -> None: ...zdef k1(a): passk1zdef k2(a) -> None: ...zdef k2(a, **kwargs): passzdef k3(a, b) -> None: ...zdef k3(a, **kwargs): passk3zdef k4(a, *, b) -> None: ...zdef k4(a, **kwargs): passzdef k5(a, *, b) -> None: ...z"def k5(a, *, b, c, **kwargs): passk5z&def k6(a, *, b, **kwargs) -> None: ...z"def k6(a, *, b, c, **kwargs): passk6rq   rr   s    r   test_varargs_varkwargsz#StubtestUnit.test_varargs_varkwargs   s     73
 
 
 	
 	
 	

 7,
 
 
 	
 	
 	

 2<T\`
 
 
 	
 	
 	
 9CT\`
 
 
 	
 	
 	
 9,
 
 
 	
 	
 	

 )3T\`
 
 
 	
 	
 	
 0:T\`
 
 
 	
 	
 	
 05
 
 
 	
 	
 	

 5?PX\
 
 
 	
 	
 	
 .8PX\
 
 
 	
 	
 	
 /9T\`
 
 
 	
 	
 	
 :DU]abbbbbb)/	
 
 
 	
 	
 	
 ,6QY]
 
 
 	
 	
 	
 /9T\`
 
 
 	
 	
 	
 /8
 
 
 	
 	
 	

 98
 
 
 	
 	
 	
 	
 	
rE   c              #     K   t          ddd           V  t          ddd          V  t          ddd	          V  t          d
dd           V  t          ddd           V  d S )Nz
            from typing import overload

            @overload
            def f1(a: int, *, c: int = ...) -> int: ...
            @overload
            def f1(a: int, b: int, c: int = ...) -> str: ...
            zdef f1(a, b = 0, c = 0): passrB   z
            @overload
            def f2(a: int, *, c: int = ...) -> int: ...
            @overload
            def f2(a: int, b: int, c: int = ...) -> str: ...
            zdef f2(a, b, c = 0): passr   z
            @overload
            def f3(a: int) -> int: ...
            @overload
            def f3(a: int, b: str) -> str: ...
            zdef f3(a, b = None): passr   z
            @overload
            def f4(a: int, *args, b: int, **kwargs) -> int: ...
            @overload
            def f4(a: str, *args, b: int, **kwargs) -> str: ...
            z#def f4(a, *args, b, **kwargs): passz
            @overload
            def f5(__a: int) -> int: ...
            @overload
            def f5(__b: str) -> str: ...
            zdef f5(x, /): passrq   rr   s    r   test_overloadzStubtestUnit.test_overloadC  s       4
 
 
 	
 	
 	
  0	
 	
 	
 		
 		
 		
  0	
 	
 	
 		
 		
 		
  :	
 	
 	
 		
 		
 		
  )	
 	
 	
 		
 		
 		
 		
 		
rE   c              #  "  K   t          ddd           V  t          ddd          V  t          ddd           V  t          d	d
d          V  t          ddd          V  t          ddd           V  t          ddd           V  d S )Nzt
            class Good:
                @property
                def read_only_attr(self) -> int: ...
            zr
            class Good:
                @property
                def read_only_attr(self): return 1
            rB   zf
            class Bad:
                @property
                def f(self) -> int: ...
            zQ
            class Bad:
                def f(self) -> int: return 1
            zBad.fzo
            class GoodReadOnly:
                @property
                def f(self) -> int: ...
            zC
            class GoodReadOnly:
                f = 1
            zn
            class BadReadOnly:
                @property
                def f(self) -> str: ...
            zB
            class BadReadOnly:
                f = 1
            zBadReadOnly.fz
            class Y:
                @property
                def read_only_attr(self) -> int: ...
                @read_only_attr.setter
                def read_only_attr(self, val: int) -> None: ...
            o
            class Y:
                @property
                def read_only_attr(self): return 5
            Y.read_only_attrz
            class Z:
                @property
                def read_write_attr(self) -> int: ...
                @read_write_attr.setter
                def read_write_attr(self, val: int) -> None: ...
            
            class Z:
                @property
                def read_write_attr(self): return self._val
                @read_write_attr.setter
                def read_write_attr(self, val): self._val = val
            zr
            class FineAndDandy:
                @property
                def attr(self) -> int: ...
            a  
            class _EvilDescriptor:
                def __get__(self, instance, ownerclass=None):
                    if instance is None:
                        raise AttributeError('no')
                    return 42
                def __set__(self, instance, value):
                    raise AttributeError('no')

            class FineAndDandy:
                attr = _EvilDescriptor()
            rq   rr   s    r   test_propertyzStubtestUnit.test_propertyz  sl     

 
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
 
 "
 
 
 	
 	
 	
 
 %
 
 
 	
 	
 	
  
 
 
 	
 	
 	
" 
 %
 
 
 	
 	
 	
 	
 	
rE   c              #    K   t          ddd           V  t          ddd          V  t          ddd           V  t          d	d
d           V  t          ddd          V  t          ddd          V  t          ddd          V  t          ddd           V  t          ddd          V  t          ddd           V  d S )Nzx1: intzx1 = 5rB   zx2: strzx2 = 5x2zfrom typing import Tupler)   z-
            x3: Tuple[int, int]
            zx3 = (1, 3)z-
            x4: Tuple[int, int]
            zx4 = (1, 3, 5)x4zx5: intzdef x5(a, b): passx5z-def foo(a: int, b: int) -> None: ...
x6 = fooz&def foo(a, b): pass
def x6(c, d): passx6z9
            class X:
                f: int
            zj
            class X:
                def __init__(self):
                    self.f = "asdf"
            zF
            class Y:
                read_only_attr: int
            r   r   zG
            class Z:
                read_write_attr: int
            r   rq   rr   s    r   test_varzStubtestUnit.test_var  s     	84@@@@@@	84@@@@@@-r488888 "
 
 
 	
 	
 	
  %
 
 
 	
 	
 	
 	+?tLLLLLLA=
 
 
 	
 	
 	

 
 
 
 
 	
 	
 	
 
 %
 
 
 	
 	
 	
  
 
 
 	
 	
 	
 	
 	
rE   c              #    K   t          ddd           V  t          ddd          V  t          ddd	          V  t          d
dd          V  t          ddd           V  t          ddd          V  t          ddd          V  t          ddd           V  t          ddd          V  t          ddd          V  t          ddd          V  t          dd d           V  t          d!d"d           V  t          d#d#d           V  t          d$d%d           V  t          d&d'd           V  t          j        d(k    rt          d)d*d           V  d S d S )+Nz
            import collections.abc
            import re
            import typing
            from typing import Callable, Dict, Generic, Iterable, List, Match, Tuple, TypeVar, Union
            z
            import collections.abc
            import re
            from typing import Callable, Dict, Generic, Iterable, List, Match, Tuple, TypeVar, Union
            rB   z]
            class X:
                def f(self) -> None: ...
            Y = X
            zd
            class X:
                def f(self) -> None: ...
            class Y: ...
            zY.fzA = Tuple[int, str]zA = (int, str)AzB = strr)   Bz_C = intzr
            D = tuple[str, str]
            E = Tuple[int, int, int]
            F = Tuple[str, int]
            zl
            D = Tuple[str, str]
            E = Tuple[int, int, int]
            F = List[str]
            Fzb
            G = str | int
            H = Union[str, bool]
            I = str | int
            zb
            G = Union[str, int]
            H = Union[str, bool]
            I = str
            Iz
            K = dict[str, str]
            L = Dict[int, int]
            KK = collections.abc.Iterable[str]
            LL = typing.Iterable[str]
            z
            K = Dict[str, str]
            L = Dict[int, int]
            KK = Iterable[str]
            LL = Iterable[str]
            z
            _T = TypeVar("_T")
            class _Spam(Generic[_T]):
                def foo(self) -> None: ...
            IntFood = _Spam[int]
            z
            _T = TypeVar("_T")
            class _Bacon(Generic[_T]):
                def foo(self, arg): pass
            IntFood = _Bacon[int]
            zIntFood.foozStrList = list[str]zStrList = ['foo', 'bar']StrListz
            N = typing.Callable[[str], bool]
            O = collections.abc.Callable[[int], str]
            P = typing.Callable[[str], bool]
            zl
            N = Callable[[str], bool]
            O = Callable[[int], str]
            P = int
            Pzb
            class Foo:
                class Bar: ...
            BarAlias = Foo.Bar
            zc
            class Foo:
                class Bar: pass
            BarAlias = Foo.Bar
            zV
            from io import StringIO
            StringIOAlias = StringIO
            zW
            from _io import StringIO
            StringIOAlias = StringIO
            zM = Match[str]zk
            class Baz:
                def fizz(self) -> None: ...
            BazAlias = Baz
            z
            class Baz:
                def fizz(self): pass
            BazAlias = Baz
            Baz.__name__ = Baz.__qualname__ = Baz.__module__ = "New"
            z
            class FooBar:
                __module__: None  # type: ignore
                def fizz(self) -> None: ...
            FooBarAlias = FooBar
            z
            class FooBar:
                def fizz(self): pass
            FooBarAlias = FooBar
            FooBar.__module__ = None
               
   a  
                Q = Dict[str, str]
                R = dict[int, int]
                S = Tuple[int, int]
                T = tuple[str, str]
                U = int | str
                V = Union[int, str]
                W = typing.Callable[[str], bool]
                Z = collections.abc.Callable[[str], bool]
                QQ = typing.Iterable[str]
                RR = collections.abc.Iterable[str]
                MM = typing.Match[str]
                MMM = re.Match[str]
                a  
                Q = dict[str, str]
                R = dict[int, int]
                S = tuple[int, int]
                T = tuple[str, str]
                U = int | str
                V = int | str
                W = collections.abc.Callable[[str], bool]
                Z = collections.abc.Callable[[str], bool]
                QQ = collections.abc.Iterable[str]
                RR = collections.abc.Iterable[str]
                MM = re.Match[str]
                MMM = re.Match[str]
                r>   r   version_inforr   s    r   test_type_aliaszStubtestUnit.test_type_alias"  s
     
 
 
 
 	
 	
 	
 

 
 
 
 	
 	
 	
 -7GsSSSSSS	2S999999
Bd;;;;;;

 
 
 
 	
 	
 	
 

 
 
 
 	
 	
 	
  
 
 
 	
 	
 	
   
 
 
 	
 	
 	
 -7QYbcccccc

 
 
 
 	
 	
 	
 

 
 
 
 	
 	
 	
  

 

 

 
	
 
	
 
	
 (2B$OOOOOO
 
 
 
 	
 	
 	
  
 
 
 	
 	
 	
 w&& ;        '&rE   c              #  "  K   t          ddd           V  t          ddd          V  t          ddd           V  t          dd	d
          V  t          ddd           V  t          ddd          V  t          ddd           V  d S )Nzimport enumrB   zr
            class X(enum.Enum):
                a: int
                b: str
                c: str
            zt
            class X(enum.Enum):
                a = 1
                b = "asdf"
                c = 2
            zX.cz
            class Flags1(enum.Flag):
                a: int
                b: int
            def foo(x: Flags1 = ...) -> None: ...
            z
            class Flags1(enum.Flag):
                a = 1
                b = 2
            def foo(x=Flags1.a|Flags1.b): pass
            z
            class Flags2(enum.Flag):
                a: int
                b: int
            def bar(x: Flags2 | None = None) -> None: ...
            z
            class Flags2(enum.Flag):
                a = 1
                b = 2
            def bar(x=Flags2.a|Flags2.b): pass
            ry   z
            class Flags3(enum.Flag):
                a: int
                b: int
            def baz(x: Flags3 | None = ...) -> None: ...
            z
            class Flags3(enum.Flag):
                a = 1
                b = 2
            def baz(x=Flags3(0)): pass
            z
            class Flags4(enum.Flag):
                a: int
                b: int
            def spam(x: Flags4 | None = None) -> None: ...
            z
            class Flags4(enum.Flag):
                a = 1
                b = 2
            def spam(x=Flags4(0)): pass
            spama  
            from typing_extensions import Final, Literal
            class BytesEnum(bytes, enum.Enum):
                a: bytes
            FOO: Literal[BytesEnum.a]
            BAR: Final = BytesEnum.a
            BAZ: BytesEnum
            EGGS: bytes
            z
            class BytesEnum(bytes, enum.Enum):
                a = b'foo'
            FOO = BytesEnum.a
            BAR = BytesEnum.a
            BAZ = BytesEnum.a
            EGGS = BytesEnum.a
            rq   rr   s    r   	test_enumzStubtestUnit.test_enum  sU     }DIIIIII 
 
 
 	
 	
 	
  
 
 
 	
 	
 	
  
 
 
 	
 	
 	
  
 
 
 	
 	
 	
  
 
 
 	
 	
 	
  %
 
 
 	
 	
 	
 	
 	
rE   c              #  2   K   t          ddd           V  d S )Nz
            from typing import Any, Callable
            def decorator(f: Callable[[], int]) -> Callable[..., Any]: ...
            @decorator
            def f() -> Any: ...
            zi
            def decorator(f): return f
            @decorator
            def f(): return 3
            rB   rq   rr   s    r   test_decoratorzStubtestUnit.test_decoratorD  s@      
 
 
 
 	
 	
 	
 	
 	
rE   c              #  2   K   t          ddd           V  d S )NzZ: intz+
            __all__ = []
            Z = 5rB   rq   rr   s    r   test_all_at_runtime_not_stubz)StubtestUnit.test_all_at_runtime_not_stubU  s>       
 
 
 	
 	
 	
 	
 	
rE   c              #  2   K   t          ddd          V  d S )Nz__all__ = ()r)   __all__rB   rq   rr   s    r   test_all_in_stub_not_at_runtimez,StubtestUnit.test_all_in_stub_not_at_runtime_  s'      )DDDDDDDDrE   c              #  2   K   t          ddd          V  d S )Nz@
            __all__ = ['foo']
            foo: str
            z>
            __all__ = []
            foo = 'foo'
            r   rB   rq   rr   s    r   ,test_all_in_stub_different_to_all_at_runtimez9StubtestUnit.test_all_in_stub_different_to_all_at_runtimec  sB      
  

 

 

 
	
 
	
 
	
 
	
 
	
rE   c              #    K   t          ddd          V  t          ddd          V  t          ddd          V  t          d	dd
          V  t          ddd           V  t          ddd          V  t          ddd          V  t          ddd          V  t          ddd          V  t          ddd           V  d S )Nzx = 5r)   xrB   def f(): ...r:   zclass X: ...Xz
            from typing import overload
            @overload
            def h(x: int): ...
            @overload
            def h(x: str): ...
            hz__all__ = []z__all__ += ['y']
y = 5yz__all__ += ['g']
def g(): passgz5from mystery import A, B as B, C as D  # type: ignorer   zclass Y: ...zF__all__ += ['Y']
class Y:
  def __or__(self, other): return self|otherzY.__or__zclass Z: ...z=__all__ += ['Z']
class Z:
  def __reduce__(self): return (Z,)rq   rr   s    r   test_missingzStubtestUnit.test_missingt  sf     3777777#>>>>>>#>>>>>> 

 

 

 
	
 
	
 
	
 N$??????$=SIIIIII$ESQQQQQQHRT\_
 
 
 	
 	
 	
 ^
 
 
 	
 	
 	

 U
 
 
 	
 	
 	
 	
 	
rE   c              #     K   t          ddd           V  t          ddd          V  t          ddd          V  t          ddd	          V  t          dd
d           V  t          ddd           V  d S )Nr)   z
import sysrB   def g(): ...r   zCONSTANT = 0CONSTANTz'import re; constant = re.compile('foo')constantz"from json.scanner import NUMBER_REz from string import ascii_lettersrq   rr   s    r   test_missing_no_runtime_allz(StubtestUnit.test_missing_no_runtime_all  s      L======N#>>>>>>N*EEEEEE$MU_``````$HPTUUUUUU$FdSSSSSSSSrE   c              #  j   K   t          ddt           d          V  t          ddd          V  d S )Nz__all__: list[str]r)   z.__all__rB   z_f: intzdef _f(): ..._f)r>   r*   rr   s    r   test_non_public_1zStubtestUnit.test_non_public_1  s[      %r<L9V9V9V
 
 
 	
 	
 	
 	?$GGGGGGGGrE   c              #     K   t          ddd           V  t          ddd          V  t          ddd	          V  d S )
Nz__all__: list[str] = ['f']z__all__ = ['f']rB   zf: intr   r:   zg: intr   r   rq   rr   s    r   test_non_public_2zStubtestUnit.test_non_public_2  s`      4>OW[\\\\\\.DDDDDD.DDDDDDDDrE   c              #     K   t          ddd          V  t          ddd          V  t          dd	d           V  t          j        d
k    rt          ddd           V  d S d S )Nz:class A:
  def __init__(self, a: int, b: int) -> None: ...z*class A:
  def __init__(self, a, bx): passz
A.__init__rB   z:class B:
  def __call__(self, c: int, d: int) -> None: ...z*class B:
  def __call__(self, c, dx): passz
B.__call__zXclass C:
  def __init_subclass__(
    cls, e: int = ..., **kwargs: int
  ) -> None: ...
z:class C:
  def __init_subclass__(cls, e=1, **kwargs): pass)r   	   z>class D:
  def __class_getitem__(cls, type: type) -> type: ...z0class D:
  def __class_getitem__(cls, type): ...r   rr   s    r   test_dunderszStubtestUnit.test_dunders  s      NA
 
 
 	
 	
 	

 NA
 
 
 	
 	
 	

 %
 R	
 	
 	
 		
 		
 		
 v%%VK        &%rE   c              #  Z   K   t          ddd           V  t          ddd          V  d S )Nzclass CanBeSubclassed: ...rB   zCclass CannotBeSubclassed:
  def __init_subclass__(cls) -> None: ...zGclass CannotBeSubclassed:
  def __init_subclass__(cls): raise TypeErrorCannotBeSubclassedrq   rr   s    r   test_not_subclassablez"StubtestUnit.test_not_subclassable  sf      -7S[_
 
 
 	
 	
 	
 W^&
 
 
 	
 	
 	
 	
 	
rE   c              #    K   t          ddd           V  t          ddd           V  t          ddd           V  t          ddd	          V  t          d
dd           V  t          ddd           V  t          ddd          V  t          ddd          V  t          ddd          V  t          ddd          V  t          ddd          V  t          ddd          V  t          d d!d"          V  d S )#Nz#from typing_extensions import finalzZ
            import functools
            from typing_extensions import final
            rB   z9
            @final
            class A: ...
            z9
            @final
            class B: ...
            z&
            class B: ...
            z&
            class C: ...
            z9
            @final
            class C: ...
            Ca  
            class D:
                @final
                def foo(self) -> None: ...
                @final
                @staticmethod
                def bar() -> None: ...
                @staticmethod
                @final
                def bar2() -> None: ...
                @final
                @classmethod
                def baz(cls) -> None: ...
                @classmethod
                @final
                def baz2(cls) -> None: ...
                @property
                @final
                def eggs(self) -> int: ...
                @final
                @property
                def eggs2(self) -> int: ...
                @final
                def ham(self, obj: int) -> int: ...
            a  
            class D:
                @final
                def foo(self): pass
                @final
                @staticmethod
                def bar(): pass
                @staticmethod
                @final
                def bar2(): pass
                @final
                @classmethod
                def baz(cls): pass
                @classmethod
                @final
                def baz2(cls): pass
                @property
                @final
                def eggs(self): return 42
                @final
                @property
                def eggs2(self): pass
                @final
                @functools.lru_cache()
                def ham(self, obj): return obj * 2
            a  
            class E:
                @final
                def foo(self) -> None: ...
                @final
                @staticmethod
                def bar() -> None: ...
                @staticmethod
                @final
                def bar2() -> None: ...
                @final
                @classmethod
                def baz(cls) -> None: ...
                @classmethod
                @final
                def baz2(cls) -> None: ...
                @property
                @final
                def eggs(self) -> int: ...
                @final
                @property
                def eggs2(self) -> int: ...
                @final
                def ham(self, obj: int) -> int: ...
            a'  
            class E:
                def foo(self): pass
                @staticmethod
                def bar(): pass
                @staticmethod
                def bar2(): pass
                @classmethod
                def baz(cls): pass
                @classmethod
                def baz2(cls): pass
                @property
                def eggs(self): return 42
                @property
                def eggs2(self): return 42
                @functools.lru_cache()
                def ham(self, obj): return obj * 2
            zM
            class F:
                def foo(self) -> None: ...
            z]
            class F:
                @final
                def foo(self): pass
            zF.foozg
            class G:
                @staticmethod
                def foo() -> None: ...
            zw
            class G:
                @final
                @staticmethod
                def foo(): pass
            zG.foozg
            class H:
                @staticmethod
                def foo() -> None: ...
            zw
            class H:
                @staticmethod
                @final
                def foo(): pass
            zH.foozi
            class I:
                @classmethod
                def foo(cls) -> None: ...
            zy
            class I:
                @final
                @classmethod
                def foo(cls): pass
            zI.foozi
            class J:
                @classmethod
                def foo(cls) -> None: ...
            zy
            class J:
                @classmethod
                @final
                def foo(cls): pass
            zJ.foozf
            class K:
                @property
                def foo(self) -> int: ...
            z|
            class K:
                @property
                @final
                def foo(self): return 42
            zK.foozV
            class L:
                def foo(self, obj: int) -> int: ...
            z
            class L:
                @final
                @functools.lru_cache()
                def foo(self, obj): return obj * 2
            zL.foorq   rr   s    r    test_has_runtime_final_decoratorz-StubtestUnit.test_has_runtime_final_decorator  s     6 
 
 
 	
 	
 	
  

 

 

 
	
 
	
 
	
  	
 	
 	
 		
 		
 		
  	
 	
 	
 		
 		
 		
 24 i5
 5
 5
 5	
 5	
 5	
n 2$ Y-
 -
 -
 -	
 -	
 -	
^ 
 
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
@  
 
 
 	
 	
 	
 	
 	
rE   c              #     K   t          ddd          V  t          ddd          V  t          dd	d
          V  t          ddd          V  d S )Nz
            class X:
                def __mangle_good(self, text: str) -> None: ...
                def __mangle_bad(self, number: int) -> None: ...
            z
            class X:
                def __mangle_good(self, text): pass
                def __mangle_bad(self, text): pass
            zX.__mangle_badrB   z
            class Klass:
                class __Mangled1:
                    class __Mangled2:
                        def __mangle_good(self, text: str) -> None: ...
                        def __mangle_bad(self, number: int) -> None: ...
            z
            class Klass:
                class __Mangled1:
                    class __Mangled2:
                        def __mangle_good(self, text): pass
                        def __mangle_bad(self, text): pass
            z(Klass.__Mangled1.__Mangled2.__mangle_badz
            class __Dunder__:
                def __mangle_good(self, text: str) -> None: ...
                def __mangle_bad(self, number: int) -> None: ...
            z
            class __Dunder__:
                def __mangle_good(self, text): pass
                def __mangle_bad(self, text): pass
            z__Dunder__.__mangle_badz
            class _Private:
                def __mangle_good(self, text: str) -> None: ...
                def __mangle_bad(self, number: int) -> None: ...
            z
            class _Private:
                def __mangle_good(self, text): pass
                def __mangle_bad(self, text): pass
            z_Private.__mangle_badrq   rr   s    r   test_name_manglingzStubtestUnit.test_name_mangling  s      

 #
 
 
 	
 	
 	
  =
 
 
 	
 	
 	
" 

 ,
 
 
 	
 	
 	
 

 *
 
 
 	
 	
 	
 	
 	
rE   c              #  Z   K   t          ddd          V  t          ddd          V  d S )Nz
            class A:
                def foo(self, x: int) -> None: ...
            class B(A):
                pass
            class C(A):
                pass
            z
            class A:
                def foo(self, x: int) -> None: ...
            class B(A):
                def foo(self, x: int) -> None: ...
            class C(A):
                def foo(self, y: int) -> None: ...
            zC.foorB   z&
            class X: ...
            zN
            class X:
                def __init__(self, x): pass
            z
X.__init__rq   rr   s    r   test_mrozStubtestUnit.test_mro  sr       #
 
 
 	
 	
 	
&  	
 	
 	
 		
 		
 		
 		
 		
rE   c              #  2   K   t          ddd           V  d S )Naz  
            from typing_extensions import Literal

            import enum
            class Color(enum.Enum):
                RED: int

            NUM: Literal[1]
            CHAR: Literal['a']
            FLAG: Literal[True]
            NON: Literal[None]
            BYT1: Literal[b'abc']
            BYT2: Literal[b'\x90']
            ENUM: Literal[Color.RED]
            a  
            import enum
            class Color(enum.Enum):
                RED = 3

            NUM = 1
            CHAR = 'a'
            NON = None
            FLAG = True
            BYT1 = b"abc"
            BYT2 = b'\x90'
            ENUM = Color.RED
            rB   rq   rr   s    r   test_good_literalzStubtestUnit.test_good_literal0  s@       ;
 
 
 	
 	
 	
 	
 	
rE   c              #  p  K   t          ddd           V  t          ddd          V  t          ddd	          V  t          d
dd          V  t          ddd          V  t          ddd          V  t          ddd          V  t          ddd          V  t          ddd          V  d S )Nz%from typing_extensions import Literalr)   zINT_FLOAT_MISMATCH: Literal[1]zINT_FLOAT_MISMATCH = 1.0INT_FLOAT_MISMATCHrB   zWRONG_INT: Literal[1]zWRONG_INT = 2	WRONG_INTzWRONG_STR: Literal['a']zWRONG_STR = 'b'	WRONG_STRz%BYTES_STR_MISMATCH: Literal[b'value']zBYTES_STR_MISMATCH = 'value'BYTES_STR_MISMATCHz$STR_BYTES_MISMATCH: Literal['value']zSTR_BYTES_MISMATCH = b'value'STR_BYTES_MISMATCHzWRONG_BYTES: Literal[b'abc']zWRONG_BYTES = b'xyz'WRONG_BYTESzWRONG_BOOL_1: Literal[True]zWRONG_BOOL_1 = FalseWRONG_BOOL_1zWRONG_BOOL_2: Literal[False]zWRONG_BOOL_2 = TrueWRONG_BOOL_2rq   rr   s    r   test_bad_literalzStubtestUnit.test_bad_literalR  sj     :BEEEEE1.&
 
 
 	
 	
 	

 /P[\\\\\\1;LT_``````82&
 
 
 	
 	
 	

 73&
 
 
 	
 	
 	

 /*
 
 
 	
 	
 	

 .* 
 
 
 	
 	
 	

 /) 
 
 
 	
 	
 	
 	
 	
rE   c              #  Z   K   t          ddd          V  t          ddd          V  d S )NzL
            b1: bool
            b2: bool
            b3: bool
            zF
            b1 = 0
            b2 = 1
            b3 = 2
            b3rB   z
            from typing_extensions import TypedDict

            class _Options(TypedDict):
                a: str
                b: int

            opt1: _Options
            opt2: _Options
            opt3: _Options
            z
            opt1 = {"a": "3.", "b": 14}
            opt2 = {"some": "stuff"}  # false negative
            opt3 = 0
            opt3rq   rr   s    r   test_special_subtypez!StubtestUnit.test_special_subtypev  sr      

 
 
 
 	
 	
 	
 

 #
 
 
 	
 	
 	
 	
 	
rE   c              #     K   t          ddd           V  t          ddd           V  t          ddd           V  d S )Nz1from typing_extensions import Protocol, TypedDictrB   z
            class X(Protocol):
                bar: int
                def foo(self, x: int, y: bytes = ...) -> str: ...
            zD
            class Y(TypedDict):
                a: int
            rq   rr   s    r   test_runtime_typing_objectsz(StubtestUnit.test_runtime_typing_objects  s      DG
 
 
 	
 	
 	

 

 
 
 
 	
 	
 	
  

 

 

 
	
 
	
 
	
 
	
 
	
rE   c              #     K   t          ddd           V  t          ddd           V  t          ddd          V  d S )Nfrom typing import NamedTuplerB   g
            class X1(NamedTuple):
                bar: int
                foo: str = ...
            zg
            class X1(NamedTuple):
                bar: int
                foo: str = 'a'
            a
            class X2(NamedTuple):
                bar: int
                foo: str
            zg
            class X2(NamedTuple):
                bar: int
                foo: str = 'a'
            
X2.__new__rq   rr   s    r   test_named_tuplezStubtestUnit.test_named_tuple  s      03
 
 
 	
 	
 	

 

 
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
 	
 	
rE   c              #     K   t          ddd           V  t          ddd           V  t          ddd          V  d S )	Nr   z"from collections import namedtuplerB   r   zO
            X1 = namedtuple('X1', ['bar', 'foo'], defaults=['a'])
            r   zO
            X2 = namedtuple('X1', ['bar', 'foo'], defaults=['a'])
            r   rq   rr   s    r   'test_named_tuple_typing_and_collectionsz4StubtestUnit.test_named_tuple_typing_and_collections  s      08
 
 
 	
 	
 	

 
 

 

 

 
	
 
	
 
	
 
 

 

 

 
	
 
	
 
	
 
	
 
	
rE   c              #     K   t          ddd           V  t          ddd           V  t          ddd          V  t          j        dk    r*t          ddd           V  t          d	d	d           V  d S d S )
Nzfrom typing import TypeVarrB   zA = TypeVar('A')zB = TypeVar('B')zB = 5r   r   zfrom typing import ParamSpeczC = ParamSpec('C')r   rr   s    r   test_type_varzStubtestUnit.test_type_var  s      -7S[_
 
 
 	
 	
 	
 *4FdSSSSSS*G3GGGGGGw&&36     
 0:NVZ[[[[[[[[ '&rE   c              #    K   t          ddd           V  t          ddd           V  t          ddd           V  t          ddd          V  t          dd	d
          V  t          ddd           V  t          ddd           V  t          ddd           V  t          ddd           V  t          ddd          V  t          ddd           V  t          ddd          V  d S )Nzclass Meta(type): ...rB   zclass A0: ...zclass A1(metaclass=Meta): ...class A2: ...zclass A2(metaclass=Meta): ...A2zclass A3(metaclass=Meta): ...class A3: ...A3zclass T1(metaclass=type): ...zclass T2: ...zclass T2(metaclass=type): ...zclass T3(metaclass=type): ...zclass T3: ...zclass _P1(type): ...zclass P2: ...zclass P2(metaclass=_P1): ...P2zU
            class I1(metaclass=Meta): ...
            class S1(I1): ...
            zh
            class I2(metaclass=Meta): ...
            class S2: ...  # missing inheritance
            zU
            class I2(metaclass=Meta): ...
            class S2(I2): ...
            S2rq   rr   s    r   test_metaclass_matchz!StubtestUnit.test_metaclass_match
  s     /9PX\]]]]]]MMMMMM03
 
 
 	
 	
 	

 1PX\]]]]]]7X\]]]]]] 03
 
 
 	
 	
 	

 1PX\]]]]]]7X\]]]]]] .8NVZ[[[[[[1OW[\\\\\\  

 

 

 
	
 
	
 
	
  

 

 

 
	
 
	
 
	
 
	
 
	
rE   c              #     K   t          ddd           V  t          ddd           V  t          ddd          V  t          ddd           V  d S )	Nzfrom abc import ABCMetarB   z class A1(metaclass=ABCMeta): ...r  z class A2(metaclass=ABCMeta): ...r  z class A3(metaclass=ABCMeta): ...r	  rq   rr   s    r   test_metaclass_abcmetaz#StubtestUnit.test_metaclass_abcmeta;  s       1;T\`aaaaaa36
 
 
 	
 	
 	
 1S[_``````:O[_````````rE   c              #  "  K   t          ddd           V  t          ddd          V  t          ddd           V  t          dd	d
          V  t          ddd           V  t          ddd           V  t          ddd           V  d S )Nz`
            from abc import abstractmethod
            from typing import overload
            from abc import abstractmethodrB   zO
            class A1:
                def some(self) -> None: ...
            zo
            class A1:
                @abstractmethod
                def some(self) -> None: ...
            zA1.somezo
            class A2:
                @abstractmethod
                def some(self) -> None: ...
            z
            class A3:
                @overload
                def some(self, other: int) -> str: ...
                @overload
                def some(self, other: str) -> int: ...
            zv
            class A3:
                @abstractmethod
                def some(self, other) -> None: ...
            zA3.somea  
            class A4:
                @overload
                @abstractmethod
                def some(self, other: int) -> str: ...
                @overload
                @abstractmethod
                def some(self, other: str) -> int: ...
            zv
            class A4:
                @abstractmethod
                def some(self, other) -> None: ...
            a  
            class A5:
                @abstractmethod
                @overload
                def some(self, other: int) -> str: ...
                @abstractmethod
                @overload
                def some(self, other: str) -> int: ...
            zv
            class A5:
                @abstractmethod
                def some(self, other) -> None: ...
            zo
            class A6:
                @abstractmethod
                def some(self) -> None: ...
            zO
            class A6:
                def some(self) -> None: ...
            rq   rr   s    r   test_abstract_methodsz"StubtestUnit.test_abstract_methodsI  sj      5
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
 

 
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
" 
 
 
 
 	
 	
 	
$ 
 
 
 
 	
 	
 	
 	
 	
rE   c              #     K   t          ddd           V  t          ddd          V  t          ddd          V  t          d	d	d           V  t          d
dd           V  d S )Nr  rB   zi
            class AP1:
                @property
                def some(self) -> int: ...
            z
            class AP1:
                @property
                @abstractmethod
                def some(self) -> int: ...
            zAP1.somezr
            class AP1_2:
                def some(self) -> int: ...  # missing `@property` decorator
            z
            class AP1_2:
                @property
                @abstractmethod
                def some(self) -> int: ...
            z
AP1_2.somez
            class AP2:
                @property
                @abstractmethod
                def some(self) -> int: ...
            z
            class AP3:
                @property
                @abstractmethod
                def some(self) -> int: ...
            zi
            class AP3:
                @property
                def some(self) -> int: ...
            rq   rr   s    r   test_abstract_propertiesz%StubtestUnit.test_abstract_properties  s      14
 
 
 	
 	
 	
 
 
 
 
 	
 	
 	
  
 
 
 	
 	
 	
  
 
 
 	
 	
 	
  
 
 
 
 	
 	
 	
 	
 	
rE   N)r   ro   )+rF   rG   rH   rl   rs   rw   rz   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r  rI   rE   r   rn   rn      s<       
 
 
 ]
$ 
 
 
 ]
* 
 
 
 ]
 %
 %
 %
 ]%
N 
 
 
 ]
@  
  
  
 ] 
D 2
 2
 2
 ]2
h >
 >
 >
 ]>
@ 
 
 
 ]
" @
 @
 @
 ]@
D 4
 4
 4
 ]4
l e
 e
 e
 ]e
N =
 =
 =
 ]=
~ | | | ]|| `
 `
 `
 ]`
D 
 
 
 ]
  
 
 
 ]
 E E E ]E 
 
 
 ]
  
 
 
 ]
B T T T ]T H H H ]H E E E ]E
    ]8 
 
 
 ]
 ~
 ~
 ~
 ]~
@ 8
 8
 8
 ]8
t 
 
 
 ]
> 
 
 
 ]
B !
 !
 !
 ]!
F  
  
  
 ] 
D 
 
 
 ]
> !
 !
 !
 ]!
F 
 
 
 ]
: \ \ \ ]\ .
 .
 .
 ].
` a a a ]a _
 _
 _
 ]_
B @
 @
 @
 ]@
 @
 @
rE   rn   sc                .    t          j        dd|           S )Nz\x1b.*?mr)   )resub)r  s    r   r4   r4     s    6+r1%%%rE   c                  f    e Zd ZddZddZddZddZddZddZdd	Z	dd
Z
ddZddZddZdS )StubtestMiscUnitr   rP   c                    t          ddg           }dt           dt           dt           d}||k    sJ t          dddg          }d	                    t                    }||k    sJ d S )
Nr|   zdef bad(num, text): passr_   error: z_.bad is inconsistent, stub argument "number" differs from runtime argument "num"
Stub: in file zG.pyi:1
def (number: builtins.int, text: builtins.str)
Runtime: in file z8.py:1
def (num, text)

Found 1 error (checked 1 module)
z	--concisezS{}.bad is inconsistent, stub argument "number" differs from runtime argument "num"
)r<   r*   rc   )rC   r;   expecteds      r   test_outputzStubtestMiscUnit.test_output  s    ?.
 
 
1& 1 1-1 1 !1	1 1 1 	 !!!!?. M
 
 
KKQ6RbKcKc 	 !!!!!!rE   c                    t          dddg          }|dk    sJ t          dddg          }|dk    sJ t          ddd	g          }|dk    sJ d S )
Nr)   z__all__ = ['f']
def f(): passz--ignore-missing-stubr_   %Success: no issues found in 1 module
zdef f(): passzdef f(__a): ...zdef f(a): passz--ignore-positional-only)r<   rC   r;   s     r   test_ignore_flagsz"StubtestMiscUnit.test_ignore_flags  s    =H_G`
 
 
 AAAAA2I`HabbbAAAAA",<GaFb
 
 
 AAAAAAArE   c                   t          j        dd          }	 |5  |                    t           d           d d d            n# 1 swxY w Y   t	          ddd|j        g          }|d	k    sJ t	          d
d
d|j        g          }|dt           dk    sJ t	          d
d
d|j        dg          }|d	k    sJ t          |j        d          5 }|                    t           d           |                    d           |                    d           d d d            n# 1 swxY w Y   t	          t          j        d	                    d                    t          j        d	                    d                    d|j        dg          }|dt           dk    sJ 	 t          j        |j                   d S # t          j        |j                   w xY w)Nzw+F)modedeletez.bad  # comment
# commentr|   zdef bad(asdf, text): passz--allowlistr_   r   r)   znote: unused allowlist entry z&.bad
Found 1 error (checked 1 module)
z--ignore-unused-allowlist)r$  z.b.*
z(unused_missing)?
z	unused.*
z
                    def good() -> None: ...
                    def bad(number: int) -> None: ...
                    def also_bad(number: int) -> None: ...
                    rU   z
                    def good(): pass
                    def bad(asdf): pass
                    def also_bad(asdf): pass
                    r^   z&note: unused allowlist entry unused.*
z
.also_bad
)r   NamedTemporaryFiler,   r*   r<   namer+   rV   rW   rX   r   unlink)rC   	allowlistr;   r:   s       r   test_allowlistzStubtestMiscUnit.test_allowlist  s   /T%HHH	8	& Q Q#3 O O OPPPQ Q Q Q Q Q Q Q Q Q Q Q Q Q Q "C3&	7  F
 EEEEE "r2y~?^___F50@ 5 5 5   
 "&	8ST  F
 EEEEE in4000 &A+333444-...%%%& & & & & & & & & & & & & & &
 "_    !    '	8NO'  F* [>N[[[     Iin%%%%%BIin%%%%sT   G AG AG ABG AD&G &D**G -D*.A8G Gc                    t          ddg           }|d                    t                    k    sJ t          ddg           }|d                    t                    k    sJ d S )N+r)   r_   z`error: not checking stubs due to failed mypy compile:
{}.pyi:1: error: invalid syntax  [syntax]
zdef f(): ...
def f(): ...zterror: not checking stubs due to mypy build errors:
{}.pyi:2: error: Name "f" already defined on line 1  [no-redef]
)r<   rc   r*   r!  s     r   test_mypy_buildz StubtestMiscUnit.test_mypy_buildZ  s    3B???0067G0H0H
 
 
 

 #?UWXXXFFLfM]F^F^
 
 
 
 
 
rE   c                   t          j                    }t          j        |          5  t	          t          dg                     d d d            n# 1 swxY w Y   t          |                                          dk    sJ d S )Nnot_a_modulezferror: not_a_module failed to find stubs
Stub:
MISSING
Runtime:
N/A

Found 1 error (checked 1 module)
r0   r1   r2   r3   r   r   r4   r5   r!  s     r   test_missing_stubsz#StubtestMiscUnit.test_missing_stubsg  s    '// 	8 	8}n%566777	8 	8 	8 	8 	8 	8 	8 	8 	8 	8 	8 	8 	8 	8 	8 !2!2331
 
 
 
 
 
s   AAAc                    t          t                    5  t          t           dd          5 }|                    d           d d d            n# 1 swxY w Y   t	          j                    }t          j        |          5  t          t          t          g                     d d d            n# 1 swxY w Y   t          |                                          }|dk    sJ 	 d d d            d S # 1 swxY w Y   d S )Nr'   r&   za = 1r   )r   r*   r+   r,   r0   r1   r2   r3   r   r   r4   r5   )rC   r:   r;   
output_strs       r   test_only_pyzStubtestMiscUnit.test_only_pyq  s    )** 	J 	J)...44 !   ! ! ! ! ! ! ! ! ! ! ! ! ! ! ![]]F+F33 > >=*:);<<===> > > > > > > > > > > > > > >*6??+<+<==J!IIIIII	J 	J 	J 	J 	J 	J 	J 	J 	J 	J 	J 	J 	J 	J 	J 	J 	J 	JsX   C3AC3A	C3A	*C3#B1%C31B5	5C38B5	9,C33C7:C7c                
   t           j                            d d          }d|v sJ d|v sJ d|v sJ d|v sJ d|vsJ d|v sJ d|v sJ d	|vsJ t           j                            d d
          }d|v sJ d|vsJ d	|v sJ d S )N)r      builtinsr   zos.pathasynciographlib	formattercontextvarszimportlib.metadatar   )mypystubtestget_typeshed_stdlib_modules)rC   stdlibs     r    test_get_typeshed_stdlib_modulesz1StubtestMiscUnit.test_get_typeshed_stdlib_modules}  s    ::4HHV####v~~~~F""""F""""''''f$$$$&&&&#61111::4IIV####&((((#v------rE   c                    dddd}t          t          j        j                            t          j        |                              dk    sJ d S )Nr   )daintbr[   rB  rO   r   r   rP   c                   d S rA   rI   )rC  rE  r[   rB  rO   s        r   r:   z*StubtestMiscUnit.test_signature.<locals>.f  s    DrE   z#def (a, b, *, c, d = ..., **kwargs))rC  rD  rE  rD  r[   rD  rB  rD  rO   r   r   rP   )r   r<  r=  	Signaturefrom_inspect_signatureinspect	signature)rC   r:   s     r   test_signaturezStubtestMiscUnit.test_signature  sp    23 	 	 	 	 	 	 '>>w?PQR?S?STTUU45 5 5 5 5 5rE   c                    d}d}dt            d}t          ||g           }|dt           dt           dk    sJ t          ||g |	          }|d
k    sJ d S )Nz	temp = 5
z*from decimal import Decimal
temp: Decimal
z[mypy]
plugins=z*/test-data/unit/plugins/decimal_to_int.py
r_   r  zB.temp variable differs from runtime type Literal[5]
Stub: in file zE.pyi:2
_decimal.Decimal
Runtime:
5

Found 1 error (checked 1 module)
)r   r    r!   r#   r   )r	   r<   r*   )rC   r    r   r#   r;   s        r   test_config_filez!StubtestMiscUnit.test_config_file  s    =^^^^4"EEE1& 1 1-1 1 1
 
 
 

 4"R]^^^AAAAAAArE   c                
   t          j                    }t          j        |          5  t	          t          g                      d d d            n# 1 swxY w Y   t          |                                          dk    sJ d S )Nzerror: no modules to check
r0  r!  s     r   test_no_modulesz StubtestMiscUnit.test_no_modules  s    '// 	* 	*}R(()))	* 	* 	* 	* 	* 	* 	* 	* 	* 	* 	* 	* 	* 	* 	* !2!2337UUUUUUUs   AAAc                   t          j                    }t          j        |          5  t	          t          ddg                     d d d            n# 1 swxY w Y   t          |                                          dk    sJ d S )Nz--check-typeshedsome_modulez?error: cannot pass both --check-typeshed and a list of modules
r0  r!  s     r   test_module_and_typeshedz)StubtestMiscUnit.test_module_and_typeshed  s    '// 	K 	K}&8-%HIIJJJ	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K 	K !2!233N
 
 
 
 
 
s   AAAN)r   rP   )rF   rG   rH   r  r"  r*  r-  r1  r4  r@  rK  rM  rO  rR  rI   rE   r   r  r    s       " " " "6B B B B;& ;& ;& ;&z
 
 
 

 
 
 

J 
J 
J 
J. . . . 
 
 
 
B B B BV V V V
 
 
 
 
 
rE   r  )r
   r   r   r   rA   )
r   r   r    r   r!   r"   r#   r$   r   r   )rJ   rK   r   rL   )r  r   r   r   )"
__future__r   r2   rI  r0   r   r  r   r   rV   unittesttypingr   r   r   mypy.stubtestr<  r   r   mypy.test.datar	   contextmanagerr   r*   r.   r-   r/   r<   r>   rl   TestCasern   r4   r  rI   rE   r   <module>rZ     s   " " " " " "      				 				 				 



    * * * * * * * * * *     3 3 3 3 3 3 3 3 # # # # # #    " ! " H! F F LP
 
 
 
 
8       ! ! ! !HT
 T
 T
 T
 T
8$ T
 T
 T
n8& & & &|
 |
 |
 |
 |
x( |
 |
 |
 |
 |
rE   