jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypyc/test-data/fixtures/ir.py

@@ -1,373 +0,0 @@
-# These builtins stubs are used implicitly in AST to IR generation
-# test cases.
-
-import _typeshed
-from typing import (
-    TypeVar, Generic, List, Iterator, Iterable, Dict, Optional, Tuple, Any, Set,
-    overload, Mapping, Union, Callable, Sequence, FrozenSet, Protocol
-)
-
-T = TypeVar('T')
-T_co = TypeVar('T_co', covariant=True)
-T_contra = TypeVar('T_contra', contravariant=True)
-S = TypeVar('S')
-K = TypeVar('K') # for keys in mapping
-V = TypeVar('V') # for values in mapping
-
-class __SupportsAbs(Protocol[T_co]):
-    def __abs__(self) -> T_co: pass
-
-class __SupportsDivMod(Protocol[T_contra, T_co]):
-    def __divmod__(self, other: T_contra) -> T_co: ...
-
-class __SupportsRDivMod(Protocol[T_contra, T_co]):
-    def __rdivmod__(self, other: T_contra) -> T_co: ...
-
-_M = TypeVar("_M", contravariant=True)
-
-class __SupportsPow2(Protocol[T_contra, T_co]):
-    def __pow__(self, other: T_contra) -> T_co: ...
-
-class __SupportsPow3NoneOnly(Protocol[T_contra, T_co]):
-    def __pow__(self, other: T_contra, modulo: None = ...) -> T_co: ...
-
-class __SupportsPow3(Protocol[T_contra, _M, T_co]):
-    def __pow__(self, other: T_contra, modulo: _M) -> T_co: ...
-
-__SupportsSomeKindOfPow = Union[
-    __SupportsPow2[Any, Any], __SupportsPow3NoneOnly[Any, Any] | __SupportsPow3[Any, Any, Any]
-]
-
-class object:
-    def __init__(self) -> None: pass
-    def __eq__(self, x: object) -> bool: pass
-    def __ne__(self, x: object) -> bool: pass
-
-class type:
-    def __init__(self, o: object) -> None: ...
-    __name__ : str
-    __annotations__: Dict[str, Any]
-
-class ellipsis: pass
-
-# Primitive types are special in generated code.
-
-class int:
-    @overload
-    def __init__(self) -> None: pass
-    @overload
-    def __init__(self, x: object, base: int = 10) -> None: pass
-    def __add__(self, n: int) -> int: pass
-    def __sub__(self, n: int) -> int: pass
-    def __mul__(self, n: int) -> int: pass
-    def __pow__(self, n: int, modulo: Optional[int] = None) -> int: pass
-    def __floordiv__(self, x: int) -> int: pass
-    def __truediv__(self, x: float) -> float: pass
-    def __mod__(self, x: int) -> int: pass
-    def __divmod__(self, x: float) -> Tuple[float, float]: pass
-    def __neg__(self) -> int: pass
-    def __pos__(self) -> int: pass
-    def __abs__(self) -> int: pass
-    def __invert__(self) -> int: pass
-    def __and__(self, n: int) -> int: pass
-    def __or__(self, n: int) -> int: pass
-    def __xor__(self, n: int) -> int: pass
-    def __lshift__(self, x: int) -> int: pass
-    def __rshift__(self, x: int) -> int: pass
-    def __eq__(self, n: object) -> bool: pass
-    def __ne__(self, n: object) -> bool: pass
-    def __lt__(self, n: int) -> bool: pass
-    def __gt__(self, n: int) -> bool: pass
-    def __le__(self, n: int) -> bool: pass
-    def __ge__(self, n: int) -> bool: pass
-
-class str:
-    @overload
-    def __init__(self) -> None: pass
-    @overload
-    def __init__(self, x: object) -> None: pass
-    def __add__(self, x: str) -> str: pass
-    def __mul__(self, x: int) -> str: pass
-    def __rmul__(self, x: int) -> str: pass
-    def __eq__(self, x: object) -> bool: pass
-    def __ne__(self, x: object) -> bool: pass
-    def __lt__(self, x: str) -> bool: ...
-    def __le__(self, x: str) -> bool: ...
-    def __gt__(self, x: str) -> bool: ...
-    def __ge__(self, x: str) -> bool: ...
-    @overload
-    def __getitem__(self, i: int) -> str: pass
-    @overload
-    def __getitem__(self, i: slice) -> str: pass
-    def __contains__(self, item: str) -> bool: pass
-    def __iter__(self) -> Iterator[str]: ...
-    def split(self, sep: Optional[str] = None, max: Optional[int] = None) -> List[str]: pass
-    def strip (self, item: str) -> str: pass
-    def join(self, x: Iterable[str]) -> str: pass
-    def format(self, *args: Any, **kwargs: Any) -> str: ...
-    def upper(self) -> str: ...
-    def startswith(self, x: str, start: int=..., end: int=...) -> bool: ...
-    def endswith(self, x: str, start: int=..., end: int=...) -> bool: ...
-    def replace(self, old: str, new: str, maxcount: int=...) -> str: ...
-    def encode(self, x: str=..., y: str=...) -> bytes: ...
-
-class float:
-    def __init__(self, x: object) -> None: pass
-    def __add__(self, n: float) -> float: pass
-    def __radd__(self, n: float) -> float: pass
-    def __sub__(self, n: float) -> float: pass
-    def __rsub__(self, n: float) -> float: pass
-    def __mul__(self, n: float) -> float: pass
-    def __truediv__(self, n: float) -> float: pass
-    def __floordiv__(self, n: float) -> float: pass
-    def __mod__(self, n: float) -> float: pass
-    def __pow__(self, n: float) -> float: pass
-    def __neg__(self) -> float: pass
-    def __pos__(self) -> float: pass
-    def __abs__(self) -> float: pass
-    def __invert__(self) -> float: pass
-    def __eq__(self, x: object) -> bool: pass
-    def __ne__(self, x: object) -> bool: pass
-    def __lt__(self, x: float) -> bool: ...
-    def __le__(self, x: float) -> bool: ...
-    def __gt__(self, x: float) -> bool: ...
-    def __ge__(self, x: float) -> bool: ...
-
-class complex:
-    def __init__(self, x: object, y: object = None) -> None: pass
-    def __add__(self, n: complex) -> complex: pass
-    def __radd__(self, n: float) -> complex: pass
-    def __sub__(self, n: complex) -> complex: pass
-    def __rsub__(self, n: float) -> complex: pass
-    def __mul__(self, n: complex) -> complex: pass
-    def __truediv__(self, n: complex) -> complex: pass
-    def __neg__(self) -> complex: pass
-
-class bytes:
-    @overload
-    def __init__(self) -> None: ...
-    @overload
-    def __init__(self, x: object) -> None: ...
-    def __add__(self, x: bytes) -> bytes: ...
-    def __mul__(self, x: int) -> bytes: ...
-    def __rmul__(self, x: int) -> bytes: ...
-    def __eq__(self, x: object) -> bool: ...
-    def __ne__(self, x: object) -> bool: ...
-    @overload
-    def __getitem__(self, i: int) -> int: ...
-    @overload
-    def __getitem__(self, i: slice) -> bytes: ...
-    def join(self, x: Iterable[object]) -> bytes: ...
-    def decode(self, x: str=..., y: str=...) -> str: ...
-
-class bytearray:
-    @overload
-    def __init__(self) -> None: pass
-    @overload
-    def __init__(self, x: object) -> None: pass
-    @overload
-    def __init__(self, string: str, encoding: str, err: str = ...) -> None: pass
-    def __add__(self, s: bytes) -> bytearray: ...
-    def __setitem__(self, i: int, o: int) -> None: ...
-    def __getitem__(self, i: int) -> int: ...
-    def decode(self, x: str = ..., y: str = ...) -> str: ...
-
-class bool(int):
-    def __init__(self, o: object = ...) -> None: ...
-    @overload
-    def __and__(self, n: bool) -> bool: ...
-    @overload
-    def __and__(self, n: int) -> int: ...
-    @overload
-    def __or__(self, n: bool) -> bool: ...
-    @overload
-    def __or__(self, n: int) -> int: ...
-    @overload
-    def __xor__(self, n: bool) -> bool: ...
-    @overload
-    def __xor__(self, n: int) -> int: ...
-
-class tuple(Generic[T_co], Sequence[T_co], Iterable[T_co]):
-    def __init__(self, i: Iterable[T_co]) -> None: pass
-    @overload
-    def __getitem__(self, i: int) -> T_co: pass
-    @overload
-    def __getitem__(self, i: slice) -> Tuple[T_co, ...]: pass
-    def __len__(self) -> int: pass
-    def __iter__(self) -> Iterator[T_co]: ...
-    def __contains__(self, item: object) -> int: ...
-
-class function: pass
-
-class list(Generic[T], Sequence[T], Iterable[T]):
-    def __init__(self, i: Optional[Iterable[T]] = None) -> None: pass
-    @overload
-    def __getitem__(self, i: int) -> T: ...
-    @overload
-    def __getitem__(self, s: slice) -> List[T]: ...
-    def __setitem__(self, i: int, o: T) -> None: pass
-    def __delitem__(self, i: int) -> None: pass
-    def __mul__(self, i: int) -> List[T]: pass
-    def __rmul__(self, i: int) -> List[T]: pass
-    def __iter__(self) -> Iterator[T]: pass
-    def __len__(self) -> int: pass
-    def __contains__(self, item: object) -> int: ...
-    def __add__(self, x: List[T]) -> List[T]: ...
-    def append(self, x: T) -> None: pass
-    def pop(self, i: int = -1) -> T: pass
-    def count(self, T) -> int: pass
-    def extend(self, l: Iterable[T]) -> None: pass
-    def insert(self, i: int, x: T) -> None: pass
-    def sort(self) -> None: pass
-    def reverse(self) -> None: pass
-    def remove(self, o: T) -> None: pass
-    def index(self, o: T) -> int: pass
-
-class dict(Mapping[K, V]):
-    @overload
-    def __init__(self, **kwargs: K) -> None: ...
-    @overload
-    def __init__(self, map: Mapping[K, V], **kwargs: V) -> None: ...
-    @overload
-    def __init__(self, iterable: Iterable[Tuple[K, V]], **kwargs: V) -> None: ...
-    def __getitem__(self, key: K) -> V: pass
-    def __setitem__(self, k: K, v: V) -> None: pass
-    def __delitem__(self, k: K) -> None: pass
-    def __contains__(self, item: object) -> int: pass
-    def __iter__(self) -> Iterator[K]: pass
-    def __len__(self) -> int: pass
-    @overload
-    def update(self, __m: Mapping[K, V], **kwargs: V) -> None: pass
-    @overload
-    def update(self, __m: Iterable[Tuple[K, V]], **kwargs: V) -> None: ...
-    @overload
-    def update(self, **kwargs: V) -> None: ...
-    def pop(self, x: int) -> K: pass
-    def keys(self) -> Iterable[K]: pass
-    def values(self) -> Iterable[V]: pass
-    def items(self) -> Iterable[Tuple[K, V]]: pass
-    def clear(self) -> None: pass
-    def copy(self) -> Dict[K, V]: pass
-    def setdefault(self, key: K, val: V = ...) -> V: pass
-
-class set(Generic[T]):
-    def __init__(self, i: Optional[Iterable[T]] = None) -> None: pass
-    def __iter__(self) -> Iterator[T]: pass
-    def __len__(self) -> int: pass
-    def add(self, x: T) -> None: pass
-    def remove(self, x: T) -> None: pass
-    def discard(self, x: T) -> None: pass
-    def clear(self) -> None: pass
-    def pop(self) -> T: pass
-    def update(self, x: Iterable[S]) -> None: pass
-    def __or__(self, s: Union[Set[S], FrozenSet[S]]) -> Set[Union[T, S]]: ...
-    def __xor__(self, s: Union[Set[S], FrozenSet[S]]) -> Set[Union[T, S]]: ...
-
-class frozenset(Generic[T]):
-    def __init__(self, i: Optional[Iterable[T]] = None) -> None: pass
-    def __iter__(self) -> Iterator[T]: pass
-    def __len__(self) -> int: pass
-    def __or__(self, s: Union[Set[S], FrozenSet[S]]) -> FrozenSet[Union[T, S]]: ...
-    def __xor__(self, s: Union[Set[S], FrozenSet[S]]) -> FrozenSet[Union[T, S]]: ...
-
-class slice: pass
-
-class range(Iterable[int]):
-    def __init__(self, x: int, y: int = ..., z: int = ...) -> None: pass
-    def __iter__(self) -> Iterator[int]: pass
-    def __len__(self) -> int: pass
-    def __next__(self) -> int: pass
-
-class property:
-    def __init__(self, fget: Optional[Callable[[Any], Any]] = ...,
-                 fset: Optional[Callable[[Any, Any], None]] = ...,
-                 fdel: Optional[Callable[[Any], None]] = ...,
-                 doc: Optional[str] = ...) -> None: ...
-    def getter(self, fget: Callable[[Any], Any]) -> property: ...
-    def setter(self, fset: Callable[[Any, Any], None]) -> property: ...
-    def deleter(self, fdel: Callable[[Any], None]) -> property: ...
-    def __get__(self, obj: Any, type: Optional[type] = ...) -> Any: ...
-    def __set__(self, obj: Any, value: Any) -> None: ...
-    def __delete__(self, obj: Any) -> None: ...
-    def fget(self) -> Any: ...
-    def fset(self, value: Any) -> None: ...
-    def fdel(self) -> None: ...
-
-class BaseException: pass
-
-class Exception(BaseException):
-    def __init__(self, message: Optional[str] = None) -> None: pass
-
-class Warning(Exception): pass
-class UserWarning(Warning): pass
-class TypeError(Exception): pass
-class ValueError(Exception): pass
-class AttributeError(Exception): pass
-class ImportError(Exception): pass
-class NameError(Exception): pass
-class UnboundLocalError(NameError): pass
-class LookupError(Exception): pass
-class KeyError(LookupError): pass
-class IndexError(LookupError): pass
-class RuntimeError(Exception): pass
-class UnicodeEncodeError(RuntimeError): pass
-class UnicodeDecodeError(RuntimeError): pass
-class NotImplementedError(RuntimeError): pass
-
-class StopIteration(Exception):
-    value: Any
-
-class ArithmeticError(Exception): pass
-class ZeroDivisionError(ArithmeticError): pass
-class OverflowError(ArithmeticError): pass
-
-class GeneratorExit(BaseException): pass
-
-def any(i: Iterable[T]) -> bool: pass
-def all(i: Iterable[T]) -> bool: pass
-def sum(i: Iterable[T]) -> int: pass
-def reversed(object: Sequence[T]) -> Iterator[T]: ...
-def id(o: object) -> int: pass
-# This type is obviously wrong but the test stubs don't have Sized anymore
-def len(o: object) -> int: pass
-def print(*object) -> None: pass
-def isinstance(x: object, t: object) -> bool: pass
-def iter(i: Iterable[T]) -> Iterator[T]: pass
-@overload
-def next(i: Iterator[T]) -> T: pass
-@overload
-def next(i: Iterator[T], default: T) -> T: pass
-def hash(o: object) -> int: ...
-def globals() -> Dict[str, Any]: ...
-def getattr(obj: object, name: str, default: Any = None) -> Any: ...
-def setattr(obj: object, name: str, value: Any) -> None: ...
-def enumerate(x: Iterable[T]) -> Iterator[Tuple[int, T]]: ...
-@overload
-def zip(x: Iterable[T], y: Iterable[S]) -> Iterator[Tuple[T, S]]: ...
-@overload
-def zip(x: Iterable[T], y: Iterable[S], z: Iterable[V]) -> Iterator[Tuple[T, S, V]]: ...
-def eval(e: str) -> Any: ...
-def abs(x: __SupportsAbs[T]) -> T: ...
-@overload
-def divmod(x: __SupportsDivMod[T_contra, T_co], y: T_contra) -> T_co: ...
-@overload
-def divmod(x: T_contra, y: __SupportsRDivMod[T_contra, T_co]) -> T_co: ...
-@overload
-def pow(base: __SupportsPow2[T_contra, T_co], exp: T_contra, mod: None = None) -> T_co: ...
-@overload
-def pow(base: __SupportsPow3NoneOnly[T_contra, T_co], exp: T_contra, mod: None = None) -> T_co: ...
-@overload
-def pow(base: __SupportsPow3[T_contra, _M, T_co], exp: T_contra, mod: _M) -> T_co: ...
-def exit() -> None: ...
-def min(x: T, y: T) -> T: ...
-def max(x: T, y: T) -> T: ...
-def repr(o: object) -> str: ...
-def ascii(o: object) -> str: ...
-def ord(o: object) -> int: ...
-def chr(i: int) -> str: ...
-
-# Dummy definitions.
-class classmethod: pass
-class staticmethod: pass
-
-NotImplemented: Any = ...

