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

jaclang/vendor/mypy/typeshed/stdlib/_stat.pyi

@@ -1,103 +0,0 @@
-import sys
-from typing import Literal
-
-SF_APPEND: Literal[0x00040000]
-SF_ARCHIVED: Literal[0x00010000]
-SF_IMMUTABLE: Literal[0x00020000]
-SF_NOUNLINK: Literal[0x00100000]
-SF_SNAPSHOT: Literal[0x00200000]
-
-ST_MODE: Literal[0]
-ST_INO: Literal[1]
-ST_DEV: Literal[2]
-ST_NLINK: Literal[3]
-ST_UID: Literal[4]
-ST_GID: Literal[5]
-ST_SIZE: Literal[6]
-ST_ATIME: Literal[7]
-ST_MTIME: Literal[8]
-ST_CTIME: Literal[9]
-
-S_IFIFO: Literal[0o010000]
-S_IFLNK: Literal[0o120000]
-S_IFREG: Literal[0o100000]
-S_IFSOCK: Literal[0o140000]
-S_IFBLK: Literal[0o060000]
-S_IFCHR: Literal[0o020000]
-S_IFDIR: Literal[0o040000]
-
-# These are 0 on systems that don't support the specific kind of file.
-# Example: Linux doesn't support door files, so S_IFDOOR is 0 on linux.
-S_IFDOOR: int
-S_IFPORT: int
-S_IFWHT: int
-
-S_ISUID: Literal[0o4000]
-S_ISGID: Literal[0o2000]
-S_ISVTX: Literal[0o1000]
-
-S_IRWXU: Literal[0o0700]
-S_IRUSR: Literal[0o0400]
-S_IWUSR: Literal[0o0200]
-S_IXUSR: Literal[0o0100]
-
-S_IRWXG: Literal[0o0070]
-S_IRGRP: Literal[0o0040]
-S_IWGRP: Literal[0o0020]
-S_IXGRP: Literal[0o0010]
-
-S_IRWXO: Literal[0o0007]
-S_IROTH: Literal[0o0004]
-S_IWOTH: Literal[0o0002]
-S_IXOTH: Literal[0o0001]
-
-S_ENFMT: Literal[0o2000]
-S_IREAD: Literal[0o0400]
-S_IWRITE: Literal[0o0200]
-S_IEXEC: Literal[0o0100]
-
-UF_APPEND: Literal[0x00000004]
-UF_COMPRESSED: Literal[0x00000020]  # OS X 10.6+ only
-UF_HIDDEN: Literal[0x00008000]  # OX X 10.5+ only
-UF_IMMUTABLE: Literal[0x00000002]
-UF_NODUMP: Literal[0x00000001]
-UF_NOUNLINK: Literal[0x00000010]
-UF_OPAQUE: Literal[0x00000008]
-
-def S_IMODE(mode: int) -> int: ...
-def S_IFMT(mode: int) -> int: ...
-def S_ISBLK(mode: int) -> bool: ...
-def S_ISCHR(mode: int) -> bool: ...
-def S_ISDIR(mode: int) -> bool: ...
-def S_ISDOOR(mode: int) -> bool: ...
-def S_ISFIFO(mode: int) -> bool: ...
-def S_ISLNK(mode: int) -> bool: ...
-def S_ISPORT(mode: int) -> bool: ...
-def S_ISREG(mode: int) -> bool: ...
-def S_ISSOCK(mode: int) -> bool: ...
-def S_ISWHT(mode: int) -> bool: ...
-def filemode(mode: int) -> str: ...
-
-if sys.platform == "win32":
-    IO_REPARSE_TAG_SYMLINK: int
-    IO_REPARSE_TAG_MOUNT_POINT: int
-    IO_REPARSE_TAG_APPEXECLINK: int
-
-if sys.platform == "win32":
-    FILE_ATTRIBUTE_ARCHIVE: Literal[32]
-    FILE_ATTRIBUTE_COMPRESSED: Literal[2048]
-    FILE_ATTRIBUTE_DEVICE: Literal[64]
-    FILE_ATTRIBUTE_DIRECTORY: Literal[16]
-    FILE_ATTRIBUTE_ENCRYPTED: Literal[16384]
-    FILE_ATTRIBUTE_HIDDEN: Literal[2]
-    FILE_ATTRIBUTE_INTEGRITY_STREAM: Literal[32768]
-    FILE_ATTRIBUTE_NORMAL: Literal[128]
-    FILE_ATTRIBUTE_NOT_CONTENT_INDEXED: Literal[8192]
-    FILE_ATTRIBUTE_NO_SCRUB_DATA: Literal[131072]
-    FILE_ATTRIBUTE_OFFLINE: Literal[4096]
-    FILE_ATTRIBUTE_READONLY: Literal[1]
-    FILE_ATTRIBUTE_REPARSE_POINT: Literal[1024]
-    FILE_ATTRIBUTE_SPARSE_FILE: Literal[512]
-    FILE_ATTRIBUTE_SYSTEM: Literal[4]
-    FILE_ATTRIBUTE_TEMPORARY: Literal[256]
-    FILE_ATTRIBUTE_VIRTUAL: Literal[65536]

