ML i"iddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl mZmZddlZddlmZmZddlmZddlmZddlmZmZdd lmZdd lmZej<dd Zd Z d Z!dZ"dZ#ddZ$ d ddZ% d ddZ&GddZ'd dZ(Gdde jRZ*d!dZ+Gdde jRZ,y)") annotationsN)Iterator)AnyCallable)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 \/mnt/ssd/data/python-lab/Trading/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 TypedDict = 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 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]] def overload(func: _T) -> _T: ... def type_check_only(func: _T) -> _T: ... def final(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 frozenset(Generic[T]): ... 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__ c tjtddtj|gt t S)Nzmain.pyi)sourcesoptions alt_lib_path)rr textwrapdedentr r )sources r build_helperr)s3 ;;Zxv/FGH " c 2tt5}tdd5}|jtdddtdd5}|jt dddtdd5}|jt dddttdd5}|j|dddttdd5}|j|ddd|r;ttdd5}|j|ddd|dtdgz}tj}tj}tj|5tj|5tttg|zd dddddddddtjj!t"j$j't"j(zd j!|t"j(zd }tjj!t"j$j'|t"j(zd j!|t"j(zd } || fS#1swYsxYw#1swYVxYw#1swY9xYw#1swYxYw#1swYxYw#1swYxYw#1swY\xYw#1swYaxYw#1swYfxYw) Nz builtins.pyiwz typing.pyizenum.pyiz.pyi.pyz _config.iniz--mypy-config-fileT)use_builtins_fixtures)r TEST_MODULE_NAMEopenwritestubtest_builtins_stubstubtest_typing_stubstubtest_enum_stubioStringIO contextlibredirect_stdoutredirect_stderrr r remove_color_codegetvaluereplacerrrealpathsep) stubruntimer$ config_filetmp_dirfoutputouterrfiltered_outputfiltered_outerrs rrun_stubtest_with_stderrrIs % &`' .# & ,! GG* + , , $ * GG( ) * *c " (a GG& ' ( %&d+S 1 Q GGDM  %&c*C 0 A GGG   )*+6< % $ %!5:J9K;7W XXG  ' ' / `1K1KF1S ` }&6%7'%ABZ^ _ ` `#`&( !!'*RVV3R 8266AQSU9VO ( !!'*RVV3R 8266AQSU9VO O ++9 , , * * ( (     % %  ` ` ` `#``s L J$L J1L 1J>L "K 4L K!L >K%AL #K?9K2K? L $J. )L 1J; 6L >K L  K L K" L %K/ *L 2K< 7K??L L  Lc$t||||dSrrIr@rAr$rBs r run_stubtestrMs $D'7K H KKr*ceZdZddZy)Casec.||_||_||_yNr@rAerror)selfr@rArSs r__init__z Case.__init__s   r*N)r@strrArVrS str | NonereturnNone)__name__ __module__ __qualname__rUr*rrOrOsr*rOcdfd }|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. cpt|i|}t}|D]u}|j|j}|dk(rt}n#|j tds td|}||vsJdj ||j |wtdjd|Ddjd|Ddg}t|j}||k7rGtdjd |Ddjd |Dg}||k(sJ|yy) Nr/.z_collect_cases merges cases into a single stubtest invocation; we already expect an error for {}z c3xK|]2}tj|jjd4yw Nr&r'r@lstrip.0cs r z.collect_cases..test..s&QaX__QVV]]4-@AQ8:c3xK|]2}tj|jjd4ywrbr&r'rArerfs rriz.collect_cases..test..s(WA 0@0@0F GWrj--generate-allowlistr@rAr$c3xK|]2}tj|jjd4ywrbrdrfs rriz.collect_cases..test..s& U!t1D!E Urjc3xK|]2}tj|jjd4ywrbrlrfs rriz.collect_cases..test..s)#[PQHOOAII4D4DT4J$K#[rj) listsetrSr0 startswithformataddrMjoin splitlines) argskwargscasesexpected_errorsrhexpected_errorrE actual_errorsfns rtestzcollect_cases..testsLR(()% 0AwwWWN#!1#..2B1C1/EF$4#5Q~6F!G!8 ))/)? 8    / 0Q5QQKKWQVWW+,  F--/0 O +![[ Uu UU #[UZ#[[F !O3 ;V ;3 ,r*)rxrryrrXrYr])r~rs` r collect_casesrs<> Kr*c6eZdZed/dZed/dZed/dZed/dZed/dZed/dZ ed/dZ ed/dZ ed/d Z ed/d Z ed/d Zed/d Zed/d Zed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZ ed/dZ!ed/dZ"ed/d Z#ed/d!Z$ed/d"Z%ed/d#Z&ed/d$Z'ed/d%Z(ed/d&Z)ed/d'Z*ed/d(Z+ed/d)Z,ed/d*Z-ed/d+Z.ed/d,Z/ed/d-Z0y.)0 StubtestUnitc#LKtdddtdddyw)Nz*def f(number: int, text: str) -> None: ...zdef f(number, text): passrRzc class X: def f(self, number: int, text: str) -> None: ... zR class X: def f(self, number, text): pass rOrTs rtest_basic_goodzStubtestUnit.test_basic_goods:=/    "$c#lKtdddtdddtdd d yw) Nz!def mistyped_class() -> None: ...zclass mistyped_class: passmistyped_classrRzclass 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_typessR40"  )3LTa  #  24c#Ktdddtdddtdddtd d dyw) Nzdef bar() -> int: ...zasync def bar(): return 5barrRzasync def foo() -> int: ...zdef foo(): return 5zdef baz() -> int: ...zdef baz(): return 5zasync def bingo() -> int: ...zasync def bingo(): return 5rrs rtest_coroutineszStubtestUnit.test_coroutines1sR/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: passbadrR7def 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_name;s?6  J:  I:       =@  HH  ?D#  sBBc#Ktdddtdddtdd d td d dtd ddtdddyw)Nz7def runtime_kwonly(number: int, text: str) -> None: ...z)def runtime_kwonly(number, *, text): passruntime_kwonlyrRz7def 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_kindrsJ?"  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): passrRz"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 rtest_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'): passrRz$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 rtest_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'): passf1rRz(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 rtest_default_valuezStubtestUnit.test_default_values,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 rRze 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 rtest_static_class_methodz%StubtestUnit.test_static_class_methodIs                 AAc#Ktdddtdddtddd td d d td ddyw)Nzdef f1(a, *, b, c) -> None: ...zdef f1(a, *, b, c): passrRzdef 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 rtest_arg_mismatchzStubtestUnit.test_arg_mismatchs|2 None: ...zdef f1(*args, **kwargs): passrRz$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 rtest_varargs_varkwargsz#StubtestUnit.test_varargs_varkwargss73  7,  2 int: ... @overload def f1(a: int, b: int, c: int = ...) -> str: ... zdef f1(a, b = 0, c = 0): passrRz @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_overloads>4   0   0   :   )   !  $ )   ,   .    %  (   sB2B4c#Ktdddtdddtdddtd d d td d dtdddtdddyw)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 rRzf 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() rrs r test_propertyzStubtestUnit.test_propertyfs           "   %  #  & %  A2A4c#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 rRz 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 rtest_cached_propertyz!StubtestUnit.test_cached_propertys%  (       $  %  ( "!  rc#JKtdddtdddtdddtd d dtd d d tdddtdddtdddtdddtdddyw)Nzx1: intzx1 = 5rRzx2: strzx2 = 5x2zfrom typing import Tupler/z- 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 rrs rtest_varzStubtestUnit.test_var6s 84@@ 84@@-r488"   %    +?tLLA=      %    sB!B#c#TKtdddtdddtddd td d d td d dtdddtdddtdddtdddtdddtdddtdd dtd!d"dtd#d#dtd$d%dtd&d'dtjd(k\rtd)d*dyyw)+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 rRz] 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 = 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.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] rOr version_infors rtest_type_aliaszStubtestUnit.test_type_aliasvs        -7GsSS 2S99 Bd;;                 -7QYbcc          (2B$OO           w &  ;  'sD&D(c#,Ktdddtdddtdddtdd d td d dtd ddtdddtdddtdddyw)Nz import enumrRz{ 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 = ... rAr@rSz 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__ = () rrs r test_enumzStubtestUnit.test_enum5s }DII                #  &     )  ,  /  BBc#,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 rRrrs rtest_decoratorzStubtestUnit.test_decorators"    c#,Ktdddyw)NzZ: intz+ __all__ = [] Z = 5__all__rRrrs rtest_all_at_runtime_not_stubz)StubtestUnit.test_all_at_runtime_not_stubs    rc#,Ktdddyw)Nz __all__ = ()r/rrRrrs rtest_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' rrRrrs r,test_all_in_stub_different_to_all_at_runtimez9StubtestUnit.test_all_in_stub_different_to_all_at_runtimes$   rc#Ktdddtdddtdddtd dd tdd d tdd dtdddtdddtdddtdddtdddtdddtddd yw)!Nzx = 5r/xrR def f(): ...rDz 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__rrs r test_missingzStubtestUnit.test_missings377#>>#>>  N)DD$=SII$ESQQHRT\_  ^  U  <7    20  20   CCc#Ktdddtdddtdddtddd tdd dtdd dyw) Nr/z import sysrR def g(): ...rz CONSTANT = 0CONSTANTz'import re; constant = re.compile('foo')constantz"from json.scanner import NUMBER_REz from string import ascii_lettersrrs rtest_missing_no_runtime_allz(StubtestUnit.test_missing_no_runtime_all4seL==N#>>N*EE$MU_``$HPTUU$FdSSrc#,Ktdddyw)Nr/z 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 rRrrs r$test_missing_no_runtime_all_terriblez1StubtestUnit.test_missing_no_runtime_all_terrible=s    rc#ZKtddtdtdddyw)Nz__all__: list[str]r/z.__all__rRz_f: intz def _f(): ..._f)rOr0rs rtest_non_public_1zStubtestUnit.test_non_public_1Os4%rOW[\\.DD.DDrc#Ktdddtdddtdd dtd d dyw) Nz:class A: def __init__(self, a: int, b: int) -> None: ...z*class A: def __init__(self, a, bx): passz A.__init__rRz: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): ...rrs r test_dunderszStubtestUnit.test_dunders\siNA  NA  % R  RG  rc#LKtdddtdddyw)Nzclass CanBeSubclassed: ...rRzCclass CannotBeSubclassed: def __init_subclass__(cls) -> None: ...zGclass CannotBeSubclassed: def __init_subclass__(cls): raise TypeErrorCannotBeSubclassedrrs rtest_not_subclassablez"StubtestUnit.test_not_subclassablexs4-7S[_  W^&  rc#Ktdddtdddtdddtd d dtd d d tdddtdddyw)Nz' class A: pass rRz{ 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 rtest_disjoint_basezStubtestUnit.test_disjoint_bases   "  ,     @  A  K#  rc#Ktdddtdddtdddtddd td d dtd d dtdddtdddtdddtdddtdddtdddtd d!d"yw)#Nz#from typing_extensions import finalzZ import functools from typing_extensions import final rRz9 @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_decorators6         24i5 5 n2$Y- - ^                       @   rc#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_badrRz 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 rtest_name_manglingzStubtestUnit.test_name_manglings|  #  =  "  ,    *  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.foorRz& class X: ... zN class X: def __init__(self, x): pass z X.__init__rrs rtest_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 rRrrs rtest_good_literalzStubtestUnit.test_good_literalDs" ;  rc#*Ktdddtdddtddd td d d td ddtdddtdddtdddtdddyw)Nzfrom typing import Literalr/zINT_FLOAT_MISMATCH: Literal[1]zINT_FLOAT_MISMATCH = 1.0INT_FLOAT_MISMATCHrRzWRONG_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 rtest_bad_literalzStubtestUnit.test_bad_literalfs/T::1.&  /P[\\1;LT_``82&  73&  /*  .*   /)   sBBc#LKtdddtdddyw)NzL b1: bool b2: bool b3: bool zF b1 = 0 b2 = 1 b3 = 2 b3rRz from typing 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 opt3rrs rtest_special_subtypez!StubtestUnit.test_special_subtypes@      #  rc#lKtdddtdddtdddyw)Nz&from typing import Protocol, TypedDictrRz class X(Protocol): bar: int def foo(self, x: int, y: bytes = ...) -> str: ... zD class Y(TypedDict): a: int rrs rtest_runtime_typing_objectsz(StubtestUnit.test_runtime_typing_objectssX9<        rc#lKtdddtdddtdddyw)Nfrom typing import NamedTuplerRg 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 rtest_named_tuplezStubtestUnit.test_named_tuplesX03         rc#lKtdddtdddtdddyw) Nr/z"from collections import namedtuplerRr0zO X1 = namedtuple('X1', ['bar', 'foo'], defaults=['a']) r1zO X2 = namedtuple('X1', ['bar', 'foo'], defaults=['a']) r2rrs r'test_named_tuple_typing_and_collectionsz4StubtestUnit.test_named_tuple_typing_and_collectionssX08        rc#Ktdddtdddtdddtjdk\r!tdddtd d dyyw) Nzfrom typing import TypeVarrRzA = TypeVar('A')zB = TypeVar('B')zB = 5rrzfrom typing import ParamSpeczC = ParamSpec('C')rrs r test_type_varzStubtestUnit.test_type_var s|-7S[_  *4FdSS*G3GG   w &36  0:NVZ[ [ 'sA&A(c#Ktdddtdddtdddtdddtdd d td d dtd d dtdddtdddtdddtdddtdddyw)Nzclass Meta(type): ...rRz 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 rtest_metaclass_matchz!StubtestUnit.test_metaclass_match s/9PX\]]MM03  1PX\]]7X\]]03  1PX\]]7X\]].8NVZ[[1OW[\\    rc#Ktdddtdddtdddtdddyw) Nzfrom abc import ABCMetarRz class A1(metaclass=ABCMeta): ...r9z class A2(metaclass=ABCMeta): ...r:z class A3(metaclass=ABCMeta): ...r;rrs rtest_metaclass_abcmetaz#StubtestUnit.test_metaclass_abcmetaO sT1;T\`aa36  1S[_``:O[_``rc#Ktdddtdddtdddtdd d td d dtd ddtdddyw)Nz` from abc import abstractmethod from typing import overload from abc import abstractmethodrRzO 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 rtest_abstract_methodsz"StubtestUnit.test_abstract_methods] s5                "   $   rc#Ktdddtdddtdddtd d dtd d dyw) NrCrRzi 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 rtest_abstract_propertiesz%StubtestUnit.test_abstract_properties s14                 rc#,Ktdddtdddtdddtd d dtd d d td ddtdddtdddtdddyw)Nz,from typing import type_check_only, overloadzfrom typing import overloadrRzD @type_check_only class A1: ... r/zD @type_check_only class A2: ... r9r:z(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: ...func2zZ @type_check_only class _X1: ... X2 = _X1 z class X2: ...rrs rtest_type_check_onlyz!StubtestUnit.test_type_check_only s?1     $   ;>  1   0      /    $  rc#,Ktdddyw)Na from typing import Protocol 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): ... rRrrs rtest_type_default_protocolz'StubtestUnit.test_type_default_protocolO s" )  rN)rXzIterator[Case])1rZr[r\rrrrrrrrrrrrrrrrrrrrrrrrrr r rrrrrrrr'r+r-r3r5r7r?rArDrFrKrMr]r*rrrs  $  *  4 4 l  @E E N    DH H T> > @  "@ @ DD D Li i Va a F= = ~|||N N `    EE  ; ; zTT  "HH EE   6  b b H~ ~ @8 8 t  >  B! ! F    D  >! ! F  : \ \. . ` a a_ _ B@ @ DJ J X  r*rc0tjdd|S)Nz\x1b.*?mr/)resub)ss rr;r;i s 66+r1 %%r*ceZdZddZddZddZddZddZddZddZ ddZ dd Z dd Z dd Z dd Zdd ZddZddZddZy)StubtestMiscUnitctddg}dtdtdtd}||k(sJtdddg}d jt}||k(sJy) Nrzdef bad(num, text): passrnerror: za.bad is inconsistent, stub parameter "number" differs from runtime parameter "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 --concisezU{}.bad is inconsistent, stub parameter "number" differs from runtime parameter "num" )rMr0rt)rTrEexpecteds r test_outputzStubtestMiscUnit.test_outputn s?.  &'(-./ 0121  1 !!!?. M   MMSV N  !!!r*ctdddg}|dk(sJtdddg}|dk(sJtddd g}|dk(sJy) Nr/z__all__ = ['f'] def f(): passz--ignore-missing-stubrn%Success: no issues found in 1 module z def f(): passzdef f(__a): ...zdef f(a): passz--ignore-positional-onlyrMrTrEs rtest_ignore_flagsz"StubtestMiscUnit.test_ignore_flags sq=H_G` AAAA2I`HabAAAA", None: ... def bad(number: int) -> None: ... def also_bad(number: int) -> None: ... rcz def good(): pass def bad(asdf): pass def also_bad(asdf): pass rmz¬e: unused allowlist entry unused.* z .also_bad ) rNamedTemporaryFiler2r0rMnamer1r&r'rerunlink)rT allowlistrErDs rtest_allowlistzStubtestMiscUnit.test_allowlist s//T%H 8 & Q#3"44N OP Q"C3& 7F EE EE"r2 y~~?^_F/0@/AB55  "& 8STF EE EEinn40 &A+,F34-. % & "__ ! ' 8NO'F*9:J9K;W  IIinn %o Q Q2 & &< IIinn %s;F*FB F*?;F:A6F*FF*F'#F**!G ctddg}|djtk(sJtddg}|djtk(sJy)N+r/rnz`error: not checking stubs due to failed mypy compile: {}.pyi:1: error: Invalid syntax [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] )rMrtr0r[s rtest_mypy_buildz StubtestMiscUnit.test_mypy_build sg3B? 0067G0H   #?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) r6r7r8r9r r r;r<r[s rtest_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)Nr-r,za = 1rY) r r0r1r2r6r7r8r9r r r;r<)rTrDrE 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|vsJd |vsJtjjdd }d|vsJd|vsJd |vsJy) N)rbuiltinsrzos.pathasynciographlib formatter contextvarszimportlib.metadatar)mypystubtestget_typeshed_stdlib_modules)rTstdlibs r test_get_typeshed_stdlib_modulesz1StubtestMiscUnit.test_get_typeshed_stdlib_modules s::4HV###v~~F"""F"""'''f$$$&&&#6111::4IV###&(((#v---r*cdddd}ttjjj t j |dk(sJy)Nr)dcyrQr])abrhr|rys rrDz*StubtestMiscUnit.test_signature..f s r*z#def (a, b, *, c, d = ..., **kwargs)) r~intrrrhrr|rryrrXrY)rVrvrw Signaturefrom_inspect_signatureinspect signature)rTrDs rtest_signaturezStubtestMiscUnit.test_signature sG23   ''>>w?P?PQR?ST U4 5  5r*ctjjtj}|Jt tjj j|dk(sJy)Nz*def (self, sep = ..., bytes_per_sep = ...))rvrwsafe_inspect_signaturebyteshexrVrr)rTsigs r3test_builtin_signature_with_unrepresentable_defaultzDStubtestMiscUnit.test_builtin_signature_with_unrepresentable_default sSmm22599=  ''>>sC D; <  None: ... @overload def myfunction(arg: str, /) -> None: ... __main__ myfunctionrz&def (arg: builtins.int | builtins.str)z,def (arg: Union[builtins.int, builtins.str]))r)filesnamesnode isinstancerOverloadedFuncDefrvrwrfrom_overloadedfuncdefrrrV)rTr(resultr@rs rtest_overload_signaturez(StubtestMiscUnit.test_overload_signature s f%||J'--l;@@$ 7 7888mm%%<rs." $ ) 3*# "!/b#JDLP ,  , ,&/ ,>H , ,HLPL LL&/L>HLL 'T_% 8$$_% DK&A x((A r*