superacli 1.1.4 → 1.1.6

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

@@ -0,0 +1,394 @@
+# 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

@@ -0,0 +1,138 @@
+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]]: ...