jaclang/vendor/mypy/typeshed/stdlib/_thread.pyi

@@ -1,59 +0,0 @@
-import sys
-from _typeshed import structseq
-from collections.abc import Callable
-from threading import Thread
-from types import TracebackType
-from typing import Any, Final, NoReturn, final, overload
-from typing_extensions import TypeVarTuple, Unpack
-
-_Ts = TypeVarTuple("_Ts")
-
-error = RuntimeError
-
-def _count() -> int: ...
-@final
-class LockType:
-    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
-    def release(self) -> None: ...
-    def locked(self) -> bool: ...
-    def __enter__(self) -> bool: ...
-    def __exit__(
-        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-    ) -> None: ...
-
-@overload
-def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]]) -> int: ...
-@overload
-def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any]) -> int: ...
-def interrupt_main() -> None: ...
-def exit() -> NoReturn: ...
-def allocate_lock() -> LockType: ...
-def get_ident() -> int: ...
-def stack_size(size: int = ...) -> int: ...
-
-TIMEOUT_MAX: float
-
-def get_native_id() -> int: ...  # only available on some platforms
-@final
-class _ExceptHookArgs(structseq[Any], tuple[type[BaseException], BaseException | None, TracebackType | None, Thread | None]):
-    if sys.version_info >= (3, 10):
-        __match_args__: Final = ("exc_type", "exc_value", "exc_traceback", "thread")
-
-    @property
-    def exc_type(self) -> type[BaseException]: ...
-    @property
-    def exc_value(self) -> BaseException | None: ...
-    @property
-    def exc_traceback(self) -> TracebackType | None: ...
-    @property
-    def thread(self) -> Thread | None: ...
-
-_excepthook: Callable[[_ExceptHookArgs], Any]
-
-if sys.version_info >= (3, 12):
-    def daemon_threads_allowed() -> bool: ...
-
-class _local:
-    def __getattribute__(self, name: str, /) -> Any: ...
-    def __setattr__(self, name: str, value: Any, /) -> None: ...
-    def __delattr__(self, name: str, /) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/_threading_local.pyi

@@ -1,17 +0,0 @@
-from typing import Any
-from typing_extensions import TypeAlias
-from weakref import ReferenceType
-
-__all__ = ["local"]
-_LocalDict: TypeAlias = dict[Any, Any]
-
-class _localimpl:
-    key: str
-    dicts: dict[int, tuple[ReferenceType[Any], _LocalDict]]
-    def get_dict(self) -> _LocalDict: ...
-    def create_dict(self) -> _LocalDict: ...
-
-class local:
-    def __getattribute__(self, name: str) -> Any: ...
-    def __setattr__(self, name: str, value: Any) -> None: ...
-    def __delattr__(self, name: str) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/_tkinter.pyi

