pPjaddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z ddlmZddlmZddlmZddlZddlmZmZddlmZdd lmZdd lmZmZdd lmZdd l m!Z!ejDdd Z#dZ$dZ%dZ&dZ'ddZ( d d dZ) d! d"dZ*GddZ+d#dZ,Gdde jZZ.d$dZ/Gdde jZZ0y)%) annotationsN)CallableIterator)Path)Any)raises)buildnodes) BuildSource)Options) parse_options test_stubs) test_temp_dir)root_dirc#Ktj}tjj }t j 5} tj|tjd|k7r tjjd|||j t_|tjvrtj|=tj| dddy#|j t_|tjvrtj|=tj|wxYw#1swYyxYwwNr) osgetcwdsyspathcopytempfileTemporaryDirectorychdirinsertmodules)mod_namecurrentcurrent_syspathtmps [/home/oem/CyberBrain26-unified/.venv/lib/python3.12/site-packages/mypy/test/teststubtest.py use_tmp_dirr"siikGhhmmoO  $ $ & #  HHSMxx{c!3'I&++-CH3;;&KK) HHW   '++-CH3;;&KK) HHW   s9AE E  AC5AE , E5AEE  EE test_modulea Any = object() class _SpecialForm: def __getitem__(self, typeargs: Any) -> object: ... Callable: _SpecialForm = ... Generic: _SpecialForm = ... Protocol: _SpecialForm = ... Union: _SpecialForm = ... ClassVar: _SpecialForm = ... Final = 0 Literal = 0 NewType = 0 TypedDict = 0 Unpack = 0 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 MutableMapping(Mapping[_K, _V]): ... class Match(Generic[AnyStr]): ... class Sequence(Iterable[_T_co]): ... class Tuple(Sequence[_T_co]): ... class NamedTuple(tuple[Any, ...]): ... class _TypedDict(Mapping[str, object]): __required_keys__: ClassVar[frozenset[str]] __optional_keys__: ClassVar[frozenset[str]] __total__: ClassVar[bool] __readonly_keys__: ClassVar[frozenset[str]] __mutable_keys__: ClassVar[frozenset[str]] __closed__: ClassVar[bool | None] __extra_items__: ClassVar[Any] def overload(func: _T) -> _T: ... def type_check_only(func: _T) -> _T: ... def final(func: _T) -> _T: ... aI import types 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 frozenset(Generic[T]): ... class function: pass class sentinel: __name__: str __module__: str def __new__(cls, name: str, /, *, repr: str | None = None) -> sentinel: ... 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__ c tjtddtj|gt t S)Nzmain.pyi)sourcesoptions alt_lib_path)r r textwrapdedentr r)sources r! build_helperr+s3 ;;Zxv/FGH " c Btt5}tdd5}|jtdddtdd5}|jt dddtdd5}|jt dddttdd5}|j|dddttdd5}|j|ddd|r;ttdd5}|j|ddd|dtdgz}|tjn|}|tjn|}tj|5tj|5tttg|zd dddddddddt|jj!t"j$j't"j(zd j!|t"j(zd }t|jj!t"j$j'|t"j(zd j!|t"j(zd } || fS#1swY{xYw#1swY^xYw#1swYAxYw#1swY!xYw#1swYxYw#1swYxYw#1swY\xYw#1swYaxYw#1swYfxYw) N builtins.pyiw typing.pyienum.pyiz.pyi.pyz _config.iniz--mypy-config-fileTuse_builtins_fixtures)r"TEST_MODULE_NAMEopenwritestubtest_builtins_stubstubtest_typing_stubstubtest_enum_stubioStringIO contextlibredirect_stdoutredirect_stderrrr remove_color_codegetvaluereplacerrrealpathsep) stubruntimer& config_fileoutputouterrtmp_dirffiltered_outputfiltered_outerrs r!run_stubtest_with_stderrrOs % &`' .# & ,! GG* + , , $ * GG( ) * *c " (a GG& ' ( %&d+S 1 Q GGDM  %&c*C 0 A GGG   )*+6< % $ %!5:J9K;7W XXG"(.f"(.f  ' ' / `1K1KF1S ` }&6%7'%ABZ^ _ ` `#`&( !!'*RVV3R 8266AQSU9VO ( !!'*RVV3R 8266AQSU9VO O ++9 , , * * ( (     % %  ` ` ` `#``s LJ,LJ9L1KL"K4LK !L>K-AL+LK: L(L,J6 1L9K >LK LK L K* %L-K7 2L:L ?LL LLc$t||||dSr)rOrFrGr&rHs r! run_stubtestrRs $D'7K H KKr,ceZdZddZy)Casec.||_||_||_yNrFrGerror)selfrFrGrXs r!__init__z Case.__init__s   r,N)rFstrrGr[rX str | NonereturnNone)__name__ __module__ __qualname__rZr,r!rTrTsr,rTcdfd }|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. crt|i|}t}|D]u}|j|j}|dk(rt}n#|j tds td|}||vsJdj ||j |wtdjd|Ddjd|Dddg }t|j}||k7rGtdjd |Ddjd |Dg }||k(sJ|yy) Nr5.z_collect_cases merges cases into a single stubtest invocation; we already expect an error for {}z c3xK|]2}tj|jjd4yw Nr(r)rFlstrip.0cs r! z.collect_cases..test..s&QaX__QVV]]4-@AQ8:c3xK|]2}tj|jjd4ywrgr(r)rGrjrks r!rnz.collect_cases..test.. s(WA 0@0@0F GWro--generate-allowlistz--strict-type-check-onlyrFrGr&c3xK|]2}tj|jjd4ywrgrirks r!rnz.collect_cases..test..s& U!t1D!E Uroc3xK|]2}tj|jjd4ywrgrqrks r!rnz.collect_cases..test..s)#[PQHOOAII4D4DT4J$K#[ro) listsetrXr6 startswithformataddrRjoin splitlines) argskwargscasesexpected_errorsrmexpected_errorrI actual_errorsfns r!testzcollect_cases..testsOR(()% 0AwwWWN#!1#..2B1C1/EF$4#5Q~6F!G!8 ))/)? 8    / 0Q5QQKKWQVWW+-GH  F--/0 O +![[ Uu UU #[UZ#[[F !O3 ;V ;3 ,r,)r}rr~rr]r^rb)rrs` r! collect_casesrs<> Kr,ceZdZed7dZed7dZed7dZed7dZed7dZed7dZ ed7dZ ed7dZ ed7d Z ed7d Z ed7d Zed7d Zed7d Zed7dZed7dZed7dZed7dZed7dZed7dZed7dZed7dZed7dZed7dZed7dZed7dZed7dZed7dZed7dZed7dZ ed7dZ!ed7dZ"ed7d Z#ed7d!Z$ed7d"Z%ed7d#Z&ed7d$Z'ed7d%Z(ed7d&Z)ed7d'Z*ed7d(Z+ed7d)Z,ed7d*Z-ed7d+Z.ed7d,Z/ed7d-Z0ed7d.Z1ed7d/Z2ed7d0Z3ed7d1Z4ed7d2Z5ed7d3Z6ed7d4Z7ed7d5Z8y6)8 StubtestUnitc#LKtdddtdddyw)Nz*def f(number: int, text: str) -> None: ...zdef f(number, text): passrWzc class X: def f(self, number: int, text: str) -> None: ... zR class X: def f(self, number, text): pass rTrYs r!test_basic_goodzStubtestUnit.test_basic_goods:=/    "$c#lKtdddtdddtdd d yw) Nz!def mistyped_class() -> None: ...zclass mistyped_class: passmistyped_classrWzclass mistyped_fn: ...zdef mistyped_fn(): pass mistyped_fnzU class X: def mistyped_var(self) -> int: ... zC class X: mistyped_var = 1 zX.mistyped_varrrs r! test_typeszStubtestUnit.test_types-sR40"  )3LTa  #  24c#,Ktdddyw)Nz from typing import type_check_only class UFunc: ... @type_check_only class _BinaryUFunc(UFunc): ... equal: _BinaryUFunc zX class UFunc: pass equal = UFunc() rWrrs r!+test_transparent_type_check_only_subclassesz8StubtestUnit.test_transparent_type_check_only_subclassesCs$  #  c#Ktdddtdddtdddtd d dyw) Nzdef bar() -> int: ...zasync def bar(): return 5barrWzasync def foo() -> int: ...zdef foo(): return 5zdef baz() -> int: ...zdef baz(): return 5zasync def bingo() -> int: ...zasync def bingo(): return 5rrs r!test_coroutineszStubtestUnit.test_coroutinesZsR/9T\abb5?T\`aa/9NVZ[[0:W_c  AAc# Ktdddtdddtddd td d d td ddtdddtdddtdddyw)N,def bad(number: int, text: str) -> None: ...z def bad(num, text) -> None: passbadrW7def 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 z&def dunder_name(__x: int) -> None: ...z1def dunder_name_posonly(__x: int, /) -> None: ...z.def dunder_name_posonly(__x: int) -> None: ...z(def dunder_name_bad(x: int) -> None: ...z*def dunder_name_bad(__x: int) -> None: ...dunder_name_badrrs r! test_arg_namezStubtestUnit.test_arg_nameds?6  J:  I:       =@  HH  ?D#  BBc#Ktdddtdddtdd d td d dtd ddtdddyw)Nz7def runtime_kwonly(number: int, text: str) -> None: ...z)def runtime_kwonly(number, *, text): passruntime_kwonlyrWz7def 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_posonlyrz'def good_posonly(number, /, text): passz8def runtime_posonly(number: int, text: str) -> None: ...z*def runtime_posonly(number, /, text): passruntime_posonlyz None: ...z(def stub_posonly_570(number, text): passstub_posonly_570rrs r! test_arg_kindzStubtestUnit.test_arg_kindsJ?"  J9  J:   J=  K@#  O>$  A"A$c#Ktdddtdddtdddtdd d td d d tdddtdddtdddtdddtdddtdddtd d!d"yw)#Nz'def priv_pos_arg_missing() -> None: ...z(def priv_pos_arg_missing(_p1=None): passrWz"def multi_priv_args() -> None: ...z'def multi_priv_args(_p='', _q=''): passz%def priv_kwarg_missing() -> None: ...z'def priv_kwarg_missing(*, _p2=''): passz2def priv_pos_arg_wrong(_p: int = ...) -> None: ...z%def priv_pos_arg_wrong(_p=None): passpriv_pos_arg_wrongz3def priv_kwarg_wrong(*, _p: int = ...) -> None: ...z&def priv_kwarg_wrong(*, _p=None): passpriv_kwarg_wrongz%def pos_arg_no_default() -> None: ...z!def pos_arg_no_default(_np): passpos_arg_no_defaultz#def kwarg_no_default() -> None: ...z"def kwarg_no_default(*, _np): passkwarg_no_defaultz,def double_underscore_pos_arg() -> None: ...z0def double_underscore_pos_arg(__np = None): passdouble_underscore_pos_argz*def double_underscore_kwarg() -> None: ...z1def double_underscore_kwarg(*, __np = None): passdouble_underscore_kwargz+def priv_arg_is_kwonly(_p=...) -> None: ...z&def priv_arg_is_kwonly(*, _p=''): passpriv_arg_is_kwonlyz2def priv_arg_is_positional(*, _p=...) -> None: ...z'def priv_arg_is_positional(_p=''): passpriv_arg_is_positionalz.def priv_args_not_at_end(*, q='') -> None: ...z+def priv_args_not_at_end(_p='', q=''): passpriv_args_not_at_endrrs r!test_private_parametersz$StubtestUnit.test_private_parameterss&:>  5=  8=  E;&  F<$  87&  68$  ?F-  =G+  ><&  E=*  AA(  CCc#Ktdddtdddtddd td d d td ddtdddyw)Nz$def f1(text: str = ...) -> None: ...zdef f1(text = 'asdf'): passrWz$def f2(text: str = ...) -> None: ...zdef f2(text): passf2zdef f3(text: str) -> None: ...zdef f3(text = 'asdf'): passf3z$def f4(text: str = ...) -> None: ...zdef f4(text = None): passf4z&def f5(data: bytes = ...) -> None: ...zdef f5(data = 'asdf'): passf5z from typing import TypeVar _T = TypeVar("_T", bound=str) def f6(text: _T = ...) -> None: ... zdef f6(text = None): passf6rrs r!test_default_presencez"StubtestUnit.test_default_presences71  7AU]a  11  7/  91   0  rc#Ktdddtdddtddd td d d td ddtdddtdddtdddtdddtdddtdddtdd d!yw)"Nz$def f1(text: str = 'x') -> None: ...zdef f1(text = 'y'): passf1rWz(def f2(text: bytes = b"x'") -> None: ...zdef f2(text = b"x'"): passz(def f3(text: bytes = b"y'") -> None: ...zdef f3(text = b"x'"): passrz%def f4(text: object = 1) -> None: ...zdef f4(text = 1.0): passrz(def f5(text: object = True) -> None: ...zdef f5(text = 1): passrz(def f6(text: object = True) -> None: ...zdef f6(text = True): passz,def f7(text: object = not True) -> None: ...zdef f7(text = False): passz,def f8(text: object = not True) -> None: ...zdef f8(text = True): passf8z*def f9(text: object = {1: 2}) -> None: ...zdef f9(text = {1: 3}): passf9z+def f10(text: object = [1, 2]) -> None: ...zdef f10(text = [1, 2]): passzdef f11() -> None: ...zz def f11(text=None) -> None: pass f11.__text_signature__ = "(text=)" f11zdef f12(x=1): ...z class _ndarray: def __eq__(self, obj): return self def __bool__(self): raise ValueError def f12(x=_ndarray()) -> None: pass f12rrs r!test_default_valuezStubtestUnit.test_default_value's,7.  <1  <1  8.  ;,  ;/  ?0  ?/  =1  >2  )   $   rc#Ktdddtdddtddd td d d td ddyw)Nz class Good: @classmethod def f(cls, number: int, text: str) -> None: ... zq class Good: @classmethod def f(cls, number, text): pass rWze class Bad1: def f(cls, number: int, text: str) -> None: ... zq class Bad1: @classmethod def f(cls, number, text): pass zBad1.fz class Bad2: @classmethod def f(cls, number: int, text: str) -> None: ... zs class Bad2: @staticmethod def f(self, number, text): pass zBad2.fz class Bad3: @staticmethod def f(cls, number: int, text: str) -> None: ... zr class Bad3: @classmethod def f(self, number, text): pass zBad3.fz_ class GoodNew: def __new__(cls, *args, **kwargs): ... z` class GoodNew: def __new__(cls, *args, **kwargs): pass rrs r!test_static_class_methodz%StubtestUnit.test_static_class_methodrs                 AAc#Ktdddtdddtddd td d d td ddyw)Nzdef f1(a, *, b, c) -> None: ...zdef f1(a, *, b, c): passrWzdef f2(a, *, b) -> None: ...zdef f2(a, *, b, c): passrzdef f3(a, *, b, c) -> None: ...zdef f3(a, *, b): passrzdef f4(a, *, b, c) -> None: ...zdef f4(a, b, *, c): passrzdef f5(a, b, *, c) -> None: ...zdef f5(a, *, b, c): passrrrs r!test_arg_mismatchzStubtestUnit.test_arg_mismatchs|2 None: ...zdef f1(*args, **kwargs): passrWz$def f2(*args, **kwargs) -> None: ...zdef f2(**kwargs): passrzdef g1(a, b, c, d) -> None: ...zdef g1(a, *args): passz&def g2(a, b, c, d, *args) -> None: ...zdef g2(a): passg2z&def g3(a, b, c, d, *args) -> None: ...zdef g3(a, *args): passzdef h1(a) -> None: ...zdef h1(a, b, c, d, *args): passh1zdef h2(a, *args) -> None: ...zdef h2(a, b, c, d): passh2zdef h3(a, *args) -> None: ...zdef h3(a, b, c, d, *args): passh3z"def j1(a: int, *args) -> None: ...zdef j1(a): passj1zdef j2(a: int) -> None: ...zdef j2(a, *args): passj2zdef j3(a, b, c) -> None: ...zdef j3(a, *args, c): passj3z def k1(a, **kwargs) -> None: ...zdef k1(a): passk1zdef k2(a) -> None: ...zdef k2(a, **kwargs): passzdef k3(a, b) -> None: ...zdef k3(a, **kwargs): passk3zdef k4(a, *, b) -> None: ...zdef k4(a, **kwargs): passzdef k5(a, *, b) -> None: ...z"def k5(a, *, b, c, **kwargs): passk5z&def k6(a, *, b, **kwargs) -> None: ...z"def k6(a, *, b, c, **kwargs): passk6rrs r!test_varargs_varkwargsz#StubtestUnit.test_varargs_varkwargss73  7,  2 None: ... zdef f1(*, a, b): passrWz,def f2(**kwargs: Unpack[_Args]) -> None: ...zdef f2(*, a, c): passrz @type_check_only class _OptionalArgs(TypedDict, total=False): a: int def f3(**kwargs: Unpack[_OptionalArgs]) -> None: ... def f4(**kwargs: Unpack[_OptionalArgs]) -> None: ... zM def f3(*, a): pass def f4(*, a=0): pass rrrs r!test_kwargs_unpack_typeddictz)StubtestUnit.test_kwargs_unpack_typeddictsV ,  ?+    rc#lKtdddtdddtddd td d dtd d dtdddtdddtdddtdddtdddtdddyw)Nz from typing import overload @overload def f1(a: int, *, c: int = ...) -> int: ... @overload def f1(a: int, b: int, c: int = ...) -> str: ... zdef f1(a, b = 0, c = 0): passrWz @overload def f2(a: int, *, c: int = ...) -> int: ... @overload def f2(a: int, b: int, c: int = ...) -> str: ... zdef f2(a, b, c = 0): passrz @overload def f3(a: int) -> int: ... @overload def f3(a: int, b: str) -> str: ... zdef f3(a, b = None): passrz @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: ... zdef f5(x, /): passaS from typing import final from typing_extensions import deprecated class Foo: @overload @final def f6(self, __a: int) -> int: ... @overload @deprecated("evil") def f6(self, __b: str) -> str: ... zM class Foo: def f6(self, x, /): pass z @overload def f7(a: int, /) -> int: ... @overload def f7(b: str, /) -> str: ... zdef f7(x, /): passz @overload def f8(a: int, c: int = 0, /) -> int: ... @overload def f8(b: str, d: int, /) -> str: ... zdef f8(x, y, /): passrz @overload def f9(a: int, c: int = 0, /) -> int: ... @overload def f9(b: str, d: int, /) -> str: ... zdef f9(x, y=0, /): passaR class Bar: @overload def f1(self) -> int: ... @overload def f1(self, a: int, /) -> int: ... @overload def f2(self, a: int, /) -> int: ... @overload def f2(self, a: str, /) -> int: ... z~ class Bar: def f1(self, *a) -> int: ... def f2(self, *a) -> int: ... z @overload def f(a: int) -> int: ... @overload def f(a: int, b: str, /) -> str: ... z. def f(a, *args): ... rrs r! test_overloadzStubtestUnit.test_overload-s>4   0   0   :   )   !  $ )   ,   .    %  (   B2B4c#lKtdddtdddtdddyw) Na from typing import overload, type_check_only @type_check_only class _dec1: def __init__(self, func: object) -> None: ... def __call__(self, x: str) -> str: ... @overload def good1(x: int) -> int: ... @overload @_dec1 def good1(unrelated: int, whatever: str) -> str: ... zdef good1(x): ...rWak @type_check_only class _dec2: def __init__(self, func: object) -> None: ... def __call__(self, x: str, y: int) -> str: ... @overload def good2(x: int) -> str: ... @overload @_dec2 def good2(unrelated: int, whatever: str) -> str: ... zdef good2(x, y=...): ...ag @type_check_only class _dec3: def __init__(self, func: object) -> None: ... def __call__(self, x: str, y: int) -> str: ... @overload def bad(x: int) -> str: ... @overload @_dec3 def bad(unrelated: int, whatever: str) -> str: ... zdef bad(x): ...rrrs r!test_decorated_overloadz$StubtestUnit.test_decorated_overloadsX (!  $ /   &  rc# Ktdddtdddtdddtd d d td d dtdddtdddtdddyw)Nz class Good: @property def read_only_attr(self) -> int: ... read_only_attr_alias = read_only_attr z class Good: @property def read_only_attr(self): return 1 read_only_attr_alias = read_only_attr rWzf class Bad: @property def f(self) -> int: ... Q class Bad: def f(self) -> int: return 1 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_attra class Z: @property def read_write_attr(self) -> int: ... @read_write_attr.setter def read_write_attr(self, val: int) -> None: ... read_write_attr_alias = read_write_attr a class Z: @property def read_write_attr(self): return self._val @read_write_attr.setter def read_write_attr(self, val): self._val = val read_write_attr_alias = read_write_attr 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() z class spam: @property def eggs(self) -> int: ... @eggs.deleter def eggs(self) -> None: ... z class spam: @property def eggs(self): return 42 @eggs.deleter def eggs(self): print("eggs") rrs r! test_propertyzStubtestUnit.test_propertys           "   %  #  & %  (#  rc#Ktdddtdddtdddtd d d td d dtdddyw)Na from functools import cached_property class Good: @cached_property def read_only_attr(self) -> int: ... @cached_property def read_only_attr2(self) -> int: ... a& import functools as ft from functools import cached_property class Good: @cached_property def read_only_attr(self): return 1 @ft.cached_property def read_only_attr2(self): return 1 rWz from functools import cached_property class Bad: @cached_property def f(self) -> int: ... rrz from functools import cached_property class GoodCachedAttr: @cached_property def f(self) -> int: ... zE class GoodCachedAttr: f = 1 z from functools import cached_property class BadCachedAttr: @cached_property def f(self) -> str: ... zD class BadCachedAttr: f = 1 zBadCachedAttr.fz from functools import cached_property from typing import final class FinalGood: @cached_property @final def attr(self) -> int: ... z from functools import cached_property from typing import final class FinalGood: @cached_property @final def attr(self): return 1 z from functools import cached_property class FinalBad: @cached_property def attr(self) -> int: ... a from functools import cached_property from typing_extensions import final class FinalBad: @cached_property @final def attr(self): return 1 z FinalBad.attrrrs r!test_cached_propertyz!StubtestUnit.test_cached_propertyhs%  (       $  %  ( "!  rc#Ktdddtdddtdddtd d dtd d d tdddtdddtdddtdddtdddtdddtdddyw) Nzx1: intzx1 = 5rWzx2: strzx2 = 5x2zfrom typing import Tupler5z- x3: Tuple[int, int] z x3 = (1, 3)z- x4: Tuple[int, int] zx4 = (1, 3, 5)x4zx5: intzdef x5(a, b): passx5z-def foo(a: int, b: int) -> None: ... x6 = fooz&def foo(a, b): pass def x6(c, d): passx6z9 class X: f: int zj class X: def __init__(self): self.f = "asdf" zF class Y: read_only_attr: int rrzG class Z: read_write_attr: int z class Z: @property def read_write_attr(self): return self._val @read_write_attr.setter def read_write_attr(self, val): self._val = val zQ from typing import Final X_FINAL: Final = 2 z X_FINAL = 1X_FINALzT from typing import Final X_FINAL_OK: Final = 1 zX_FINAL_OK = 1rrs r!test_varzStubtestUnit.test_vars$ 84@@ 84@@-r488"   %    +?tLLA=      %    "   %   sCCc#,Ktdddtdddtddd td d d td d dtdddtdddtdddtdddtdddtdddtdd dtd!d"dtd#d#dtd$d%dtd&d'dtd(d)dyw)*Nz import collections.abc import re import typing from typing import Callable, Dict, Generic, Iterable, List, Match, Tuple, TypeVar, Union, type_check_only z import collections.abc import re from typing import Callable, Dict, Generic, Iterable, List, Match, Tuple, TypeVar, Union rWz] class X: def f(self) -> None: ... Y = X zd class X: def f(self) -> None: ... class Y: ... zY.fzA = Tuple[int, str]zA = (int, str)AzB = strr5Bz_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") @type_check_only 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.foozStrList = list[str]zStrList = ['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 zM = 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] rrs r!test_type_aliaszStubtestUnit.test_type_aliass        -7GsSS 2S99 Bd;;                -7QYbcc          (2B$OO          ;  rc#lKtdddtdddtdddtdd d td d dtd ddtdddtdddtdddtdddtdddyw)Nz import enumrWz{ class X(enum.Enum): a = ... b = "asdf" c = "oops" zt class X(enum.Enum): a = 1 b = "asdf" c = 2 zX.cz class Flags1(enum.Flag): a = ... b = 2 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 = ... b = 2 def bar(x: Flags2 | None = None) -> None: ... z class Flags2(enum.Flag): a = 1 b = 2 def bar(x=Flags2.a|Flags2.b): pass rz class Flags3(enum.Flag): a = ... b = 2 def baz(x: Flags3 | None = ...) -> None: ... z class Flags3(enum.Flag): a = 1 b = 2 def baz(x=Flags3(0)): pass z import enum class SomeObject: ... class WeirdEnum(enum.Enum): a = SomeObject() b = SomeObject() z import enum class SomeObject: ... class WeirdEnum(enum.Enum): _value_: SomeObject a = ... b = ... rGrFrXz class Flags4(enum.Flag): a = 1 b = 2 def spam(x: Flags4 | None = None) -> None: ... z class Flags4(enum.Flag): a = 1 b = 2 def spam(x=Flags4(0)): pass spama import sys from typing import Final, Literal class BytesEnum(bytes, enum.Enum): a = b'foo' 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 a class HasSlotsAndNothingElse: __slots__ = ("x",) x: int class HasInheritedSlots(HasSlotsAndNothingElse): pass class HasEmptySlots: __slots__ = () zu class HasCompatibleValue(enum.Enum): _value_: str FOO = ... zZ class HasCompatibleValue(enum.Enum): FOO = "foo" zw class HasIncompatibleValue(enum.Enum): _value_: int FOO = ... z\ class HasIncompatibleValue(enum.Enum): FOO = "foo" zHasIncompatibleValue.FOOrrs r! test_enumzStubtestUnit.test_enums? }DII                #  &     )  ,  /  2    -  rc#,Ktdddyw)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 rWrrs r!test_decoratorzStubtestUnit.test_decorators"    rc#LKtdddtdddyw)Nz class LazyObject: def __init__(self, func: object) -> None: ... def __bool__(self) -> bool: ... a class LazyObject: def __init__(self, func): self.__dict__["_wrapped"] = None self.__dict__["_setupfunc"] = func def _setup(self): self.__dict__["_wrapped"] = self._setupfunc() @property def __class__(self): if self._wrapped is None: self._setup() return type(self._wrapped) def __bool__(self): if self._wrapped is None: self._setup() return bool(self._wrapped) z test_module.LazyObject.__class__rWz[ def default_value() -> bool: ... DEFAULT_VALUE: bool z def default_value(): return True DEFAULT_VALUE = LazyObject(default_value) bool(DEFAULT_VALUE) # evaluate the lazy object ztest_module.DEFAULT_VALUErrs r!test_proxy_objectzStubtestUnit.test_proxy_objects@ "5/  2 .  rc#,Ktdddyw)NzZ: intz+ __all__ = [] Z = 5__all__rWrrs r!test_all_at_runtime_not_stubz)StubtestUnit.test_all_at_runtime_not_stubs    rc#,Ktdddyw)Nz __all__ = ()r5rrWrrs r!test_all_in_stub_not_at_runtimez,StubtestUnit.test_all_in_stub_not_at_runtimes)DDrc#,Ktdddyw)Nz@ __all__ = ['foo'] foo: str z> __all__ = [] foo = 'foo' rrWrrs r!,test_all_in_stub_different_to_all_at_runtimez9StubtestUnit.test_all_in_stub_different_to_all_at_runtimes$   rc# Ktdddtdddtdddtd dd td dd tdd dtdddtdddtdddtdddtdddtdddtdddtd d!d"td#ddtd$ddyw)%Nzx = 5r5xrW def f(): ...rLz class X: ...Xz class _X: ..._Xz from typing import overload @overload def h(x: int): ... @overload def h(x: str): ... hz __all__ = []rz__all__ += ['y'] y = 5yz__all__ += ['g'] def g(): passgz5from mystery import A, B as B, C as D # type: ignorerz class Y: ...zF__all__ += ['Y'] class Y: def __or__(self, other): return self|otherzY.__or__z class Z: ...z=__all__ += ['Z'] class Z: def __reduce__(self): return (Z,)zl class ClassWithMetaclassOverride: def __call__(*args, **kwds): ... z%class ClassWithMetaclassOverride: ...z#ClassWithMetaclassOverride.__call__z from typing import Any class FakeSetattrClass: def __setattr__(self, name: str, value: Any, /) -> None: ... zclass FakeSetattrClass: ...zFakeSetattrClass.__setattr__zr class FakeDelattrClass: def __delattr__(self, name: str, /) -> None: ... zclass FakeDelattrClass: ...zFakeDelattrClass.__delattr__zfrom typing import NewTypez_Int = NewType('_Int', int)rrs r! test_missingzStubtestUnit.test_missingsI377#>>#>>4@@  N)DD$=SII$ESQQHRT\_  ^  U  <7    20  20   4bMM5rNNsDDc#Ktdddtdddtdddtddd tdd dtdd dyw) Nr5z import sysrW def g(): ...r z CONSTANT = 0CONSTANTz'import re; constant = re.compile('foo')constantz"from json.scanner import NUMBER_REz from string import ascii_lettersrrs r!test_missing_no_runtime_allz(StubtestUnit.test_missing_no_runtime_all seL==N#>>N*EE$MU_``$HPTUU$FdSSrc#,Ktdddyw)Nr5z import sys import types import __future__ _m = types.SimpleNamespace() _m.annotations = __future__.annotations sys.modules["_terrible_stubtest_test_module"] = _m from _terrible_stubtest_test_module import * assert annotations rWrrs r!$test_missing_no_runtime_all_terriblez1StubtestUnit.test_missing_no_runtime_all_terrible)s    rc#ZKtddtdtdddyw)Nz__all__: list[str]r5z.__all__rWz_f: intz def _f(): ..._f)rTr6rs r!test_non_public_1zStubtestUnit.test_non_public_1;s4%rOW[\\.DD.DDrc#Ktdddtdddtdd dtd d dtd d dtdddyw)Nz:class A: def __init__(self, a: int, b: int) -> None: ...z*class A: def __init__(self, a, bx): passz A.__init__rWz: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): passz>class D: def __class_getitem__(cls, type: type) -> type: ...z0class D: def __class_getitem__(cls, type): ...z=class E: def __getitem__(self, item: object) -> object: ...z@class E: def __getitem__(self, item: object, /) -> object: ...z E.__getitem__z@class F: def __getitem__(self, item: object, /) -> object: ...z=class F: def __getitem__(self, item: object) -> object: ...rrs r! test_dunderszStubtestUnit.test_dundersHsNA  NA  % R  RG  QW!  TT  rc# Ktdddtdddtdd d td d d tdddtdddtdddtdddyw)a Dunders present at runtime but missing in the stub are usually ignored if the runtime dunder is an instance of `WrapperDescriptorType` -- these are often not actually callable at runtime. However, in certain specific situations we still report a diagnostic when the stub is missing a dunder that is present as a `WrapperDescriptorType` at runtime. zh class Forward: def __add__(self, other: object) -> object: ... z class Forward: def __add__(self, other): pass __radd__ = int.__radd__ zForward.__radd__rWzk class Reflected: def __radd__(self, other: object) -> object: ... z class Reflected: def __radd__(self, other): pass __add__ = int.__add__ zReflected.__add__zf class Ordering: def __lt__(self, other: object) -> bool: ... z{ class Ordering: def __lt__(self, other): pass __gt__ = int.__gt__ zOrdering.__gt__zb class ContextManager: def __enter__(self) -> object: ... z class ContextManager: def __enter__(self): pass __exit__ = int.__add__ zContextManager.__exit__z class LessThanOrEqual: def __lt__(self, other: object) -> bool: ... def __eq__(self, other: object) -> bool: ... z class LessThanOrEqual: def __lt__(self, other): pass def __eq__(self, other): pass __le__ = int.__le__ zLessThanOrEqual.__le__zh from typing import Mapping class MappingOr(Mapping[str, int]): ... zO class MappingOr: __or__ = dict.__or__ zMappingOr.__or__z~ from typing import MutableMapping class MutableMappingIor(MutableMapping[str, int]): ... zY class MutableMappingIor: __ior__ = dict.__ior__ zMutableMappingIor.__ior__zh from typing import Sequence class SequenceRmul(Sequence[int]): ... zV class SequenceRmul: __rmul__ = list.__rmul__ zSequenceRmul.__rmul__Nrrs r! test_missing_wrapper_descriptorsz-StubtestUnit.test_missing_wrapper_descriptorsns %   &   $   ,    +  %  .  *  rc#LKtdddtdddyw)Nzclass CanBeSubclassed: ...rWzCclass CannotBeSubclassed: def __init_subclass__(cls) -> None: ...zGclass CannotBeSubclassed: def __init_subclass__(cls): raise TypeErrorCannotBeSubclassedrrs r!test_not_subclassablez"StubtestUnit.test_not_subclassables4-7S[_  W^&  rc#Ktdddtdddtdddtd d dtd d d tdddtdddyw)Nz' class A: pass rWz{ from typing_extensions import disjoint_base @disjoint_base class B: pass z' class B: pass z test_module.Ba from typing_extensions import Self class mytakewhile: def __new__(cls, predicate: object, iterable: object, /) -> Self: ... def __iter__(self) -> Self: ... def __next__(self) -> object: ... zH from itertools import takewhile as mytakewhile ztest_module.mytakewhileaE from typing_extensions import disjoint_base, Self @disjoint_base class mycorrecttakewhile: def __new__(cls, predicate: object, iterable: object, /) -> Self: ... def __iter__(self) -> Self: ... def __next__(self) -> object: ... zO from itertools import takewhile as mycorrecttakewhile zz class IsDisjointBaseBecauseItHasSlots: __slots__ = ("a",) a: int z from typing_extensions import disjoint_base @disjoint_base class IsDisjointBaseBecauseItHasSlots: a: int z+test_module.IsDisjointBaseBecauseItHasSlotsrzE class IsFinalSoDisjointBaseIsRedundant: ... z from typing_extensions import disjoint_base, final @final @disjoint_base class IsFinalSoDisjointBaseIsRedundant: ... z,test_module.IsFinalSoDisjointBaseIsRedundantz import enum class IsEnumWithMembersSoDisjointBaseIsRedundant(enum.Enum): A = 1 B = 2 z from typing_extensions import disjoint_base import enum @disjoint_base class IsEnumWithMembersSoDisjointBaseIsRedundant(enum.Enum): A = 1 B = 2 z6test_module.IsEnumWithMembersSoDisjointBaseIsRedundantrrs r!test_disjoint_basezStubtestUnit.test_disjoint_bases   "  ,     @  A  K#  A2A4c#Ktdddtdddtdddtddd td d dtd d dtdddtdddtdddtdddtdddtdddtd d!d"yw)#Nz#from typing_extensions import finalzZ import functools from typing_extensions import final rWz9 @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 zF.foozg class G: @staticmethod def foo() -> None: ... zw class G: @final @staticmethod def foo(): pass zG.foozg class H: @staticmethod def foo() -> None: ... zw class H: @staticmethod @final def foo(): pass zH.foozi class I: @classmethod def foo(cls) -> None: ... zy class I: @final @classmethod def foo(cls): pass zI.foozi class J: @classmethod def foo(cls) -> None: ... zy class J: @classmethod @final def foo(cls): pass zJ.foozf class K: @property def foo(self) -> int: ... z| class K: @property @final def foo(self): return 42 zK.foozV class L: def foo(self, obj: int) -> int: ... z class L: @final @functools.lru_cache() def foo(self, obj): return obj * 2 zL.foorrs r! test_has_runtime_final_decoratorz-StubtestUnit.test_has_runtime_final_decoratorKs6         24i5 5 n2$Y- - ^                       @   sCCc#Ktdddtdddtdd d td d d yw)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 zX.__mangle_badrWz 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_badrrs r!test_name_manglingzStubtestUnit.test_name_manglingL s|  #  =  "  ,    *  rc#LKtdddtdddyw)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: ... zC.foorWz& class X: ... zN class X: def __init__(self, x): pass z X.__init__rrs r!test_mrozStubtestUnit.test_mro s@#  &  rc#,Ktdddyw)Nap from typing import Literal import enum class Color(enum.Enum): RED = ... 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 rWrrs r!test_good_literalzStubtestUnit.test_good_literal s" ;  rc#*Ktdddtdddtddd td d d td ddtdddtdddtdddtdddyw)Nzfrom typing import Literalr5zINT_FLOAT_MISMATCH: Literal[1]zINT_FLOAT_MISMATCH = 1.0INT_FLOAT_MISMATCHrWzWRONG_INT: Literal[1]z WRONG_INT = 2 WRONG_INTzWRONG_STR: Literal['a']zWRONG_STR = 'b' WRONG_STRz%BYTES_STR_MISMATCH: Literal[b'value']zBYTES_STR_MISMATCH = 'value'BYTES_STR_MISMATCHz$STR_BYTES_MISMATCH: Literal['value']zSTR_BYTES_MISMATCH = b'value'STR_BYTES_MISMATCHzWRONG_BYTES: Literal[b'abc']zWRONG_BYTES = b'xyz' WRONG_BYTESzWRONG_BOOL_1: Literal[True]zWRONG_BOOL_1 = False WRONG_BOOL_1zWRONG_BOOL_2: Literal[False]zWRONG_BOOL_2 = True WRONG_BOOL_2rrs r!test_bad_literalzStubtestUnit.test_bad_literal s/T::1.&  /P[\\1;LT_``82&  73&  /*  .*   /)   sBBc#LKtdddtdddyw)NzL b1: bool b2: bool b3: bool zF b1 = 0 b2 = 1 b3 = 2 b3rWa  from typing import TypedDict, type_check_only @type_check_only 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 opt3rrs r!test_special_subtypez!StubtestUnit.test_special_subtype s@      %  rc#lKtdddtdddtdddyw)Nz&from typing import Protocol, TypedDictrWz class X(Protocol): bar: int def foo(self, x: int, y: bytes = ...) -> str: ... zD class Y(TypedDict): a: int rrs r!test_runtime_typing_objectsz(StubtestUnit.test_runtime_typing_objects sX9<        rc#lKtdddtdddtdddyw)Nfrom typing import NamedTuplerWg 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__rrs r!test_named_tuplezStubtestUnit.test_named_tuple1 sX03         rc#lKtdddtdddtdddyw) Nr<z"from collections import namedtuplerWr=zO X1 = namedtuple('X1', ['bar', 'foo'], defaults=['a']) r>zO X2 = namedtuple('X1', ['bar', 'foo'], defaults=['a']) r?rrs r!'test_named_tuple_typing_and_collectionsz4StubtestUnit.test_named_tuple_typing_and_collectionsU sX08        rc#Ktdddtdddtdddtdddtdddyw) Nzfrom typing import TypeVarrWzA = TypeVar('A')zB = TypeVar('B')zB = 5rzfrom typing import ParamSpeczC = ParamSpec('C')rrs r! test_type_varzStubtestUnit.test_type_vars si-7S[_  *4FdSS*G3GG/9W_c  ,6JRVWWrc#Ktdddtdddtdddtdddtdd d td d dtd d dtdddtdddtdddtdddtdddyw)Nzclass Meta(type): ...rWz class A0: ...zclass A1(metaclass=Meta): ... class A2: ...zclass A2(metaclass=Meta): ...A2zclass A3(metaclass=Meta): ... class A3: ...A3zclass T1(metaclass=type): ...z class T2: ...zclass T2(metaclass=type): ...zclass T3(metaclass=type): ...z class T3: ...zclass _P1(type): ...z class P2: ...zclass 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): ... S2rrs r!test_metaclass_matchz!StubtestUnit.test_metaclass_match s/9PX\]]MM03  1PX\]]7X\]]03  1PX\]]7X\]].8NVZ[[1OW[\\    rc#Ktdddtdddtdddtdddyw) Nzfrom abc import ABCMetarWz class A1(metaclass=ABCMeta): ...rFz class A2(metaclass=ABCMeta): ...rGz class A3(metaclass=ABCMeta): ...rHrrs r!test_metaclass_abcmetaz#StubtestUnit.test_metaclass_abcmeta sT1;T\`aa36  1S[_``:O[_``rc#Ktdddtdddtdddtdd d td d dtd ddtdddyw)Nz` from abc import abstractmethod from typing import overload from abc import abstractmethodrWzO class A1: def some(self) -> None: ... zo class A1: @abstractmethod def some(self) -> None: ... zA1.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: ... zA3.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: ... rrs r!test_abstract_methodsz"StubtestUnit.test_abstract_methods s5                "   $   r!c#Ktdddtdddtdddtd d dtd d dyw) NrPrWzi class AP1: @property def some(self) -> int: ... z class AP1: @property @abstractmethod def some(self) -> int: ... zAP1.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: ... rrs r!test_abstract_propertiesz%StubtestUnit.test_abstract_properties s14                 rc#,Ktdddtdddtdddtd d dtd d d td ddtdddtdddtdddtdddtdddtdddtdddtdddtdddtd ddtd!d"dyw)#Nz,from typing import type_check_only, overloadzfrom typing import overloadrWzD @type_check_only class A1: ... r5zD @type_check_only class A2: ... rFrGz(from typing import NamedTuple, TypedDictzQ @type_check_only class NT1(NamedTuple): ... zclass NT1(NamedTuple): ...NT1zP @type_check_only class TD1(TypedDict): ... zclass TD1(TypedDict): ...TD1zO @type_check_only def func1() -> None: ... zO @type_check_only def func2() -> None: ... zdef func2() -> None: ...func2zE @type_check_only class _P1: ... zE @type_check_only class _P2: ... zclass _P2: ..._P2z4 class _TD1(TypedDict): ... _TD1z@ _TD2 = TypedDict("_TD2", {"foo": int}) _TD2zD _TD3 = TypedDict("_TD3", {"foo-bar": int}) zB _TD4 = TypedDict("_TD4", {"class": int}) z5 class _NT1(NamedTuple): ... _NT1zR @type_check_only class _NT2(NamedTuple): ... zZ @type_check_only class _X1: ... X2 = _X1 z class X2: ...rrs r!test_type_check_onlyz!StubtestUnit.test_type_check_onlyc s?1     $   ;>  1   0      /      %                      $  rc#,Ktdddyw)Na from typing import Protocol, type_check_only @type_check_only class _FormatterClass(Protocol): def __call__(self, *, prog: str) -> HelpFormatter: ... class ArgumentParser: def __init__(self, formatter_class: _FormatterClass = ...) -> None: ... class HelpFormatter: def __init__(self, prog: str, indent_increment: int = 2) -> None: ... z class HelpFormatter: def __init__(self, prog, indent_increment=2) -> None: ... class ArgumentParser: def __init__(self, formatter_class=HelpFormatter): ... rWrrs r!test_type_default_protocolz'StubtestUnit.test_type_default_protocol s" +  rc#,Ktdddyw)N: def f(x: int = ...) -> None: ... zc _MISSING = object() def f(x=_MISSING): pass rWrrs r!test_object_markerzStubtestUnit.test_object_marker s"  rc#,Ktdddyw)Nr`z from typing_extensions import sentinel _MISSING = sentinel("_MISSING") def f(x=_MISSING): pass rWrrs r! test_sentinel_object_like_markerz-StubtestUnit.test_sentinel_object_like_marker "  rc#,Ktdddyw)Nr`z from typing_extensions import Sentinel _MISSING = Sentinel("_MISSING") def f(x=_MISSING): pass rWrrs r!'test_legacy_sentinel_object_like_markerz4StubtestUnit.test_legacy_sentinel_object_like_marker, rdrN)r]zIterator[Case])9r_r`rarrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrrr r$r&r(r*r4r8r:r@rBrDrLrNrQrSr\r^rarcrfrbr,r!rrsn  $  *  ,  4 4 l  @E E N    DH H T> > @  "@ @ D" " HD D L2 2 h| | |a a FM M ^| | |f f P  ( ( T  EE  >O>O@TT  "HH EE # # Jj j X  b b H~ ~ @8 8 t  >  B! ! F! ! F  >! ! F  : X X. . ` a a_ _ B@ @ DJ J X  2      "  r,rc0tjdd|S)Nz\x1b.*?mr5)resub)ss r!rArA? s 66+r1 %%r,ceZdZddZddZddZddZddZddZddZ ddZ dd Z dd Z dd Z dd Zdd ZddZddZddZddZy)StubtestMiscUnitctddg}dtdtdtd}||k(sJtdddg}d jt}||k(sJy) Nrzdef bad(num, text): passrserror: za.bad is inconsistent, stub parameter "number" differs from runtime parameter "num" Stub: in file z5.pyi:1 def (number: int, text: str) Runtime: in file z8.py:1 def (num, text) Found 1 error (checked 1 module) z --concisezU{}.bad is inconsistent, stub parameter "number" differs from runtime parameter "num" )rRr6ry)rYrIexpecteds r! test_outputzStubtestMiscUnit.test_outputD s?.  &'(-./ 0121  1 !!!?. M   MMSV N  !!!r,c`tt5}tdjttdjt tdjt tjddtdjdtd jdtd jd td jd tj}tj}tj|5tj|5tttgdddddddt!|j#j%tj&j)|tj*zdj%|tj*zd}dddj-ddk(sJd|vsJd|vsJy#1swYxYw#1swYxYw#1swYDxYw)Nr.r0r1r#T)exist_okztest_module/__init__.pyizfrom .mod import fztest_module/__init__.pyztest_module/mod.pyizdef f(self) -> None: ...ztest_module/mod.pyzdef f(self, x): passr3r5z stub does not have parameter "x"z __init__.pyizmod.py:1)r"r6r write_textr9r:r;rmakedirsr<r=r>r?r@rr rArBrCrrDrEcount)rYrKrIrJrMs r!%test_reexport_reports_import_locationz6StubtestMiscUnit.test_reexport_reports_import_locationa s ) * g  + +,B C   ) )*> ?   ' '(: ; KK  5 + , 7 78L M * + 6 67K L & ' 2 23M N % & 1 12H I[[]F[[]F++F3 ZZ5O5OPV5W Z=*:); None: ... def bad(number: int) -> None: ... def also_bad(number: int) -> None: ... rhz def good(): pass def bad(asdf): pass def also_bad(asdf): pass rrz¬e: unused allowlist entry unused.* z .also_bad ) rNamedTemporaryFiler8r6rRnamer7r(r)rjrunlink)rY allowlistrIrLs r!test_allowlistzStubtestMiscUnit.test_allowlist s//T%H 0 & Q#3"44N OP Q"C3& 7F EE EE"r2 y~~?^_F/0@/AB55  "& 8STF EE EEinn40 &A+,F34-. % & "__&t & !)t & ' 8NO F9:J9K;W  IIinn %_ Q Q2 & &, IIinn %s;F*FB F*?;F:A6F*FF*F'#F**!G ctddg}|djtk(sJtddg}|djtk(sJy)N+r5rszherror: not checking stubs due to failed mypy compile: {}.pyi:1: error: Expected an expression [syntax] zdef f(): ... def f(): ...zterror: not checking stubs due to mypy build errors: {}.pyi:2: error: Name "f" already defined on line 1 [no-redef] )rRryr6r{s r!test_mypy_buildz StubtestMiscUnit.test_mypy_build sg3B? 88>?O8P   #?UWX FFLfM]F^   r,ctj}tj|5t t dgdddt |jdk(sJy#1swY(xYw)N not_a_modulezferror: not_a_module failed to find stubs Stub: MISSING Runtime: N/A Found 1 error (checked 1 module) r<r=r>r?rr rArBr{s r!test_missing_stubsz#StubtestMiscUnit.test_missing_stubs sc  ' ' / 8 }n%56 7 8 !23 1    8 8s A''A0ctt5ttdd5}|jddddt j }t j|5tttgdddt|j}|dk(sJ dddy#1swY~xYw#1swY?xYw#1swYyxYw)Nr2r/za = 1ry) r"r6r7r8r<r=r>r?rr rArB)rYrLrI output_strs r! test_only_pyzStubtestMiscUnit.test_only_py s) * J)*#.4 !  ![[]F++F3 >=*:);<= >*6??+<=J!II II J J ! ! > >  J Js9C B31C 'B?(C 3B< 8C ?C C  Cctjjdd}d|vsJd|vsJd|vsJd|vsJd|vsJd|vsJd|vsJtjjdd }d|vsJd |vsJd|vsJy) N)builtinsrzos.pathasynciographlib contextvarszimportlib.metadata)r formatter)mypystubtestget_typeshed_stdlib_modules)rYstdlibs r! test_get_typeshed_stdlib_modulesz1StubtestMiscUnit.test_get_typeshed_stdlib_modules s::4HV###v~~F"""F"""'''&&&#6111::4IV###&(((#v---r,cdddd}ttjjj t j |dk(sJy)Nr)dcyrVrb)abrmrr~s r!rLz*StubtestMiscUnit.test_signature..f s r,z#def (a, b, *, c, d = ..., **kwargs)) rintrrrmrrrr~rr]r^)r[rr Signaturefrom_inspect_signatureinspect signature)rYrLs r!test_signaturezStubtestMiscUnit.test_signature sG23   ''>>w?P?PQR?ST U4 5  5r,ctjjtj}|Jt tjj j|dk(sJy)Nz*def (self, sep = ..., bytes_per_sep = ...))rrsafe_inspect_signaturebyteshexr[rr)rYsigs r!3test_builtin_signature_with_unrepresentable_defaultzDStubtestMiscUnit.test_builtin_signature_with_unrepresentable_default sSmm22599=  ''>>sC D; <  None: ... @overload def myfunction(arg: str, /) -> None: ... __main__ myfunctionzdef (arg: int | str)) r+filesnamesnode isinstancer OverloadedFuncDefrrrfrom_overloadedfuncdefr[)rYr*resultrFrs r!test_overload_signaturez(StubtestMiscUnit.test_overload_signature sw f%||J'--l;@@$ 7 7888mm%%<rr<rrhrrr(unittestcollections.abcrrpathlibrtypingrpytestr mypy.stubtestrr r mypy.modulefinderr mypy.optionsr r rmypy.test.configrmypy.test.datarcontextmanagerr"r6r:r9r;r+rOrRrTrTestCaserrArlrbr,r!rsR" .) 3*# "!4l(TD#!%!% %, %, %,%, %,  %,  %,%,RLPL LL&/L>HLL 'Tc, 8$$c, LY&V x((V r,