superacli 1.1.6 → 1.1.8

package/ref-monty/crates/monty-typeshed/vendor/typeshed/stdlib/_typeshed/__init__.pyi

@@ -1,394 +0,0 @@
-# Utility types for typeshed
-#
-# See the README.md file in this directory for more information.
-
-import sys
-from collections.abc import Awaitable, Callable, Iterable, Iterator, Sequence, Set as AbstractSet, Sized
-from dataclasses import Field
-from os import PathLike
-from types import FrameType, TracebackType
-from typing import (
-    Any,
-    AnyStr,
-    ClassVar,
-    Final,
-    Generic,
-    Literal,
-    Protocol,
-    SupportsFloat,
-    SupportsIndex,
-    SupportsInt,
-    TypeVar,
-    final,
-    overload,
-)
-
-from typing_extensions import Buffer, LiteralString, Self as _Self, TypeAlias
-
-_KT = TypeVar('_KT')
-_KT_co = TypeVar('_KT_co', covariant=True)
-_KT_contra = TypeVar('_KT_contra', contravariant=True)
-_VT = TypeVar('_VT')
-_VT_co = TypeVar('_VT_co', covariant=True)
-_T = TypeVar('_T')
-_T_co = TypeVar('_T_co', covariant=True)
-_T_contra = TypeVar('_T_contra', contravariant=True)
-
-# Alternative to `typing_extensions.Self`, exclusively for use with `__new__`
-# in metaclasses:
-#     def __new__(cls: type[Self], ...) -> Self: ...
-# In other cases, use `typing_extensions.Self`.
-Self = TypeVar('Self')
-
-# covariant version of typing.AnyStr, useful for protocols
-AnyStr_co = TypeVar('AnyStr_co', str, bytes, covariant=True)
-
-# For partially known annotations. Usually, fields where type annotations
-# haven't been added are left unannotated, but in some situations this
-# isn't possible or a type is already partially known. In cases like these,
-# use Incomplete instead of Any as a marker. For example, use
-# "Incomplete | None" instead of "Any | None".
-Incomplete: TypeAlias = Any  # stable
-
-# To describe a function parameter that is unused and will work with anything.
-Unused: TypeAlias = object  # stable
-
-# Marker for return types that include None, but where forcing the user to
-# check for None can be detrimental. Sometimes called "the Any trick". See
-# https://typing.python.org/en/latest/guides/writing_stubs.html#the-any-trick
-# for more information.
-MaybeNone: TypeAlias = Any  # stable
-
-# Used to mark arguments that default to a sentinel value. This prevents
-# stubtest from complaining about the default value not matching.
-#
-# def foo(x: int | None = sentinel) -> None: ...
-#
-# In cases where the sentinel object is exported and can be used by user code,
-# a construct like this is better:
-#
-# _SentinelType = NewType("_SentinelType", object)  # does not exist at runtime
-# sentinel: Final[_SentinelType]
-# def foo(x: int | None | _SentinelType = ...) -> None: ...
-sentinel: Any  # stable
-
-# stable
-class IdentityFunction(Protocol):
-    def __call__(self, x: _T, /) -> _T: ...
-
-# stable
-class SupportsNext(Protocol[_T_co]):
-    def __next__(self) -> _T_co: ...
-
-# stable
-class SupportsAnext(Protocol[_T_co]):
-    def __anext__(self) -> Awaitable[_T_co]: ...
-
-class SupportsBool(Protocol):
-    def __bool__(self) -> bool: ...
-
-# Comparison protocols
-class SupportsDunderLT(Protocol[_T_contra]):
-    def __lt__(self, other: _T_contra, /) -> SupportsBool: ...
-
-class SupportsDunderGT(Protocol[_T_contra]):
-    def __gt__(self, other: _T_contra, /) -> SupportsBool: ...
-
-class SupportsDunderLE(Protocol[_T_contra]):
-    def __le__(self, other: _T_contra, /) -> SupportsBool: ...
-
-class SupportsDunderGE(Protocol[_T_contra]):
-    def __ge__(self, other: _T_contra, /) -> SupportsBool: ...
-
-class SupportsAllComparisons(
-    SupportsDunderLT[Any], SupportsDunderGT[Any], SupportsDunderLE[Any], SupportsDunderGE[Any], Protocol
-): ...
-
-SupportsRichComparison: TypeAlias = SupportsDunderLT[Any] | SupportsDunderGT[Any]
-SupportsRichComparisonT = TypeVar('SupportsRichComparisonT', bound=SupportsRichComparison)
-
-# Dunder protocols
-
-class SupportsAdd(Protocol[_T_contra, _T_co]):
-    def __add__(self, x: _T_contra, /) -> _T_co: ...
-
-class SupportsRAdd(Protocol[_T_contra, _T_co]):
-    def __radd__(self, x: _T_contra, /) -> _T_co: ...
-
-class SupportsSub(Protocol[_T_contra, _T_co]):
-    def __sub__(self, x: _T_contra, /) -> _T_co: ...
-
-class SupportsRSub(Protocol[_T_contra, _T_co]):
-    def __rsub__(self, x: _T_contra, /) -> _T_co: ...
-
-class SupportsMul(Protocol[_T_contra, _T_co]):
-    def __mul__(self, x: _T_contra, /) -> _T_co: ...
-
-class SupportsRMul(Protocol[_T_contra, _T_co]):
-    def __rmul__(self, x: _T_contra, /) -> _T_co: ...
-
-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: ...
-
-# This protocol is generic over the iterator type, while Iterable is
-# generic over the type that is iterated over.
-class SupportsIter(Protocol[_T_co]):
-    def __iter__(self) -> _T_co: ...
-
-# This protocol is generic over the iterator type, while AsyncIterable is
-# generic over the type that is iterated over.
-class SupportsAiter(Protocol[_T_co]):
-    def __aiter__(self) -> _T_co: ...
-
-class SupportsLen(Protocol):
-    def __len__(self) -> int: ...
-
-class SupportsLenAndGetItem(Protocol[_T_co]):
-    def __len__(self) -> int: ...
-    def __getitem__(self, k: int, /) -> _T_co: ...
-
-class SupportsTrunc(Protocol):
-    def __trunc__(self) -> int: ...
-
-# Mapping-like protocols
-
-# stable
-class SupportsItems(Protocol[_KT_co, _VT_co]):
-    def items(self) -> AbstractSet[tuple[_KT_co, _VT_co]]: ...
-
-# stable
-class SupportsKeysAndGetItem(Protocol[_KT, _VT_co]):
-    def keys(self) -> Iterable[_KT]: ...
-    def __getitem__(self, key: _KT, /) -> _VT_co: ...
-
-# stable
-class SupportsGetItem(Protocol[_KT_contra, _VT_co]):
-    def __getitem__(self, key: _KT_contra, /) -> _VT_co: ...
-
-# stable
-class SupportsContainsAndGetItem(Protocol[_KT_contra, _VT_co]):
-    def __contains__(self, x: Any, /) -> bool: ...
-    def __getitem__(self, key: _KT_contra, /) -> _VT_co: ...
-
-# stable
-class SupportsItemAccess(Protocol[_KT_contra, _VT]):
-    def __contains__(self, x: Any, /) -> bool: ...
-    def __getitem__(self, key: _KT_contra, /) -> _VT: ...
-    def __setitem__(self, key: _KT_contra, value: _VT, /) -> None: ...
-    def __delitem__(self, key: _KT_contra, /) -> None: ...
-
-StrPath: TypeAlias = str | PathLike[str]  # stable
-BytesPath: TypeAlias = bytes | PathLike[bytes]  # stable
-GenericPath: TypeAlias = AnyStr | PathLike[AnyStr]
-StrOrBytesPath: TypeAlias = str | bytes | PathLike[str] | PathLike[bytes]  # stable
-
-OpenTextModeUpdating: TypeAlias = Literal[
-    'r+',
-    '+r',
-    'rt+',
-    'r+t',
-    '+rt',
-    'tr+',
-    't+r',
-    '+tr',
-    'w+',
-    '+w',
-    'wt+',
-    'w+t',
-    '+wt',
-    'tw+',
-    't+w',
-    '+tw',
-    'a+',
-    '+a',
-    'at+',
-    'a+t',
-    '+at',
-    'ta+',
-    't+a',
-    '+ta',
-    'x+',
-    '+x',
-    'xt+',
-    'x+t',
-    '+xt',
-    'tx+',
-    't+x',
-    '+tx',
-]
-OpenTextModeWriting: TypeAlias = Literal['w', 'wt', 'tw', 'a', 'at', 'ta', 'x', 'xt', 'tx']
-OpenTextModeReading: TypeAlias = Literal['r', 'rt', 'tr', 'U', 'rU', 'Ur', 'rtU', 'rUt', 'Urt', 'trU', 'tUr', 'Utr']
-OpenTextMode: TypeAlias = OpenTextModeUpdating | OpenTextModeWriting | OpenTextModeReading
-OpenBinaryModeUpdating: TypeAlias = Literal[
-    'rb+',
-    'r+b',
-    '+rb',
-    'br+',
-    'b+r',
-    '+br',
-    'wb+',
-    'w+b',
-    '+wb',
-    'bw+',
-    'b+w',
-    '+bw',
-    'ab+',
-    'a+b',
-    '+ab',
-    'ba+',
-    'b+a',
-    '+ba',
-    'xb+',
-    'x+b',
-    '+xb',
-    'bx+',
-    'b+x',
-    '+bx',
-]
-OpenBinaryModeWriting: TypeAlias = Literal['wb', 'bw', 'ab', 'ba', 'xb', 'bx']
-OpenBinaryModeReading: TypeAlias = Literal['rb', 'br', 'rbU', 'rUb', 'Urb', 'brU', 'bUr', 'Ubr']
-OpenBinaryMode: TypeAlias = OpenBinaryModeUpdating | OpenBinaryModeReading | OpenBinaryModeWriting
-
-# stable
-class HasFileno(Protocol):
-    def fileno(self) -> int: ...
-
-FileDescriptor: TypeAlias = int  # stable
-FileDescriptorLike: TypeAlias = int | HasFileno  # stable
-FileDescriptorOrPath: TypeAlias = int | StrOrBytesPath
-
-# stable
-class SupportsRead(Protocol[_T_co]):
-    def read(self, length: int = ..., /) -> _T_co: ...
-
-# stable
-class SupportsReadline(Protocol[_T_co]):
-    def readline(self, length: int = ..., /) -> _T_co: ...
-
-# stable
-class SupportsNoArgReadline(Protocol[_T_co]):
-    def readline(self) -> _T_co: ...
-
-# stable
-class SupportsWrite(Protocol[_T_contra]):
-    def write(self, s: _T_contra, /) -> object: ...
-
-# stable
-class SupportsFlush(Protocol):
-    def flush(self) -> object: ...
-
-# Suitable for dictionary view objects
-class Viewable(Protocol[_T_co]):
-    def __len__(self) -> int: ...
-    def __iter__(self) -> Iterator[_T_co]: ...
-
-class SupportsGetItemViewable(Protocol[_KT, _VT_co]):
-    def __len__(self) -> int: ...
-    def __iter__(self) -> Iterator[_KT]: ...
-    def __getitem__(self, key: _KT, /) -> _VT_co: ...
-
-# Unfortunately PEP 688 does not allow us to distinguish read-only
-# from writable buffers. We use these aliases for readability for now.
-# Perhaps a future extension of the buffer protocol will allow us to
-# distinguish these cases in the type system.
-ReadOnlyBuffer: TypeAlias = Buffer  # stable
-# Anything that implements the read-write buffer interface.
-WriteableBuffer: TypeAlias = Buffer
-# Same as WriteableBuffer, but also includes read-only buffer types (like bytes).
-ReadableBuffer: TypeAlias = Buffer  # stable
-
-class SliceableBuffer(Buffer, Protocol):
-    def __getitem__(self, slice: slice[SupportsIndex | None], /) -> Sequence[int]: ...
-
-class IndexableBuffer(Buffer, Protocol):
-    def __getitem__(self, i: int, /) -> int: ...
-
-class SupportsGetItemBuffer(SliceableBuffer, IndexableBuffer, Protocol):
-    def __contains__(self, x: Any, /) -> bool: ...
-    @overload
-    def __getitem__(self, slice: slice[SupportsIndex | None], /) -> Sequence[int]: ...
-    @overload
-    def __getitem__(self, i: int, /) -> int: ...
-
-class SizedBuffer(Sized, Buffer, Protocol): ...
-
-ExcInfo: TypeAlias = tuple[type[BaseException], BaseException, TracebackType]
-OptExcInfo: TypeAlias = ExcInfo | tuple[None, None, None]
-
-# stable
-if sys.version_info >= (3, 10):
-    from types import NoneType as NoneType
-else:
-    # Used by type checkers for checks involving None (does not exist at runtime)
-    @final
-    class NoneType:
-        def __bool__(self) -> Literal[False]: ...
-
-# This is an internal CPython type that is like, but subtly different from, a NamedTuple
-# Subclasses of this type are found in multiple modules.
-# In typeshed, `structseq` is only ever used as a mixin in combination with a fixed-length `Tuple`
-# See discussion at #6546 & #6560
-# `structseq` classes are unsubclassable, so are all decorated with `@final`.
-class structseq(Generic[_T_co]):
-    n_fields: Final[int]
-    n_unnamed_fields: Final[int]
-    n_sequence_fields: Final[int]
-    # The first parameter will generally only take an iterable of a specific length.
-    # E.g. `os.uname_result` takes any iterable of length exactly 5.
-    #
-    # The second parameter will accept a dict of any kind without raising an exception,
-    # but only has any meaning if you supply it a dict where the keys are strings.
-    # https://github.com/python/typeshed/pull/6560#discussion_r767149830
-    def __new__(cls, sequence: Iterable[_T_co], dict: dict[str, Any] = ...) -> _Self: ...
-    if sys.version_info >= (3, 13):
-        def __replace__(self, **kwargs: Any) -> _Self: ...
-
-# Superset of typing.AnyStr that also includes LiteralString
-AnyOrLiteralStr = TypeVar('AnyOrLiteralStr', str, bytes, LiteralString)
-
-# Represents when str or LiteralStr is acceptable. Useful for string processing
-# APIs where literalness of return value depends on literalness of inputs
-StrOrLiteralStr = TypeVar('StrOrLiteralStr', LiteralString, str)
-
-# Objects suitable to be passed to sys.setprofile, threading.setprofile, and similar
-ProfileFunction: TypeAlias = Callable[[FrameType, str, Any], object]
-
-# Objects suitable to be passed to sys.settrace, threading.settrace, and similar
-TraceFunction: TypeAlias = Callable[[FrameType, str, Any], TraceFunction | None]
-
-# experimental
-# Might not work as expected for pyright, see
-#   https://github.com/python/typeshed/pull/9362
-#   https://github.com/microsoft/pyright/issues/4339
-class DataclassInstance(Protocol):
-    __dataclass_fields__: ClassVar[dict[str, Field[Any]]]
-
-# Anything that can be passed to the int/float constructors
-if sys.version_info >= (3, 14):
-    ConvertibleToInt: TypeAlias = str | ReadableBuffer | SupportsInt | SupportsIndex
-else:
-    ConvertibleToInt: TypeAlias = str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc
-ConvertibleToFloat: TypeAlias = str | ReadableBuffer | SupportsFloat | SupportsIndex
-
-# A few classes updated from Foo(str, Enum) to Foo(StrEnum). This is a convenience so these
-# can be accurate on all python versions without getting too wordy
-if sys.version_info >= (3, 11):
-    from enum import StrEnum as StrEnum
-else:
-    from enum import Enum
-
-    class StrEnum(str, Enum): ...
-
-# Objects that appear in annotations or in type expressions.
-# Similar to PEP 747's TypeForm but a little broader.
-AnnotationForm: TypeAlias = Any
-
-if sys.version_info >= (3, 14):
-    from annotationlib import Format
-
-    # These return annotations, which can be arbitrary objects
-    AnnotateFunc: TypeAlias = Callable[[Format], dict[str, AnnotationForm]]
-    EvaluateFunc: TypeAlias = Callable[[Format], AnnotationForm]