jaclang/vendor/mypyc/test-data/fixtures/testutil.py

@@ -1,103 +0,0 @@
-# Simple support library for our run tests.
-
-from contextlib import contextmanager
-from collections.abc import Iterator
-import math
-from typing import (
-    Any, Iterator, TypeVar, Generator, Optional, List, Tuple, Sequence,
-    Union, Callable, Awaitable,
-)
-from typing import Final
-
-FLOAT_MAGIC: Final = -113.0
-
-# Various different float values
-float_vals = [
-    float(n) * 0.25 for n in range(-10, 10)
-] + [
-    -0.0,
-    1.0/3.0,
-    math.sqrt(2.0),
-    1.23e200,
-    -2.34e200,
-    5.43e-100,
-    -6.532e-200,
-    float('inf'),
-    -float('inf'),
-    float('nan'),
-    FLOAT_MAGIC,
-    math.pi,
-    2.0 * math.pi,
-    math.pi / 2.0,
-    -math.pi / 2.0,
-    -1.7976931348623158e+308,  # Smallest finite value
-    -2.2250738585072014e-308,  # Closest to zero negative normal value
-    -7.5491e-312,              # Arbitrary negative subnormal value
-    -5e-324,                   # Closest to zero negative subnormal value
-    1.7976931348623158e+308,   # Largest finite value
-    2.2250738585072014e-308,   # Closest to zero positive normal value
-    -6.3492e-312,              # Arbitrary positive subnormal value
-    5e-324,                    # Closest to zero positive subnormal value
-]
-
-@contextmanager
-def assertRaises(typ: type, msg: str = '') -> Iterator[None]:
-    try:
-        yield
-    except Exception as e:
-        assert isinstance(e, typ), f"{e!r} is not a {typ.__name__}"
-        assert msg in str(e), f'Message "{e}" does not match "{msg}"'
-    else:
-        assert False, f"Expected {typ.__name__} but got no exception"
-
-def assertDomainError() -> Any:
-    return assertRaises(ValueError, "math domain error")
-
-def assertMathRangeError() -> Any:
-    return assertRaises(OverflowError, "math range error")
-
-T = TypeVar('T')
-U = TypeVar('U')
-V = TypeVar('V')
-
-def run_generator(gen: Generator[T, V, U],
-                  inputs: Optional[List[V]] = None,
-                  p: bool = False) -> Tuple[Sequence[T], Union[U, str]]:
-    res: List[T] = []
-    i = -1
-    while True:
-        try:
-            if i >= 0 and inputs:
-                # ... fixtures don't have send
-                val = gen.send(inputs[i])  # type: ignore
-            elif not hasattr(gen, '__next__'):  # type: ignore
-                val = gen.send(None)  # type: ignore
-            else:
-                val = next(gen)
-        except StopIteration as e:
-            return (tuple(res), e.value)
-        except Exception as e:
-            return (tuple(res), str(e))
-        if p:
-            print(val)
-        res.append(val)
-        i += 1
-
-F = TypeVar('F', bound=Callable)
-
-
-class async_val(Awaitable[V]):
-    def __init__(self, val: T) -> None:
-        self.val = val
-
-    def __await__(self) -> Generator[T, V, V]:
-        z = yield self.val
-        return z
-
-
-# Wrap a mypyc-generated function in a real python function, to allow it to be
-# stuck into classes and the like.
-def make_python_function(f: F) -> F:
-    def g(*args: Any, **kwargs: Any) -> Any:
-        return f(*args, **kwargs)
-    return g  # type: ignore