@@ -1,121 +0,0 @@
-import sys
-from typing import Any, ClassVar, Literal, final
-
-# _tkinter is meant to be only used internally by tkinter, but some tkinter
-# functions e.g. return _tkinter.Tcl_Obj objects. Tcl_Obj represents a Tcl
-# object that hasn't been converted to a string.
-#
-# There are not many ways to get Tcl_Objs from tkinter, and I'm not sure if the
-# only existing ways are supposed to return Tcl_Objs as opposed to returning
-# strings. Here's one of these things that return Tcl_Objs:
-#
-#    >>> import tkinter
-#    >>> text = tkinter.Text()
-#    >>> text.tag_add('foo', '1.0', 'end')
-#    >>> text.tag_ranges('foo')
-#    (<textindex object: '1.0'>, <textindex object: '2.0'>)
-@final
-class Tcl_Obj:
-    @property
-    def string(self) -> str: ...
-    @property
-    def typename(self) -> str: ...
-    __hash__: ClassVar[None]  # type: ignore[assignment]
-    def __eq__(self, value, /): ...
-    def __ge__(self, value, /): ...
-    def __gt__(self, value, /): ...
-    def __le__(self, value, /): ...
-    def __lt__(self, value, /): ...
-    def __ne__(self, value, /): ...
-
-class TclError(Exception): ...
-
-# This class allows running Tcl code. Tkinter uses it internally a lot, and
-# it's often handy to drop a piece of Tcl code into a tkinter program. Example:
-#
-#    >>> import tkinter, _tkinter
-#    >>> tkapp = tkinter.Tk().tk
-#    >>> isinstance(tkapp, _tkinter.TkappType)
-#    True
-#    >>> tkapp.call('set', 'foo', (1,2,3))
-#    (1, 2, 3)
-#    >>> tkapp.eval('return $foo')
-#    '1 2 3'
-#    >>>
-#
-# call args can be pretty much anything. Also, call(some_tuple) is same as call(*some_tuple).
-#
-# eval always returns str because _tkinter_tkapp_eval_impl in _tkinter.c calls
-# Tkapp_UnicodeResult, and it returns a string when it succeeds.
-@final
-class TkappType:
-    # Please keep in sync with tkinter.Tk
-    def adderrorinfo(self, msg, /): ...
-    def call(self, command: Any, /, *args: Any) -> Any: ...
-    def createcommand(self, name, func, /): ...
-    if sys.platform != "win32":
-        def createfilehandler(self, file, mask, func, /): ...
-        def deletefilehandler(self, file, /): ...
-
-    def createtimerhandler(self, milliseconds, func, /): ...
-    def deletecommand(self, name, /): ...
-    def dooneevent(self, flags: int = 0, /): ...
-    def eval(self, script: str, /) -> str: ...
-    def evalfile(self, fileName, /): ...
-    def exprboolean(self, s, /): ...
-    def exprdouble(self, s, /): ...
-    def exprlong(self, s, /): ...
-    def exprstring(self, s, /): ...
-    def getboolean(self, arg, /): ...
-    def getdouble(self, arg, /): ...
-    def getint(self, arg, /): ...
-    def getvar(self, *args, **kwargs): ...
-    def globalgetvar(self, *args, **kwargs): ...
-    def globalsetvar(self, *args, **kwargs): ...
-    def globalunsetvar(self, *args, **kwargs): ...
-    def interpaddr(self): ...
-    def loadtk(self) -> None: ...
-    def mainloop(self, threshold: int = 0, /): ...
-    def quit(self): ...
-    def record(self, script, /): ...
-    def setvar(self, *ags, **kwargs): ...
-    if sys.version_info < (3, 11):
-        def split(self, arg, /): ...
-
-    def splitlist(self, arg, /): ...
-    def unsetvar(self, *args, **kwargs): ...
-    def wantobjects(self, *args, **kwargs): ...
-    def willdispatch(self): ...
-
-# These should be kept in sync with tkinter.tix constants, except ALL_EVENTS which doesn't match TCL_ALL_EVENTS
-ALL_EVENTS: Literal[-3]
-FILE_EVENTS: Literal[8]
-IDLE_EVENTS: Literal[32]
-TIMER_EVENTS: Literal[16]
-WINDOW_EVENTS: Literal[4]
-
-DONT_WAIT: Literal[2]
-EXCEPTION: Literal[8]
-READABLE: Literal[2]
-WRITABLE: Literal[4]
-
-TCL_VERSION: str
-TK_VERSION: str
-
-@final
-class TkttType:
-    def deletetimerhandler(self): ...
-
-def create(
-    screenName: str | None = None,
-    baseName: str = "",
-    className: str = "Tk",
-    interactive: bool = False,
-    wantobjects: bool = False,
-    wantTk: bool = True,
-    sync: bool = False,
-    use: str | None = None,
-    /,
-): ...
-def getbusywaitinterval(): ...
-def setbusywaitinterval(new_val, /): ...

