o tBh@sddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z m Z mZddlZddlmZmZddlmZejd%d d Zd Zd ZdZ d&d'ddZGdddZd(ddZGddde jZd)d!d"ZGd#d$d$e jZ dS)*) annotationsN)AnyCallableIterator) parse_options test_stubs)root_dirmod_namestrreturn Iterator[str]c cst}tjdd}tM}z-t|tjd|kr%tjd||VW|ddt_|tjvr9tj|=t|n|ddt_|tjvrOtj|=t|wWddS1s`wYdS)Nr) osgetcwdsyspathtempfileTemporaryDirectorychdirinsertmodules)r currentcurrent_syspathtmprm/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/mypy/test/teststubtest.py use_tmp_dirs$     "r test_moduleaP Any = object() class _SpecialForm: def __getitem__(self, typeargs: Any) -> object: ... Callable: _SpecialForm = ... Generic: _SpecialForm = ... Protocol: _SpecialForm = ... Union: _SpecialForm = ... class TypeVar: def __init__(self, name, covariant: bool = ..., contravariant: bool = ...) -> None: ... class ParamSpec: def __init__(self, name: str) -> None: ... AnyStr = TypeVar("AnyStr", str, bytes) _T = TypeVar("_T") _T_co = TypeVar("_T_co", covariant=True) _K = TypeVar("_K") _V = TypeVar("_V") _S = TypeVar("_S", contravariant=True) _R = TypeVar("_R", covariant=True) class Coroutine(Generic[_T_co, _S, _R]): ... class Iterable(Generic[_T_co]): ... class Mapping(Generic[_K, _V]): ... class Match(Generic[AnyStr]): ... class Sequence(Iterable[_T_co]): ... class Tuple(Sequence[_T_co]): ... def overload(func: _T) -> _T: ... aI 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 class type: ... class tuple(Sequence[T_co], Generic[T_co]): ... class dict(Mapping[KT, VT]): ... class function: pass class ellipsis: pass class int: ... class float: ... class bool(int): ... class str: ... class bytes: ... class list(Sequence[T]): ... def property(f: T) -> T: ... def classmethod(f: T) -> T: ... def staticmethod(f: T) -> T: ... stubruntimeoptions list[str] config_file str | Nonec Cstt}tdd }|tWdn1swYtdd }|tWdn1s4wYttdd }||Wdn1sQwYttdd }||Wdn1snwY|rttdd }||Wdn1swY|dtdg}t}t |t t tg|dd Wdn1swY| tj|tjd  |tjd  WdS1swYdS) Nz builtins.pyiwz typing.pyiz.pyi.pyz _config.iniz--mypy-config-fileT)use_builtins_fixtures)rTEST_MODULE_NAMEopenwritestubtest_builtins_stubstubtest_typing_stubioStringIO contextlibredirect_stdoutrrgetvaluereplacer rrealpathsep)rrrr!tmp_dirfoutputrrr run_stubtestks6         $r7c@seZdZd ddZdS) Caserr rerrorr"cCs||_||_||_dSNrrr9)selfrrr9rrr__init__s z Case.__init__N)rr rr r9r")__name__ __module__ __qualname__r=rrrrr8sr8fnCallable[..., Iterator[Case]]Callable[..., None]csd fdd }|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. argsrkwargsr Nonecst|i|}t}|D]1}|jdurq|j}|dkr t}n|tds/td|}||vs:Jd|||qtddd|Dddd|Ddgd }t| }||ksfJ|dS) Nr&.z_collect_cases merges cases into a single stubtest invocation; we already expect an error for {}z cs"|] }t|jdVqdS N)textwrapdedentrlstrip.0crrr  z.collect_cases..test..csrHrI)rKrLrrMrNrrrrQrR--generate-allowlistrrr) listsetr9r' startswithformataddr7join splitlines)rDrEcasesexpected_errorsrPexpected_errorr6 actual_errorsrArrtests,    zcollect_cases..testN)rDrrErr rFr)rArarr`r collect_casessrbc@seZdZedFddZedFddZedFddZedFd d ZedFd d ZedFd dZ edFddZ edFddZ edFddZ edFddZ edFddZedFddZedFddZedFddZedFdd ZedFd!d"ZedFd#d$ZedFd%d&ZedFd'd(ZedFd)d*ZedFd+d,ZedFd-d.ZedFd/d0ZedFd1d2ZedFd3d4ZedFd5d6ZedFd7d8ZedFd9d:ZedFd;d<Z edFd=d>Z!edFd?d@Z"edFdAdBZ#edFdCdDZ$dES)G StubtestUnitr Iterator[Case]ccs&tddddVtddddVdS)Nz*def f(number: int, text: str) -> None: ...zdef f(number, text): passr;zc class X: def f(self, number: int, text: str) -> None: ... zR class X: def f(self, number, text): pass r8r<rrrtest_basic_goods zStubtestUnit.test_basic_goodccs6tddddVtddddVtdd d dVdS) Nz!def mistyped_class() -> None: ...zclass mistyped_class: passmistyped_classr;zclass mistyped_fn: ...zdef mistyped_fn(): pass mistyped_fnzU class X: def mistyped_var(self) -> int: ... zC class X: mistyped_var = 1 zX.mistyped_varrerfrrr test_typess zStubtestUnit.test_typesccsFtddddVtddddVtddddVtd d ddVdS) Nzdef bar() -> int: ...zasync def bar(): return 5barr;zasync def foo() -> int: ...zdef foo(): return 5zdef baz() -> int: ...zdef baz(): return 5zasync def bingo() -> int: ...zasync def bingo(): return 5rerfrrrtest_coroutiness zStubtestUnit.test_coroutinesccs`tddddVtjdkrtddddVtdd d dVtd d d dVtddddVdS)N,def bad(number: int, text: str) -> None: ...z def bad(num, text) -> None: passbadr;7def good_posonly(__number: int, text: str) -> None: ...z$def good_posonly(num, /, text): passz6def bad_posonly(__number: int, text: str) -> None: ...z$def bad_posonly(flag, /, text): pass bad_posonlyzk class BadMethod: def f(self, number: int, text: str) -> None: ... zU class BadMethod: def f(self, n, text): pass z BadMethod.fze class GoodDunder: def __exit__(self, t, v, tb) -> None: ... zo class GoodDunder: def __exit__(self, exc_type, exc_val, exc_tb): pass r8r version_inforfrrr test_arg_names6   zStubtestUnit.test_arg_nameccsttddddVtddddVtdd d dVtjd kr8td d ddVtddddVtddddVdSdS)Nz7def runtime_kwonly(number: int, text: str) -> None: ...z)def runtime_kwonly(number, *, text): passruntime_kwonlyr;z7def stub_kwonly(number: int, *, text: str) -> None: ...z#def stub_kwonly(number, text): pass stub_kwonlyz7def stub_posonly(__number: int, text: str) -> None: ...z$def stub_posonly(number, text): pass stub_posonlyrorrz'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_570rtrfrrr test_arg_kindsB  zStubtestUnit.test_arg_kindccsftddddVtddddVtddd dVtd d d dVtd dddVtddddVdS)Nz$def f1(text: str = ...) -> None: ...zdef f1(text = 'asdf'): passr;z$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): passf6rerfrrrtest_default_value0s: zStubtestUnit.test_default_valueccsVtddddVtddddVtddd dVtd d d dVtd dddVdS)Nz class Good: @classmethod def f(cls, number: int, text: str) -> None: ... zq class Good: @classmethod def f(cls, number, text): pass r;ze 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 rerfrrrtest_static_class_methodSs4     z%StubtestUnit.test_static_class_methodccsVtddddVtddddVtddd dVtd d d dVtd dddVdS)Nzdef f1(a, *, b, c) -> None: ...zdef f1(a, *, b, c): passr;zdef f2(a, *, b) -> None: ...zdef f2(a, *, b, c): passr}zdef f3(a, *, b, c) -> None: ...zdef f3(a, *, b): passr~zdef f4(a, *, b, c) -> None: ...zdef f4(a, b, *, c): passrzdef f5(a, b, *, c) -> None: ...zdef f5(a, *, b, c): passrrerfrrrtest_arg_mismatchs  zStubtestUnit.test_arg_mismatchccstddddVtddddVtddddVtd d d dVtd d ddVtddddVtddddVtddddVtddddVtddddVtddddVtd d!d"dVtd#d$ddVtd%d&d'dVtd(d)ddVtd*d+d,dVtd-d.d/dVdS)0Nz$def f1(*args, **kwargs) -> None: ...zdef f1(*args, **kwargs): passr;z$def f2(*args, **kwargs) -> None: ...zdef f2(**kwargs): passr}zdef 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): passk6rerfrrrtest_varargs_varkwargss z#StubtestUnit.test_varargs_varkwargsccsdtddddVtddddVtddd dVtd d ddVtjd kr0td dddVdSdS)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): passr;z @overload def f2(a: int, *, c: int = ...) -> int: ... @overload def f2(a: int, b: int, c: int = ...) -> str: ... zdef f2(a, b, c = 0): passr}z @overload def f3(a: int) -> int: ... @overload def f3(a: int, b: str) -> str: ... zdef f3(a, b = None): passr~z @overload def f4(a: int, *args, b: int, **kwargs) -> int: ... @overload def f4(a: str, *args, b: int, **kwargs) -> str: ... z#def f4(a, *args, b, **kwargs): passroz @overload def f5(__a: int) -> int: ... @overload def f5(__b: str) -> str: ... zdef f5(x, /): passrtrfrrr test_overloads8     zStubtestUnit.test_overloadccsvtddddVtddddVtddddVtd d d dVtd d ddVtddddVtddddVdS)Nzt class Good: @property def read_only_attr(self) -> int: ... zr class Good: @property def read_only_attr(self): return 1 r;zf class Bad: @property def f(self) -> int: ... zQ class Bad: def f(self) -> int: return 1 zBad.fzo class GoodReadOnly: @property def f(self) -> int: ... zC class GoodReadOnly: f = 1 zn class BadReadOnly: @property def f(self) -> str: ... zB class BadReadOnly: f = 1 z BadReadOnly.fz class Y: @property def read_only_attr(self) -> int: ... @read_only_attr.setter def read_only_attr(self, val: int) -> None: ... o class Y: @property def read_only_attr(self): return 5 Y.read_only_attrz class Z: @property def read_write_attr(self) -> int: ... @read_write_attr.setter def read_write_attr(self, val: int) -> None: ... class Z: @property def read_write_attr(self): return self._val @read_write_attr.setter def read_write_attr(self, val): self._val = val zr class FineAndDandy: @property def attr(self) -> int: ... a class _EvilDescriptor: def __get__(self, instance, ownerclass=None): if instance is None: raise AttributeError('no') return 42 def __set__(self, instance, value): raise AttributeError('no') class FineAndDandy: attr = _EvilDescriptor() rerfrrr test_property!sH     zStubtestUnit.test_propertyccstddddVtddddVtdddVtd d ddVtd d d dVtddddVtddddVtddddVtddddVtddddVdS)Nzx1: intzx1 = 5r;zx2: 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 rrerfrrrtest_varsF   zStubtestUnit.test_varccstddddVtddddVtdd d dVtd d ddVtd d ddVtddddVtddddVtddddVtddddVtddddVtddddVtdd ddVtd!d!ddVtd"d#ddVtd$d%ddVtjd&krtd'd(ddVdSdS))Nz] class X: def f(self) -> None: ... Y = X zd class X: def f(self) -> None: ... class Y: ... zY.fr;zR from typing import Tuple A = Tuple[int, str] zA = (int, str)AzB = strr&Bz_C = intz from typing import Tuple D = tuple[str, str] E = Tuple[int, int, int] F = Tuple[str, int] z from typing import List, Tuple D = Tuple[str, str] E = Tuple[int, int, int] F = List[str] Fz from typing import Union G = str | int H = Union[str, bool] I = str | int z from typing import Union G = Union[str, int] H = Union[str, bool] I = str Iz import typing from collections.abc import Iterable from typing import Dict K = dict[str, str] L = Dict[int, int] KK = Iterable[str] LL = typing.Iterable[str] z from typing import Iterable, Dict K = Dict[str, str] L = Dict[int, int] KK = Iterable[str] LL = Iterable[str] z from typing import Generic, TypeVar _T = TypeVar("_T") class _Spam(Generic[_T]): def foo(self) -> None: ... IntFood = _Spam[int] z from typing import Generic, TypeVar _T = TypeVar("_T") class _Bacon(Generic[_T]): def foo(self, arg): pass IntFood = _Bacon[int] z IntFood.foozStrList = list[str]zStrList = ['foo', 'bar']StrListz import collections.abc from typing import Callable N = Callable[[str], bool] O = collections.abc.Callable[[int], str] P = Callable[[str], bool] z from typing import Callable 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 from typing import Match M = Match[str] zk class Baz: def fizz(self) -> None: ... BazAlias = Baz z class Baz: def fizz(self): pass BazAlias = Baz Baz.__name__ = Baz.__qualname__ = Baz.__module__ = "New" z class FooBar: __module__: None # type: ignore def fizz(self) -> None: ... FooBarAlias = FooBar z class FooBar: def fizz(self): pass FooBarAlias = FooBar FooBar.__module__ = None rp aq import collections.abc import re from typing import Callable, Dict, Match, Iterable, Tuple, Union Q = Dict[str, str] R = dict[int, int] S = Tuple[int, int] T = tuple[str, str] U = int | str V = Union[int, str] W = Callable[[str], bool] Z = collections.abc.Callable[[str], bool] QQ = Iterable[str] RR = collections.abc.Iterable[str] MM = Match[str] MMM = re.Match[str] a from collections.abc import Callable, Iterable from re import Match Q = dict[str, str] R = dict[int, int] S = tuple[int, int] T = tuple[str, str] U = int | str V = int | str W = Callable[[str], bool] Z = Callable[[str], bool] QQ = Iterable[str] RR = Iterable[str] MM = Match[str] MMM = Match[str] rtrfrrrtest_type_aliass        zStubtestUnit.test_type_aliascctddddVdS)Nz import enum class X(enum.Enum): a: int b: str c: str z import enum class X(enum.Enum): a = 1 b = "asdf" c = 2 zX.cr;rerfrrr test_enum  zStubtestUnit.test_enumcctddddVdS)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 r;rerfrrrtest_decorators  zStubtestUnit.test_decoratorccr)NzZ: intz+ __all__ = [] Z = 5r;rerfrrrtest_all_at_runtime_not_stubs  z)StubtestUnit.test_all_at_runtime_not_stubccr)Nz __all__ = ()r&__all__r;rerfrrrtest_all_in_stub_not_at_runtimesz,StubtestUnit.test_all_in_stub_not_at_runtimeccr)Nz@ __all__ = ['foo'] foo: str z> __all__ = [] foo = 'foo' r&r;rerfrrr,test_all_in_stub_different_to_all_at_runtimes  z9StubtestUnit.test_all_in_stub_different_to_all_at_runtimeccstddddVtddddVtddddVtd dd dVtdd ddVtdd d dVtddddVtddddVtddddVtddddVdS)Nzx = 5r&xr; def f(): ...r5z class X: ...Xz from typing import overload @overload def h(x: int): ... @overload def h(x: str): ... hz __all__ = []z__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,)rerfrrr test_missings2  zStubtestUnit.test_missingccs6tddddVtddddVtddddVdS)Nr&z import sysr; def g(): ...rz CONSTANT = 0CONSTANTrerfrrrtest_missing_no_runtime_allz(StubtestUnit.test_missing_no_runtime_allccs,tddtddVtddddVdS)Nz__all__: list[str]r&z.__all__r;z_f: intz def _f(): ..._f)r8r'rfrrrtest_non_public_1 s  zStubtestUnit.test_non_public_1ccs6tddddVtddddVtddd dVdS) Nz__all__: list[str] = ['f']z__all__ = ['f']r;zf: intrr5zg: intrrrerfrrrtest_non_public_2rzStubtestUnit.test_non_public_2ccsTtddddVtddddVtdd ddVtjd kr(td d ddVdSdS) Nz:class A: def __init__(self, a: int, b: int) -> None: ...z*class A: def __init__(self, a, bx): passz A.__init__r;z:class B: def __call__(self, c: int, d: int) -> None: ...z*class B: def __call__(self, c, dx): passz B.__call__zXclass C: def __init_subclass__( cls, e: int = ..., **kwargs: int ) -> None: ... z:class C: def __init_subclass__(cls, e=1, **kwargs): pass)rp z>class D: def __class_getitem__(cls, type: type) -> type: ...z0class D: def __class_getitem__(cls, type): ...rtrfrrr test_dunderss.  zStubtestUnit.test_dundersccs&tddddVtddddVdS)Nzclass CanBeSubclassed: ...r;zCclass CannotBeSubclassed: def __init_subclass__(cls) -> None: ...zGclass CannotBeSubclassed: def __init_subclass__(cls): raise TypeErrorCannotBeSubclassedrerfrrrtest_not_subclassable3s z"StubtestUnit.test_not_subclassableccr)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_badr;rerfrrrtest_name_mangling>s  zStubtestUnit.test_name_manglingcc&tddddVtddddVdS)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.foor;z& class X: ... zN class X: def __init__(self, x): pass z X.__init__rerfrrrtest_mroNs zStubtestUnit.test_mroccr)Naz from typing_extensions import Literal import enum class Color(enum.Enum): RED: int NUM: Literal[1] CHAR: Literal['a'] FLAG: Literal[True] NON: Literal[None] BYT1: Literal[b'abc'] BYT2: Literal[b'\x90'] ENUM: Literal[Color.RED] a import enum class Color(enum.Enum): RED = 3 NUM = 1 CHAR = 'a' NON = None FLAG = True BYT1 = b"abc" BYT2 = b'\x90' ENUM = Color.RED r;rerfrrrtest_good_literalns  zStubtestUnit.test_good_literalccstdddVtddddVtddd dVtd d d dVtd dddVtddddVtddddVtddddVtddddVdS)Nz%from typing_extensions import Literalr&zINT_FLOAT_MISMATCH: Literal[1]zINT_FLOAT_MISMATCH = 1.0INT_FLOAT_MISMATCHr;zWRONG_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_2rerfrrrtest_bad_literalsD zStubtestUnit.test_bad_literalccr)NzL b1: bool b2: bool b3: bool zF b1 = 0 b2 = 1 b3 = 2 b3r;z from typing_extensions import TypedDict class _Options(TypedDict): a: str b: int opt1: _Options opt2: _Options opt3: _Options z opt1 = {"a": "3.", "b": 14} opt2 = {"some": "stuff"} # false negative opt3 = 0 opt3rerfrrrtest_special_subtypes   z!StubtestUnit.test_special_subtypeccstddddVdS)Nz from typing_extensions import Protocol class X(Protocol): bar: int def foo(self, x: int, y: bytes = ...) -> str: ... r;rerfrrr test_protocolrzStubtestUnit.test_protocolccsdtddddVtddddVtddddVtjdkr0tddddVtd d ddVdSdS) Nzfrom typing import TypeVarr;zA = TypeVar('A')zB = TypeVar('B')zB = 5rrzfrom typing import ParamSpeczC = ParamSpec('C')rtrfrrr test_type_vars zStubtestUnit.test_type_varccFtddddVtddddVtddddVtddddVdS) Nfrom abc import abstractmethodr;zO class A1: def some(self) -> None: ... zo class A1: @abstractmethod def some(self) -> None: ... zA1.somezo class A2: @abstractmethod def some(self) -> None: ... zo class A3: @abstractmethod def some(self) -> None: ... zO class A3: def some(self) -> None: ... rerfrrrtest_abstract_methodss*  z"StubtestUnit.test_abstract_methodsccr) Nrr;zO class AP1: def some(self) -> int: ... z class AP1: @property @abstractmethod def some(self) -> int: ... zAP1.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: ... rerfrrrtest_abstract_properties(s*  z%StubtestUnit.test_abstract_propertiesN)r rd)%r>r?r@rbrgrjrlrvr|rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrcs    ( ! " @  B 7 g ? T      !        ! # "   -rcscCstdd|S)Nz\x1b.*?mr&)resub)rrrrremove_color_code]src@szeZdZdddZdddZdddZdd d Zdd d Zdd dZdddZ dddZ dddZ dddZ dddZ dS)StubtestMiscUnitr rFcCsdtddgd}dtdtdtd}t||ksJtdddgd}d t}t||ks0JdS) Nrmzdef bad(num, text): passrTerror: zi.bad is inconsistent, stub argument "number" differs from runtime argument "num" Stub: at line 1 in file zO.pyi def (number: builtins.int, text: builtins.str) Runtime: at line 1 in file z6.py def (num, text) Found 1 error (checked 1 module) z --concisezS{}.bad is inconsistent, stub argument "number" differs from runtime argument "num" )r7r'rrX)r<r6expectedrrr test_outputbs*zStubtestMiscUnit.test_outputcCsXtdddgd}|dksJtdddgd}|dksJtddd gd}|dks*JdS) Nr&z__all__ = ['f'] def f(): passz--ignore-missing-stubrT%Success: no issues found in 1 module z def f(): passzdef f(__a): ...zdef f(a): passz--ignore-positional-only)r7r<r6rrrtest_ignore_flags}s  z"StubtestMiscUnit.test_ignore_flagsc Csbtjddd}z||tdWdn1swYtddd|jgd}|d ks2Jtd d d|jgd}|d td ksFJtd d d|jd gd}|d ksWJt|jdd}|td|d|dWdn1s{wYttd dtd dd|jdgd}|dtdksJWt |jdSt |jw)Nzw+F)modedeletez.bad # comment # commentrmzdef bad(asdf, text): passz --allowlistrTrr&znote: unused allowlist entry z&.bad Found 1 error (checked 1 module) z--ignore-unused-allowlist)rz.b.* z(unused_missing)? z unused.* z def good() -> None: ... def bad(number: int) -> None: ... def also_bad(number: int) -> None: ... rJz def good(): pass def bad(asdf): pass def also_bad(asdf): pass rSz¬e: unused allowlist entry unused.* z .also_bad ) rNamedTemporaryFiler)r'r7namer(rKrLrMr unlink)r< allowlistr6r5rrrtest_allowlistsZ          zStubtestMiscUnit.test_allowlistcCsLtddgd}t|dtksJtddgd}t|dtks$JdS)N+r&rTzVerror: not checking stubs due to failed mypy compile: {}.pyi:1: error: invalid syntax zdef f(): ... def f(): ...zherror: not checking stubs due to mypy build errors: {}.pyi:2: error: Name "f" already defined on line 1 )r7rrXr'rrrrtest_mypy_builds z StubtestMiscUnit.test_mypy_buildcCsXt}t|ttdgWdn1swYt|dks*JdS)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/rrrr0rrrrtest_missing_stubss   z#StubtestMiscUnit.test_missing_stubsc CsttRttdd }|dWdn1swYt}t|tt tgWdn1s=wYt | }|dksNJWddS1sYwYdS)Nr$r#za = 1r) rr'r(r)r,r-r.r/rrrr0)r<r5r6 output_strrrr test_only_pys    "zStubtestMiscUnit.test_only_pycCstjdd}d|vs Jd|vsJd|vsJd|vsJd|vs%Jd|vs+Jd|vs1Jd |vs7Jtjdd }d|vsDJd|vsJJd |vsPJdS) N)rpbuiltinsr zos.pathasynciographlib formatter contextvarszimportlib.metadatar)mypystubtestget_typeshed_stdlib_modules)r<stdlibrrr test_get_typeshed_stdlib_moduless          z1StubtestMiscUnit.test_get_typeshed_stdlib_modulescCs4dddd d }ttjjt|dksJdS)Nr)daintbrPrrErr rFc[sdSr:r)rrrPrrErrrr5sz*StubtestMiscUnit.test_signature..fz#def (a, b, *, c, d = ..., **kwargs)) rrrrrPrrrrErr rF)r rr Signaturefrom_inspect_signatureinspect signature)r<r5rrrtest_signatures zStubtestMiscUnit.test_signaturecCs`d}d}dtd}t||gd}t|dtdtdks Jt||g|d }|d ks.JdS) Nz temp = 5 z*from decimal import Decimal temp: Decimal z[mypy] plugins=z*/test-data/unit/plugins/decimal_to_int.py rTrzL.temp variable differs from runtime type Literal[5] Stub: at line 2 in file zC.pyi _decimal.Decimal Runtime: 5 Found 1 error (checked 1 module) )rrrr!r)rr7rr')r<rrr!r6rrrtest_config_files z!StubtestMiscUnit.test_config_filecCsVt}t|ttgWdn1swYt|dks)JdS)Nzerror: no modules to check rrrrrtest_no_moduless  z StubtestMiscUnit.test_no_modulescCsZt}t|ttddgWdn1swYt|dks+JdS)Nz--check-typeshed some_modulez?error: cannot pass both --check-typeshed and a list of modules rrrrrtest_module_and_typesheds   z)StubtestMiscUnit.test_module_and_typeshedN)r rF)r>r?r@rrrrrrrrrrrrrrrras    =  r)r r r r r:) rr rr rr r!r"r r )rArBr rC)rr r r )! __future__rr.rr,r rrrrKunittesttypingrrr mypy.stubtestrrrmypy.test.datarcontextmanagerrr'r+r*r7r8rbTestCasercrrrrrrsF   ""  $ 5