package/ref-monty/crates/monty-typeshed/vendor/typeshed/stdlib/asyncio.pyi

@@ -1,138 +0,0 @@
-from collections.abc import Awaitable, Generator
-from typing import Any, Literal, TypeAlias, TypeVar, overload
-
-_T = TypeVar('_T')
-_T1 = TypeVar('_T1')
-_T2 = TypeVar('_T2')
-_T3 = TypeVar('_T3')
-_T4 = TypeVar('_T4')
-_T5 = TypeVar('_T5')
-_T6 = TypeVar('_T6')
-
-class _Future(Awaitable[_T]):
-    """
-    Minimal copy of Future from _typeshed/stdlib/_asyncio.pyi
-    """
-    def __iter__(self) -> Generator[Any, None, _T]: ...
-    def __await__(self) -> Generator[Any, None, _T]: ...
-
-_FutureLike: TypeAlias = _Future[_T] | Awaitable[_T]
-
-def run(main: Awaitable[_T], *, debug: bool | None = None, loop_factory: Any = None) -> _T: ...
-@overload
-def gather(
-    coro_or_future1: _FutureLike[_T1], /, *, return_exceptions: Literal[False] = False
-) -> _Future[tuple[_T1]]: ...
-@overload
-def gather(
-    coro_or_future1: _FutureLike[_T1],
-    coro_or_future2: _FutureLike[_T2],
-    /,
-    *,
-    return_exceptions: Literal[False] = False,
-) -> _Future[tuple[_T1, _T2]]: ...
-@overload
-def gather(
-    coro_or_future1: _FutureLike[_T1],
-    coro_or_future2: _FutureLike[_T2],
-    coro_or_future3: _FutureLike[_T3],
-    /,
-    *,
-    return_exceptions: Literal[False] = False,
-) -> _Future[tuple[_T1, _T2, _T3]]: ...
-@overload
-def gather(
-    coro_or_future1: _FutureLike[_T1],
-    coro_or_future2: _FutureLike[_T2],
-    coro_or_future3: _FutureLike[_T3],
-    coro_or_future4: _FutureLike[_T4],
-    /,
-    *,
-    return_exceptions: Literal[False] = False,
-) -> _Future[tuple[_T1, _T2, _T3, _T4]]: ...
-@overload
-def gather(
-    coro_or_future1: _FutureLike[_T1],
-    coro_or_future2: _FutureLike[_T2],
-    coro_or_future3: _FutureLike[_T3],
-    coro_or_future4: _FutureLike[_T4],
-    coro_or_future5: _FutureLike[_T5],
-    /,
-    *,
-    return_exceptions: Literal[False] = False,
-) -> _Future[tuple[_T1, _T2, _T3, _T4, _T5]]: ...
-@overload
-def gather(
-    coro_or_future1: _FutureLike[_T1],
-    coro_or_future2: _FutureLike[_T2],
-    coro_or_future3: _FutureLike[_T3],
-    coro_or_future4: _FutureLike[_T4],
-    coro_or_future5: _FutureLike[_T5],
-    coro_or_future6: _FutureLike[_T6],
-    /,
-    *,
-    return_exceptions: Literal[False] = False,
-) -> _Future[tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...
-@overload
-def gather(*coros_or_futures: _FutureLike[_T], return_exceptions: Literal[False] = False) -> _Future[list[_T]]: ...
-@overload
-def gather(coro_or_future1: _FutureLike[_T1], /, *, return_exceptions: bool) -> _Future[tuple[_T1 | BaseException]]: ...
-@overload
-def gather(
-    coro_or_future1: _FutureLike[_T1], coro_or_future2: _FutureLike[_T2], /, *, return_exceptions: bool
-) -> _Future[tuple[_T1 | BaseException, _T2 | BaseException]]: ...
-@overload
-def gather(
-    coro_or_future1: _FutureLike[_T1],
-    coro_or_future2: _FutureLike[_T2],
-    coro_or_future3: _FutureLike[_T3],
-    /,
-    *,
-    return_exceptions: bool,
-) -> _Future[tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException]]: ...
-@overload
-def gather(
-    coro_or_future1: _FutureLike[_T1],
-    coro_or_future2: _FutureLike[_T2],
-    coro_or_future3: _FutureLike[_T3],
-    coro_or_future4: _FutureLike[_T4],
-    /,
-    *,
-    return_exceptions: bool,
-) -> _Future[tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException, _T4 | BaseException]]: ...
-@overload
-def gather(
-    coro_or_future1: _FutureLike[_T1],
-    coro_or_future2: _FutureLike[_T2],
-    coro_or_future3: _FutureLike[_T3],
-    coro_or_future4: _FutureLike[_T4],
-    coro_or_future5: _FutureLike[_T5],
-    /,
-    *,
-    return_exceptions: bool,
-) -> _Future[
-    tuple[_T1 | BaseException, _T2 | BaseException, _T3 | BaseException, _T4 | BaseException, _T5 | BaseException]
-]: ...
-@overload
-def gather(
-    coro_or_future1: _FutureLike[_T1],
-    coro_or_future2: _FutureLike[_T2],
-    coro_or_future3: _FutureLike[_T3],
-    coro_or_future4: _FutureLike[_T4],
-    coro_or_future5: _FutureLike[_T5],
-    coro_or_future6: _FutureLike[_T6],
-    /,
-    *,
-    return_exceptions: bool,
-) -> _Future[
-    tuple[
-        _T1 | BaseException,
-        _T2 | BaseException,
-        _T3 | BaseException,
-        _T4 | BaseException,
-        _T5 | BaseException,
-        _T6 | BaseException,
-    ]
-]: ...
-@overload
-def gather(*coros_or_futures: _FutureLike[_T], return_exceptions: bool) -> _Future[list[_T | BaseException]]: ...