jaclang/vendor/mypy/typeshed/stdlib/_tracemalloc.pyi

@@ -1,17 +0,0 @@
-import sys
-from collections.abc import Sequence
-from tracemalloc import _FrameTuple, _TraceTuple
-
-def _get_object_traceback(obj: object, /) -> Sequence[_FrameTuple] | None: ...
-def _get_traces() -> Sequence[_TraceTuple]: ...
-def clear_traces() -> None: ...
-def get_traceback_limit() -> int: ...
-def get_traced_memory() -> tuple[int, int]: ...
-def get_tracemalloc_memory() -> int: ...
-def is_tracing() -> bool: ...
-
-if sys.version_info >= (3, 9):
-    def reset_peak() -> None: ...
-
-def start(nframe: int = 1, /) -> None: ...
-def stop() -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/_typeshed/__init__.pyi

@@ -1,347 +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, 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, 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")  # noqa: Y001
-
-# covariant version of typing.AnyStr, useful for protocols
-AnyStr_co = TypeVar("AnyStr_co", str, bytes, covariant=True)  # noqa: Y001
-
-# 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
-
-# To describe a function parameter that is unused and will work with anything.
-Unused: TypeAlias = object
-
-# 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)
-# sentinel: _SentinelType
-# def foo(x: int | None | _SentinelType = ...) -> None: ...
-sentinel: Any
-
-# 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]: ...
-
-# Comparison protocols
-
-class SupportsDunderLT(Protocol[_T_contra]):
-    def __lt__(self, other: _T_contra, /) -> bool: ...
-
-class SupportsDunderGT(Protocol[_T_contra]):
-    def __gt__(self, other: _T_contra, /) -> bool: ...
-
-class SupportsDunderLE(Protocol[_T_contra]):
-    def __le__(self, other: _T_contra, /) -> bool: ...
-
-class SupportsDunderGE(Protocol[_T_contra]):
-    def __ge__(self, other: _T_contra, /) -> bool: ...
-
-class SupportsAllComparisons(
-    SupportsDunderLT[Any], SupportsDunderGT[Any], SupportsDunderLE[Any], SupportsDunderGE[Any], Protocol
-): ...
-
-SupportsRichComparison: TypeAlias = SupportsDunderLT[Any] | SupportsDunderGT[Any]
-SupportsRichComparisonT = TypeVar("SupportsRichComparisonT", bound=SupportsRichComparison)  # noqa: Y001
-
-# 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 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 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 __contains__(self, x: Any, /) -> bool: ...
-    def __getitem__(self, key: _KT_contra, /) -> _VT_co: ...
-
-# stable
-class SupportsItemAccess(SupportsGetItem[_KT_contra, _VT], Protocol[_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: ...
-
-# 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, /) -> 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, /) -> Sequence[int]: ...
-    @overload
-    def __getitem__(self, i: int, /) -> int: ...
-
-class SizedBuffer(Sized, Buffer, Protocol): ...
-
-# for compatibility with third-party stubs that may use this
-_BufferWithLen: TypeAlias = SizedBuffer  # not stable  # noqa: Y047
-
-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: type[Self], sequence: Iterable[_T_co], dict: dict[str, Any] = ...) -> Self: ...
-
-# Superset of typing.AnyStr that also includes LiteralString
-AnyOrLiteralStr = TypeVar("AnyOrLiteralStr", str, bytes, LiteralString)  # noqa: Y001
-
-# 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)  # noqa: Y001
-
-# 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
-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): ...