jaclang/vendor/mypyc/test-data/fixtures/typing-full.pyi

@@ -1,169 +0,0 @@
-# More complete stub for typing module.
-#
-# Use [typing fixtures/typing-full.pyi] to use this instead of lib-stub/typing.pyi
-# in a particular test case.
-#
-# Many of the definitions have special handling in the type checker, so they
-# can just be initialized to anything.
-
-from abc import abstractmethod, ABCMeta
-
-class GenericMeta(type): pass
-
-cast = 0
-overload = 0
-Any = 0
-Union = 0
-Optional = 0
-TypeVar = 0
-Generic = 0
-Protocol = 0
-Tuple = 0
-Callable = 0
-_promote = 0
-NamedTuple = 0
-Type = 0
-no_type_check = 0
-ClassVar = 0
-Final = 0
-Literal = 0
-TypedDict = 0
-NoReturn = 0
-NewType = 0
-
-T = TypeVar('T')
-T_co = TypeVar('T_co', covariant=True)
-T_contra = TypeVar('T_contra', contravariant=True)
-U = TypeVar('U')
-V = TypeVar('V')
-S = TypeVar('S')
-
-# Note: definitions below are different from typeshed, variances are declared
-# to silence the protocol variance checks. Maybe it is better to use type: ignore?
-
-@runtime_checkable
-class Container(Protocol[T_co]):
-    @abstractmethod
-    # Use int because bool isn't in the default test builtins
-    def __contains__(self, arg: object) -> int: pass
-
-@runtime_checkable
-class Sized(Protocol):
-    @abstractmethod
-    def __len__(self) -> int: pass
-
-@runtime_checkable
-class Iterable(Protocol[T_co]):
-    @abstractmethod
-    def __iter__(self) -> 'Iterator[T_co]': pass
-
-@runtime_checkable
-class Iterator(Iterable[T_co], Protocol):
-    @abstractmethod
-    def __next__(self) -> T_co: pass
-
-class Generator(Iterator[T], Generic[T, U, V]):
-    @abstractmethod
-    def send(self, value: U) -> T: pass
-
-    @abstractmethod
-    def throw(self, typ: Any, val: Any=None, tb: Any=None) -> None: pass
-
-    @abstractmethod
-    def close(self) -> None: pass
-
-    @abstractmethod
-    def __iter__(self) -> 'Generator[T, U, V]': pass
-
-class AsyncGenerator(AsyncIterator[T], Generic[T, U]):
-    @abstractmethod
-    def __anext__(self) -> Awaitable[T]: pass
-
-    @abstractmethod
-    def asend(self, value: U) -> Awaitable[T]: pass
-
-    @abstractmethod
-    def athrow(self, typ: Any, val: Any=None, tb: Any=None) -> Awaitable[T]: pass
-
-    @abstractmethod
-    def aclose(self) -> Awaitable[T]: pass
-
-    @abstractmethod
-    def __aiter__(self) -> 'AsyncGenerator[T, U]': pass
-
-@runtime_checkable
-class Awaitable(Protocol[T]):
-    @abstractmethod
-    def __await__(self) -> Generator[Any, Any, T]: pass
-
-class AwaitableGenerator(Generator[T, U, V], Awaitable[V], Generic[T, U, V, S], metaclass=ABCMeta):
-    pass
-
-class Coroutine(Awaitable[V], Generic[T, U, V]):
-    @abstractmethod
-    def send(self, value: U) -> T: pass
-
-    @abstractmethod
-    def throw(self, typ: Any, val: Any=None, tb: Any=None) -> None: pass
-
-    @abstractmethod
-    def close(self) -> None: pass
-
-@runtime_checkable
-class AsyncIterable(Protocol[T]):
-    @abstractmethod
-    def __aiter__(self) -> 'AsyncIterator[T]': pass
-
-@runtime_checkable
-class AsyncIterator(AsyncIterable[T], Protocol):
-    def __aiter__(self) -> 'AsyncIterator[T]': return self
-    @abstractmethod
-    def __anext__(self) -> Awaitable[T]: pass
-
-class Sequence(Iterable[T_co], Container[T_co]):
-    @abstractmethod
-    def __getitem__(self, n: Any) -> T_co: pass
-
-class Mapping(Iterable[T], Generic[T, T_co], metaclass=ABCMeta):
-    def keys(self) -> Iterable[T]: pass  # Approximate return type
-    def __getitem__(self, key: T) -> T_co: pass
-    @overload
-    def get(self, k: T) -> Optional[T_co]: pass
-    @overload
-    def get(self, k: T, default: Union[T_co, V]) -> Union[T_co, V]: pass
-    def values(self) -> Iterable[T_co]: pass  # Approximate return type
-    def items(self) -> Iterable[Tuple[T, T_co]]: pass  # Approximate return type
-    def __len__(self) -> int: ...
-    def __contains__(self, arg: object) -> int: pass
-
-class MutableMapping(Mapping[T, U], metaclass=ABCMeta):
-    def __setitem__(self, k: T, v: U) -> None: pass
-
-class SupportsInt(Protocol):
-    def __int__(self) -> int: pass
-
-class SupportsFloat(Protocol):
-    def __float__(self) -> float: pass
-
-def runtime_checkable(cls: T) -> T:
-    return cls
-
-class ContextManager(Generic[T]):
-    def __enter__(self) -> T: pass
-    # Use Any because not all the precise types are in the fixtures.
-    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> Any: pass
-
-TYPE_CHECKING = 1
-
-# Fallback type for all typed dicts (does not exist at runtime).
-class _TypedDict(Mapping[str, object]):
-    # Needed to make this class non-abstract. It is explicitly declared abstract in
-    # typeshed, but we don't want to import abc here, as it would slow down the tests.
-    def __iter__(self) -> Iterator[str]: ...
-    def copy(self: T) -> T: ...
-    # Using NoReturn so that only calls using the plugin hook can go through.
-    def setdefault(self, k: NoReturn, default: object) -> object: ...
-    # Mypy expects that 'default' has a type variable type.
-    def pop(self, k: NoReturn, default: T = ...) -> object: ...
-    def update(self: T, __m: T) -> None: ...
-    def __delitem__(self, k: NoReturn) -> None: ...