X-PhOZddlmZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl mZmZddlZddlmZmZddlmZejd%d Zd Zd ZdZdZ d&d'dZ d&d(dZGddZd)dZGdd e j Z!d*d"Z"Gd#d$e j Z#dS)+) annotationsN)Iterator)AnyCallable) parse_options test_stubs)root_dirmod_namestrreturn Iterator[str]c#Ktj}tj}t j5} tj|tjd|kr tjd||V|t_|tj vr tj |=tj|nR#|t_|tj vr tj |=tj|wxYw ddddS#1swxYwYdSNr) osgetcwdsyspathcopytempfileTemporaryDirectorychdirinsertmodules)r currentcurrent_syspathtmps V/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/mypy/test/teststubtest.py use_tmp_dirrsUikkGhmmooO  $ & & #  HSMMMx{c!!3'''III&++--CH3;&&K) HW     '++--CH3;&&K) HW                       s-E AC%AE%AD44EE  E  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__ stubruntimeoptions list[str] config_file str | Nonetuple[str, str]c tt5}tdd5}|tdddn #1swxYwYtdd5}|t dddn #1swxYwYtdd5}|t dddn #1swxYwYttdd5}||dddn #1swxYwYttdd5}||dddn #1swxYwY|rTttdd5}||dddn #1swxYwY|dtdgz}tj}tj}tj |5tj |5tttg|zd dddn #1swxYwYdddn #1swxYwYdddn #1swxYwYt|t"j|t"jzd |t"jzd }t|t"j|t"jzd |t"jzd } || fS) Nz builtins.pyiwz typing.pyizenum.pyiz.pyi.pyz _config.iniz--mypy-config-fileT)use_builtins_fixtures)rTEST_MODULE_NAMEopenwritestubtest_builtins_stubstubtest_typing_stubstubtest_enum_stubioStringIO contextlibredirect_stdoutredirect_stderrrrremove_color_codegetvaluereplacerrrealpathsep) r r!r"r$tmp_dirfoutputouterrfiltered_outputfiltered_outerrs rrun_stubtest_with_stderrrBsW % & &`' .# & & ,! GG* + + + , , , , , , , , , , , , , , , , $ $ * GG( ) ) ) * * * * * * * * * * * * * * * *c " " (a GG& ' ' ' ( ( ( ( ( ( ( ( ( ( ( ( ( ( ( %+++S 1 1 Q GGDMMM                %***C 0 0 A GGG                    Y)666<< % $$$ % % % % % % % % % % % % % % %!5:J7W7W7W XXG  ' / / ` `1KF1S1S ` ` }&6%7'%ABBZ^ _ _ _ _ ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` ` `#```````````````&( !!'**RV3R 8 826AQSU9V9VO ( !!'**RV3R 8 826AQSU9V9VO O ++s1I-A  I- A I-A I-(B I-B I-B I-*C I-C I-C I-4D I-D I-D I-9E I-E I-"E #I-F" I-"F& &I-)F& *A I-6I (H?3 I?I II I I-I I-I I--I14I1c2t||||dSrrBr r!r"r$s r run_stubtestrFs $D'7K H H KKceZdZd dZd S) Caser r r!errorr%r Nonec0||_||_||_dSNr r!rJ)selfr r!rJs r__init__z Case.__init__s   rGN)r r r!r rJr%r rK)__name__ __module__ __qualname__rPrGrrIrIs(rGrIfnCallable[..., Iterator[Case]]Callable[..., None]cdfd }|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 rKct|i|}t}|D]~}|j |j}|dkrt}n)|tds td|}||vsJd|||tdd|Ddd|Ddg}t| }||kr\tdd |Ddd |Dg}||ks J|dSdS) Nr+.z_collect_cases merges cases into a single stubtest invocation; we already expect an error for {}z c3nK|]0}tj|jdV1dS Ntextwrapdedentr lstrip.0cs r z.collect_cases..test..s:QQaX_QV]]4-@-@AAQQQQQQrGc3nK|]0}tj|jdV1dSr^rarbr!rcrds rrgz.collect_cases..test..s<WWA 0@0@0F0F G GWWWWWWrG--generate-allowlistr r!r"c3nK|]0}tj|jdV1dSr^r`rds rrgz.collect_cases..test..s: U U!t1D1D!E!E U U U U U UrGc3nK|]0}tj|jdV1dSr^rirds rrgz.collect_cases..test..s=#[#[PQHOAI4D4DT4J4J$K$K#[#[#[#[#[#[rG) listsetrJr, startswithformataddrFjoin splitlines) rYrZcasesexpected_errorsrfexpected_errorr> actual_errorsrUs rtestzcollect_cases..testsRR((())%% 0 0AwWN##!1#..2B/E/E/EFF H$4!G!G~!G!G!888))/)?)?988    / / / /QQ5QQQQQKKWWQVWWWWW+,    F--//00 O + +![[ U Uu U U UUU #[#[UZ#[#[#[[[F !O333V333 , + 43rG)rYrrZrr rKrT)rUrys` r collect_casesrzs(<<<<<<> KrGceZdZed/dZed/dZed/dZed/dZed/dZed/dZ ed/d Z ed/d Z ed/d Z ed/d Z ed/d Zed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/dZed/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-Z.d.S)0 StubtestUnitr Iterator[Case]c#ZKtdddVtdddVdS)Nz*def f(number: int, text: str) -> None: ...zdef f(number, text): passrNzc class X: def f(self, number: int, text: str) -> None: ... zR class X: def f(self, number, text): pass rIrOs rtest_basic_goodzStubtestUnit.test_basic_goodsl=/          rGc#KtdddVtdddVtdd d VdS) Nz!def mistyped_class() -> None: ...zclass mistyped_class: passmistyped_classrNzclass 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_typess40"      )3LTa      #    rGc#KtdddVtdddVtdddVtd d dVdS) Nzdef bar() -> int: ...zasync def bar(): return 5barrNzasync def foo() -> int: ...zdef foo(): return 5zdef baz() -> int: ...zdef baz(): return 5zasync def bingo() -> int: ...zasync def bingo(): return 5rrs rtest_coroutineszStubtestUnit.test_coroutines%s/9T\abbbbbb5?T\`aaaaaa/9NVZ[[[[[[0:W_c        rGc#JKtdddVtdddVtddd Vtd d d Vtd ddVtdddVtdddVtdddVdS)N,def bad(number: int, text: str) -> None: ...z def bad(num, text) -> None: passbadrN7def 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/sz?6      J:      I:               =@      HH      ?D#        rGc#KtdddVtdddVtdd d Vtd d dVtd ddVtdddVdS)Nz7def runtime_kwonly(number: int, text: str) -> None: ...z)def runtime_kwonly(number, *, text): passruntime_kwonlyrNz7def 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_kindfsJ?"      J9      J:       J=      K@#      O>$        rGc#KtdddVtdddVtdddVtdd d Vtd d d VtdddVtdddVtdddVtdddVtdddVtdddVtd d!d"VdS)#Nz'def priv_pos_arg_missing() -> None: ...z(def priv_pos_arg_missing(_p1=None): passrNz"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(        rGc#KtdddVtdddVtddd Vtd d d Vtd ddVtdddVdS)Nz$def f1(text: str = ...) -> None: ...zdef f1(text = 'asdf'): passrNz$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        rGc#KtdddVtdddVtddd Vtd d d Vtd ddVtdddVtdddVtdddVtdddVtdddVtdddVtdd d!VdS)"Nz$def f1(text: str = 'x') -> None: ...zdef f1(text = 'y'): passf1rNz(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      )       $     rGc#KtdddVtdddVtddd Vtd d d Vtd ddVdS)Nz class Good: @classmethod def f(cls, number: int, text: str) -> None: ... zq class Good: @classmethod def f(cls, number, text): pass rNze 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_method=s                           rGc#KtdddVtdddVtddd Vtd d d Vtd ddVdS)Nzdef f1(a, *, b, c) -> None: ...zdef f1(a, *, b, c): passrNzdef 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_mismatch~s2 None: ...zdef f1(*args, **kwargs): passrNz$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): passrNz @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: ... rrs r test_overloadzStubtestUnit.test_overloads4     0     0     :     )     !      $ )     ,     .      %        rGc#"KtdddVtdddVtdddVtd d d Vtd d dVtdddVtdddVdS)Nzt class Good: @property def read_only_attr(self) -> int: ... zr class Good: @property def read_only_attr(self): return 1 rNzf 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_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() rrs r test_propertyzStubtestUnit.test_propertyNsl                 "     %            " %        rGc#KtdddVtdddVtdddVtd d d Vtd d dVtdddVdS)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 rNz 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:%      (           $    %      ( "!        rGc#KtdddVtdddVtdddVtd d dVtd d d VtdddVtdddVtdddVtdddVtdddVdS)Nzx1: intzx1 = 5rNzx2: 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 rrrs rtest_varzStubtestUnit.test_vars 84@@@@@@ 84@@@@@@-r488888"       %        +?tLLLLLLA=            %        rGc#KtdddVtdddVtddd Vtd d d Vtd d dVtdddVtdddVtdddVtdddVtdddVtdddVtdd dVtd!d"dVtd#d#dVtd$d%dVtd&d'dVtjd(krtd)d*dVdSdS)+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 rNz] 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] rIr version_infors rtest_type_aliaszStubtestUnit.test_type_aliasZs             -7GsSSSSSS 2S999999 Bd;;;;;;                             -7QYbcccccc                (2B$OOOOOO                w & &  ;      ' &rGc#JKtdddVtdddVtdddVtdd d Vtd d dVtd ddVtdddVtdddVdS)Nz import enumrNz{ 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 = ... )r!r rJz 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 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 rrs r test_enumzStubtestUnit.test_enums }DIIIIII                                #      &        %        rGc#2KtdddVdS)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 rNrrs rtest_decoratorzStubtestUnit.test_decorators@      rGc#2KtdddVdS)NzZ: intz+ __all__ = [] Z = 5__all__rNrrs rtest_all_at_runtime_not_stubz)StubtestUnit.test_all_at_runtime_not_stubs>         rGc#2KtdddVdS)Nz __all__ = ()r+rrNrrs rtest_all_in_stub_not_at_runtimez,StubtestUnit.test_all_in_stub_not_at_runtimes')DDDDDDDDrGc#2KtdddVdS)Nz@ __all__ = ['foo'] foo: str z> __all__ = [] foo = 'foo' rrNrrs r,test_all_in_stub_different_to_all_at_runtimez9StubtestUnit.test_all_in_stub_different_to_all_at_runtimesB     rGc#KtdddVtdddVtdddVtd dd Vtdd d Vtdd dVtdddVtdddVtdddVtdddVtdddVtdddVtddd VdS)!Nzx = 5r+xrN def f(): ...r=z 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_missings3777777#>>>>>>#>>>>>>    N)DDDDDD$=SIIIIII$ESQQQQQQHRT\_      ^      U      <7        20      20         rGc#KtdddVtdddVtdddVtddd Vtdd dVtdd dVdS) Nr+z import sysrN 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_allsL======N#>>>>>>N*EEEEEE$MU_``````$HPTUUUUUU$FdSSSSSSSSrGc#2KtdddVdS)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 rNrrs r$test_missing_no_runtime_all_terriblez1StubtestUnit.test_missing_no_runtime_all_terribles>         rGc#jKtddtdVtdddVdS)Nz__all__: list[str]r+z.__all__rNz_f: intz def _f(): ..._f)rIr,rs rtest_non_public_1zStubtestUnit.test_non_public_1s[%rOW[\\\\\\.DDDDDD.DDDDDDDDrGc#KtdddVtdddVtdd dVtd d dVdS) Nz:class A: def __init__(self, a: int, b: int) -> None: ...z*class A: def __init__(self, a, bx): passz A.__init__rNz: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%sNA      NA      % R    RG        rGc#ZKtdddVtdddVdS)Nzclass CanBeSubclassed: ...rNzCclass CannotBeSubclassed: def __init_subclass__(cls) -> None: ...zGclass CannotBeSubclassed: def __init_subclass__(cls): raise TypeErrorCannotBeSubclassedrrs rtest_not_subclassablez"StubtestUnit.test_not_subclassableAsf-7S[_      W^&        rGc#KtdddVtdddVtdddVtddd Vtd d dVtd d dVtdddVtdddVtdddVtdddVtdddVtdddVtd d!d"VdS)#Nz#from typing_extensions import finalzZ import functools from typing_extensions import final rNz9 @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_decoratorLs6                   24i5 5 5 5 5 5 n2$Y- - - - - - ^                                   @     rGc#KtdddVtdddVtdd d Vtd d d VdS)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_badrNz 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_manglingMs  #    =      "  ,      *    rGc#ZKtdddVtdddVdS)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.foorNz& class X: ... zN class X: def __init__(self, x): pass z X.__init__rrs rtest_mrozStubtestUnit.test_mrosr#      &    rGc#2KtdddVdS)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 rNrrs rtest_good_literalzStubtestUnit.test_good_literals@ ;        rGc#pKtdddVtdddVtddd Vtd d d Vtd ddVtdddVtdddVtdddVtdddVdS)Nzfrom typing import Literalr+zINT_FLOAT_MISMATCH: Literal[1]zINT_FLOAT_MISMATCH = 1.0INT_FLOAT_MISMATCHrNzWRONG_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_literalsj/T:::::1.&      /P[\\\\\\1;LT_``````82&      73&      /*      .*       /)         rGc#ZKtdddVtdddVdS)NzL b1: bool b2: bool b3: bool zF b1 = 0 b2 = 1 b3 = 2 b3rNz 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_subtypesr        #        rGc#KtdddVtdddVtdddVdS)Nz&from typing import Protocol, TypedDictrNz 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_objectss9<                rGc#KtdddVtdddVtdddVdS)Nfrom typing import NamedTuplerNg 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_tuple1s03                     rGc#KtdddVtdddVtdddVdS) Nrz"from collections import namedtuplerNrzO 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_collectionsUs08                rGc#KtdddVtdddVtdddVtjdkr*tdddVtd d dVdSdS) Nzfrom typing import TypeVarrNzA = TypeVar('A')zB = TypeVar('B')zB = 5rrzfrom typing import ParamSpeczC = ParamSpec('C')rrs r test_type_varzStubtestUnit.test_type_varss-7S[_      *4FdSSSSSS*G3GGGGGG  w & &36    0:NVZ[[[ [ [ [ [ [ ' &rGc#KtdddVtdddVtdddVtdddVtdd d Vtd d dVtd d dVtdddVtdddVtdddVtdddVtdddVdS)Nzclass Meta(type): ...rNz 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_matchs/9PX\]]]]]]MMMMMM03      1PX\]]]]]]7X\]]]]]]03      1PX\]]]]]]7X\]]]]]].8NVZ[[[[[[1OW[\\\\\\        rGc#KtdddVtdddVtdddVtdddVdS) Nzfrom abc import ABCMetarNz class A1(metaclass=ABCMeta): ...r(z class A2(metaclass=ABCMeta): ...r)z class A3(metaclass=ABCMeta): ...r*rrs rtest_metaclass_abcmetaz#StubtestUnit.test_metaclass_abcmetas1;T\`aaaaaa36      1S[_``````:O[_````````rGc#"KtdddVtdddVtdddVtdd d Vtd d dVtd ddVtdddVdS)Nz` from abc import abstractmethod from typing import overload from abc import abstractmethodrNzO 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_methodssj5                                "       $     rGc#KtdddVtdddVtdddVtd d dVtd d dVdS) Nr2rNzi 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                               rGc#JKtdddVtdddVtdddVtd d dVtd d d Vtd ddVtdddVtdddVdS)Nz,from typing import type_check_only, overloadzfrom typing import overloadrNzD @type_check_only class A1: ... r+zD @type_check_only class A2: ... r(r)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: ...func2rrs rtest_type_check_onlyz!StubtestUnit.test_type_check_onlyf s?1             $       ;>      1       0              /         rGN)r r})/rQrRrSrzrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr r rrrr"r$r&r.r0r3r5r:rTrGrr|r|s   ] $   ] *   ] 4 4 4 ]4 l   ] @E E E ]E N    ]  DH H H ]H T> > > ]> @   ] "@ @ @ ]@ Dx x x ]x te e e ]e Na a a ]a F= = = ]= ~|||]||s s s ]s j   ]    ] EEE]E   ] ; ; ; ]; zTTT]T   ] "HHH]H EEE]E    ] 6   ] ~ ~ ~ ]~ @8 8 8 ]8 t   ] >   ] B! ! ! ]! F    ]  D   ] >! ! ! ]! F   ] : \ \ \] \. . . ]. ` a a a] a_ _ _ ]_ B@ @ @ ]@ D? ? ? ]? ? ? rGr|sc.tjdd|S)Nz\x1b.*?mr+)resub)r;s rr7r7 s 6+r1 % %%rGceZdZddZddZddZddZddZddZdd Z dd Z dd Z dd Z dd Z ddZddZddZddZdS)StubtestMiscUnitr rKctddg}dtdtdtd}||ksJtdddg}d t}||ksJdS) Nrzdef bad(num, text): passrkerror: z_.bad is inconsistent, stub argument "number" differs from runtime argument "num" Stub: in file zG.pyi:1 def (number: builtins.int, text: builtins.str) Runtime: in file z8.py:1 def (num, text) Found 1 error (checked 1 module) z --concisezS{}.bad is inconsistent, stub argument "number" differs from runtime argument "num" )rFr,rq)rOr>expecteds r test_outputzStubtestMiscUnit.test_output s?.     1& 1 1- 1 1!1  1 1 1 !!!!?. M     KKQ6RbKcKc !!!!!!rGctdddg}|dksJtdddg}|dksJtddd g}|dksJdS) Nr+z__all__ = ['f'] def f(): passz--ignore-missing-stubrk%Success: no issues found in 1 module z def f(): passzdef f(__a): ...zdef f(a): passz--ignore-positional-onlyrFrOr>s rtest_ignore_flagsz"StubtestMiscUnit.test_ignore_flags s=H_G`   AAAAA2I`HabbbAAAAA", None: ... def bad(number: int) -> None: ... def also_bad(number: int) -> None: ... r_z def good(): pass def bad(asdf): pass def also_bad(asdf): pass rjz¬e: unused allowlist entry unused.* z .also_bad ) rNamedTemporaryFiler.r,rFnamer-rarbrcrunlink)rO allowlistr>r=s rtest_allowlistzStubtestMiscUnit.test_allowlist s/T%HHH 8 & Q Q#3 O O OPPP Q Q Q Q Q Q Q Q Q Q Q Q Q Q Q"C3& 7F EEEEE"r2 y~?^___F50@555 "& 8STF EEEEEin4000 &A+333444-... %%% & & & & & & & & & & & & & & & "_ ! ' 8NO'F*W:JWWW Iin % % % % %BIin % % % %sTGA GAG A BGAD& G&D**G-D*.A8GGctddg}|dtksJtddg}|dtksJdS)N+r+rkz`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] )rFrqr,rHs rtest_mypy_buildz StubtestMiscUnit.test_mypy_build s3B??? 0067G0H0H    #?UWXXX FFLfM]F^F^      rGc tj}tj|5t t dgdddn #1swxYwYt |dksJdS)N not_a_modulezferror: not_a_module failed to find stubs Stub: MISSING Runtime: N/A Found 1 error (checked 1 module) r2r3r4r5rrr7r8rHs rtest_missing_stubsz#StubtestMiscUnit.test_missing_stubs! s  ' / / 8 8 }n%566 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 !2!233 1      sAAActt5ttdd5}|ddddn #1swxYwYt j}t j|5tttgdddn #1swxYwYt| }|dksJ ddddS#1swxYwYdS)Nr)r(za = 1rF) rr,r-r.r2r3r4r5rrr7r8)rOr=r> output_strs r test_only_pyzStubtestMiscUnit.test_only_py+ s) * * J J)...44 !    ! ! ! ! ! ! ! ! ! ! ! ! ! ! ![]]F+F33 > >=*:);<<=== > > > > > > > > > > > > > > >*6??+<+<==J!IIIIII J J J J J J J J J J J J J J J J J JsXC3A C3A C3A *C3#B1% C31B5 5C38B5 9,C33C7:C7c tjdd}d|vsJd|vsJd|vsJd|vsJd|vsJd|vsJd|vsJd |vsJtjdd }d|vsJd|vsJd |vsJdS) N)rbuiltinsrzos.pathasynciographlib formatter contextvarszimportlib.metadatar)mypystubtestget_typeshed_stdlib_modules)rOstdlibs r test_get_typeshed_stdlib_modulesz1StubtestMiscUnit.test_get_typeshed_stdlib_modules7 s::4HHV####v~~~~F""""F""""''''f$$$$&&&&#61111::4IIV####&((((#v------rGcdddd }ttjjt j|d ksJdS)Nr)daintbrfrirZrr rKcdSrMrT)rjrlrfrirZs rr=z*StubtestMiscUnit.test_signature..fH s DrGz#def (a, b, *, c, d = ..., **kwargs)) rjrkrlrkrfrkrirkrZrr rK)r rcrd Signaturefrom_inspect_signatureinspect signature)rOr=s rtest_signaturezStubtestMiscUnit.test_signatureG sp23        '>>w?PQR?S?STT U U4 5 5 5 5 5 5rGctjtj}|Jt tjj|dksJdS)Nz*def (self, sep = ..., bytes_per_sep = ...))rcrdsafe_inspect_signaturebyteshexr rnro)rOsigs r3test_builtin_signature_with_unrepresentable_defaultzDStubtestMiscUnit.test_builtin_signature_with_unrepresentable_defaultP sam2259==  '>>sCC D D; < < < < < s rtest_config_filez!StubtestMiscUnit.test_config_fileX s=^^^^ 4"EEE 1& 1 1- 1 1 1    4"R]^^^AAAAAAArGc|d}d}t||g}|dksJd}t||g|}|dksJdS)Nrzztemp = SOME_GLOBAL_CONSTrkzerror: not checking stubs due to mypy build errors: test_module.pyi:1: error: Name "SOME_GLOBAL_CONST" is not defined [name-defined] z)[mypy] disable_error_code = name-defined rErFrG)rOr!r r>r$s rtest_config_file_error_codesz-StubtestMiscUnit.test_config_file_error_codese st)4"EEE b    D 4"R]^^^AAAAAAArGc^d}d}d}t||g|\}}|dksJ|dksJdS)Nrzz temp: int z-[mypy] disable_error_code = not-a-valid-name rErFz\test_module_config.ini: [mypy]: disable_error_code: Invalid error code(s): not-a-valid-name rD)rOr!r r$r>r?s r$test_config_file_error_codes_invalidz5StubtestMiscUnit.test_config_file_error_codes_invalidr slG 1w    AAAAA 8      rGcd}d}d}t||g|}|dksJd}|t5t||g|ddddS#1swxYwYdS)Nzx = 1 zx: int z*[mypy] enable_incomplete_feature = Unpack rEz\warning: Warning: Unpack is already enabled by default Success: no issues found in 1 module z4[mypy] enable_incomplete_feature = not-a-valid-name )rF assertRaises SystemExitr{s r)test_config_file_wrong_incomplete_featurez:StubtestMiscUnit.test_config_file_wrong_incomplete_feature sD 4"R]^^^ 5    O   z * * Z Z dGR[ Y Y Y Y Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z Z ZsAA#&A#c tj}tj|5t t gdddn #1swxYwYt |dksJdS)Nzerror: no modules to check rWrHs rtest_no_modulesz StubtestMiscUnit.test_no_modules s  ' / / * * }R(( ) ) ) * * * * * * * * * * * * * * * !2!2337UUUUUUUsAAActj}tj|5t t ddgdddn #1swxYwYt |dksJdS)Nz--check-typeshed some_modulez?error: cannot pass both --check-typeshed and a list of modules rWrHs rtest_module_and_typeshedz)StubtestMiscUnit.test_module_and_typeshed s  ' / / K K }&8-%HII J J J K K K K K K K K K K K K K K K !2!233 N      sAAAN)r rK)rQrRrSrDrIrQrTrXr[rgrrrxr|r~rrrrrTrGrr@r@ sY""""6 B B B B;&;&;&;&z          J J J J....          B B B B B B B B      Z Z Z ZVVVV       rGr@)r r r r rM) r r r!r r"r#r$r%r r&) r r r!r r"r#r$r%r r )rUrVr rW)r;r r r )$ __future__rr4rpr2rr=rrraunittestcollections.abcrtypingrr mypy.stubtestrcrrmypy.test.datar contextmanagerrr,r0r/r1rBrFrIrzTestCaser|r7r@rTrGrrs!"""""" $$$$$$ 33333333###### "!/b#JFLP , , , , ,HLPLLLLL ''''Tk" k" k" k" k" 8$k" k" k" \E&&&&l l l l l x(l l l l l rG