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

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

@@ -1,313 +0,0 @@
-import sys
-from _typeshed import StrOrBytesPath, SupportsWrite
-from collections.abc import Callable, ItemsView, Iterable, Iterator, Mapping, MutableMapping, Sequence
-from re import Pattern
-from typing import Any, ClassVar, Literal, TypeVar, overload
-from typing_extensions import TypeAlias
-
-if sys.version_info >= (3, 12):
-    __all__ = (
-        "NoSectionError",
-        "DuplicateOptionError",
-        "DuplicateSectionError",
-        "NoOptionError",
-        "InterpolationError",
-        "InterpolationDepthError",
-        "InterpolationMissingOptionError",
-        "InterpolationSyntaxError",
-        "ParsingError",
-        "MissingSectionHeaderError",
-        "ConfigParser",
-        "RawConfigParser",
-        "Interpolation",
-        "BasicInterpolation",
-        "ExtendedInterpolation",
-        "LegacyInterpolation",
-        "SectionProxy",
-        "ConverterMapping",
-        "DEFAULTSECT",
-        "MAX_INTERPOLATION_DEPTH",
-    )
-else:
-    __all__ = [
-        "NoSectionError",
-        "DuplicateOptionError",
-        "DuplicateSectionError",
-        "NoOptionError",
-        "InterpolationError",
-        "InterpolationDepthError",
-        "InterpolationMissingOptionError",
-        "InterpolationSyntaxError",
-        "ParsingError",
-        "MissingSectionHeaderError",
-        "ConfigParser",
-        "SafeConfigParser",
-        "RawConfigParser",
-        "Interpolation",
-        "BasicInterpolation",
-        "ExtendedInterpolation",
-        "LegacyInterpolation",
-        "SectionProxy",
-        "ConverterMapping",
-        "DEFAULTSECT",
-        "MAX_INTERPOLATION_DEPTH",
-    ]
-
-_Section: TypeAlias = Mapping[str, str]
-_Parser: TypeAlias = MutableMapping[str, _Section]
-_ConverterCallback: TypeAlias = Callable[[str], Any]
-_ConvertersMap: TypeAlias = dict[str, _ConverterCallback]
-_T = TypeVar("_T")
-
-DEFAULTSECT: Literal["DEFAULT"]
-MAX_INTERPOLATION_DEPTH: Literal[10]
-
-class Interpolation:
-    def before_get(self, parser: _Parser, section: str, option: str, value: str, defaults: _Section) -> str: ...
-    def before_set(self, parser: _Parser, section: str, option: str, value: str) -> str: ...
-    def before_read(self, parser: _Parser, section: str, option: str, value: str) -> str: ...
-    def before_write(self, parser: _Parser, section: str, option: str, value: str) -> str: ...
-
-class BasicInterpolation(Interpolation): ...
-class ExtendedInterpolation(Interpolation): ...
-
-class LegacyInterpolation(Interpolation):
-    def before_get(self, parser: _Parser, section: str, option: str, value: str, vars: _Section) -> str: ...
-
-class RawConfigParser(_Parser):
-    _SECT_TMPL: ClassVar[str]  # undocumented
-    _OPT_TMPL: ClassVar[str]  # undocumented
-    _OPT_NV_TMPL: ClassVar[str]  # undocumented
-
-    SECTCRE: Pattern[str]
-    OPTCRE: ClassVar[Pattern[str]]
-    OPTCRE_NV: ClassVar[Pattern[str]]  # undocumented
-    NONSPACECRE: ClassVar[Pattern[str]]  # undocumented
-
-    BOOLEAN_STATES: ClassVar[Mapping[str, bool]]  # undocumented
-    default_section: str
-    @overload
-    def __init__(
-        self,
-        defaults: Mapping[str, str | None] | None = None,
-        dict_type: type[Mapping[str, str]] = ...,
-        *,
-        allow_no_value: Literal[True],
-        delimiters: Sequence[str] = ("=", ":"),
-        comment_prefixes: Sequence[str] = ("#", ";"),
-        inline_comment_prefixes: Sequence[str] | None = None,
-        strict: bool = True,
-        empty_lines_in_values: bool = True,
-        default_section: str = "DEFAULT",
-        interpolation: Interpolation | None = ...,
-        converters: _ConvertersMap = ...,
-    ) -> None: ...
-    @overload
-    def __init__(
-        self,
-        defaults: Mapping[str, str | None] | None,
-        dict_type: type[Mapping[str, str]],
-        allow_no_value: Literal[True],
-        *,
-        delimiters: Sequence[str] = ("=", ":"),
-        comment_prefixes: Sequence[str] = ("#", ";"),
-        inline_comment_prefixes: Sequence[str] | None = None,
-        strict: bool = True,
-        empty_lines_in_values: bool = True,
-        default_section: str = "DEFAULT",
-        interpolation: Interpolation | None = ...,
-        converters: _ConvertersMap = ...,
-    ) -> None: ...
-    @overload
-    def __init__(
-        self,
-        defaults: _Section | None = None,
-        dict_type: type[Mapping[str, str]] = ...,
-        allow_no_value: bool = False,
-        *,
-        delimiters: Sequence[str] = ("=", ":"),
-        comment_prefixes: Sequence[str] = ("#", ";"),
-        inline_comment_prefixes: Sequence[str] | None = None,
-        strict: bool = True,
-        empty_lines_in_values: bool = True,
-        default_section: str = "DEFAULT",
-        interpolation: Interpolation | None = ...,
-        converters: _ConvertersMap = ...,
-    ) -> None: ...
-    def __len__(self) -> int: ...
-    def __getitem__(self, key: str) -> SectionProxy: ...
-    def __setitem__(self, key: str, value: _Section) -> None: ...
-    def __delitem__(self, key: str) -> None: ...
-    def __iter__(self) -> Iterator[str]: ...
-    def __contains__(self, key: object) -> bool: ...
-    def defaults(self) -> _Section: ...
-    def sections(self) -> list[str]: ...
-    def add_section(self, section: str) -> None: ...
-    def has_section(self, section: str) -> bool: ...
-    def options(self, section: str) -> list[str]: ...
-    def has_option(self, section: str, option: str) -> bool: ...
-    def read(self, filenames: StrOrBytesPath | Iterable[StrOrBytesPath], encoding: str | None = None) -> list[str]: ...
-    def read_file(self, f: Iterable[str], source: str | None = None) -> None: ...
-    def read_string(self, string: str, source: str = "<string>") -> None: ...
-    def read_dict(self, dictionary: Mapping[str, Mapping[str, Any]], source: str = "<dict>") -> None: ...
-    if sys.version_info < (3, 12):
-        def readfp(self, fp: Iterable[str], filename: str | None = None) -> None: ...
-    # These get* methods are partially applied (with the same names) in
-    # SectionProxy; the stubs should be kept updated together
-    @overload
-    def getint(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> int: ...
-    @overload
-    def getint(
-        self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T = ...
-    ) -> int | _T: ...
-    @overload
-    def getfloat(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> float: ...
-    @overload
-    def getfloat(
-        self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T = ...
-    ) -> float | _T: ...
-    @overload
-    def getboolean(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> bool: ...
-    @overload
-    def getboolean(
-        self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T = ...
-    ) -> bool | _T: ...
-    def _get_conv(
-        self,
-        section: str,
-        option: str,
-        conv: Callable[[str], _T],
-        *,
-        raw: bool = False,
-        vars: _Section | None = None,
-        fallback: _T = ...,
-    ) -> _T: ...
-    # This is incompatible with MutableMapping so we ignore the type
-    @overload  # type: ignore[override]
-    def get(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> str | Any: ...
-    @overload
-    def get(
-        self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T
-    ) -> str | _T | Any: ...
-    @overload
-    def items(self, *, raw: bool = False, vars: _Section | None = None) -> ItemsView[str, SectionProxy]: ...
-    @overload
-    def items(self, section: str, raw: bool = False, vars: _Section | None = None) -> list[tuple[str, str]]: ...
-    def set(self, section: str, option: str, value: str | None = None) -> None: ...
-    def write(self, fp: SupportsWrite[str], space_around_delimiters: bool = True) -> None: ...
-    def remove_option(self, section: str, option: str) -> bool: ...
-    def remove_section(self, section: str) -> bool: ...
-    def optionxform(self, optionstr: str) -> str: ...
-
-class ConfigParser(RawConfigParser):
-    # This is incompatible with MutableMapping so we ignore the type
-    @overload  # type: ignore[override]
-    def get(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None) -> str: ...
-    @overload
-    def get(self, section: str, option: str, *, raw: bool = False, vars: _Section | None = None, fallback: _T) -> str | _T: ...
-
-if sys.version_info < (3, 12):
-    class SafeConfigParser(ConfigParser): ...  # deprecated alias
-
-class SectionProxy(MutableMapping[str, str]):
-    def __init__(self, parser: RawConfigParser, name: str) -> None: ...
-    def __getitem__(self, key: str) -> str: ...
-    def __setitem__(self, key: str, value: str) -> None: ...
-    def __delitem__(self, key: str) -> None: ...
-    def __contains__(self, key: object) -> bool: ...
-    def __len__(self) -> int: ...
-    def __iter__(self) -> Iterator[str]: ...
-    @property
-    def parser(self) -> RawConfigParser: ...
-    @property
-    def name(self) -> str: ...
-    def get(  # type: ignore[override]
-        self,
-        option: str,
-        fallback: str | None = None,
-        *,
-        raw: bool = False,
-        vars: _Section | None = None,
-        _impl: Any | None = None,
-        **kwargs: Any,
-    ) -> str | Any: ...  # can be None in RawConfigParser's sections
-    # These are partially-applied version of the methods with the same names in
-    # RawConfigParser; the stubs should be kept updated together
-    @overload
-    def getint(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> int: ...
-    @overload
-    def getint(self, option: str, fallback: _T = ..., *, raw: bool = ..., vars: _Section | None = ...) -> int | _T: ...
-    @overload
-    def getfloat(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> float: ...
-    @overload
-    def getfloat(self, option: str, fallback: _T = ..., *, raw: bool = ..., vars: _Section | None = ...) -> float | _T: ...
-    @overload
-    def getboolean(self, option: str, *, raw: bool = ..., vars: _Section | None = ...) -> bool: ...
-    @overload
-    def getboolean(self, option: str, fallback: _T = ..., *, raw: bool = ..., vars: _Section | None = ...) -> bool | _T: ...
-    # SectionProxy can have arbitrary attributes when custom converters are used
-    def __getattr__(self, key: str) -> Callable[..., Any]: ...
-
-class ConverterMapping(MutableMapping[str, _ConverterCallback | None]):
-    GETTERCRE: ClassVar[Pattern[Any]]
-    def __init__(self, parser: RawConfigParser) -> None: ...
-    def __getitem__(self, key: str) -> _ConverterCallback: ...
-    def __setitem__(self, key: str, value: _ConverterCallback | None) -> None: ...
-    def __delitem__(self, key: str) -> None: ...
-    def __iter__(self) -> Iterator[str]: ...
-    def __len__(self) -> int: ...
-
-class Error(Exception):
-    message: str
-    def __init__(self, msg: str = "") -> None: ...
-
-class NoSectionError(Error):
-    section: str
-    def __init__(self, section: str) -> None: ...
-
-class DuplicateSectionError(Error):
-    section: str
-    source: str | None
-    lineno: int | None
-    def __init__(self, section: str, source: str | None = None, lineno: int | None = None) -> None: ...
-
-class DuplicateOptionError(Error):
-    section: str
-    option: str
-    source: str | None
-    lineno: int | None
-    def __init__(self, section: str, option: str, source: str | None = None, lineno: int | None = None) -> None: ...
-
-class NoOptionError(Error):
-    section: str
-    option: str
-    def __init__(self, option: str, section: str) -> None: ...
-
-class InterpolationError(Error):
-    section: str
-    option: str
-    def __init__(self, option: str, section: str, msg: str) -> None: ...
-
-class InterpolationDepthError(InterpolationError):
-    def __init__(self, option: str, section: str, rawval: object) -> None: ...
-
-class InterpolationMissingOptionError(InterpolationError):
-    reference: str
-    def __init__(self, option: str, section: str, rawval: object, reference: str) -> None: ...
-
-class InterpolationSyntaxError(InterpolationError): ...
-
-class ParsingError(Error):
-    source: str
-    errors: list[tuple[int, str]]
-    if sys.version_info >= (3, 12):
-        def __init__(self, source: str) -> None: ...
-    else:
-        def __init__(self, source: str | None = None, filename: str | None = None) -> None: ...
-
-    def append(self, lineno: int, line: str) -> None: ...
-
-class MissingSectionHeaderError(ParsingError):
-    lineno: int
-    line: str
-    def __init__(self, filename: str, lineno: int, line: str) -> None: ...

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

@@ -1,208 +0,0 @@
-import abc
-import sys
-from _typeshed import FileDescriptorOrPath, Unused
-from abc import abstractmethod
-from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable, Generator, Iterator
-from types import TracebackType
-from typing import IO, Any, Generic, Protocol, TypeVar, overload, runtime_checkable
-from typing_extensions import ParamSpec, Self, TypeAlias
-
-__all__ = [
-    "contextmanager",
-    "closing",
-    "AbstractContextManager",
-    "ContextDecorator",
-    "ExitStack",
-    "redirect_stdout",
-    "redirect_stderr",
-    "suppress",
-    "AbstractAsyncContextManager",
-    "AsyncExitStack",
-    "asynccontextmanager",
-    "nullcontext",
-]
-
-if sys.version_info >= (3, 10):
-    __all__ += ["aclosing"]
-
-if sys.version_info >= (3, 11):
-    __all__ += ["chdir"]
-
-_T = TypeVar("_T")
-_T_co = TypeVar("_T_co", covariant=True)
-_T_io = TypeVar("_T_io", bound=IO[str] | None)
-_F = TypeVar("_F", bound=Callable[..., Any])
-_P = ParamSpec("_P")
-
-_ExitFunc: TypeAlias = Callable[[type[BaseException] | None, BaseException | None, TracebackType | None], bool | None]
-_CM_EF = TypeVar("_CM_EF", bound=AbstractContextManager[Any] | _ExitFunc)
-
-@runtime_checkable
-class AbstractContextManager(Protocol[_T_co]):
-    def __enter__(self) -> _T_co: ...
-    @abstractmethod
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
-    ) -> bool | None: ...
-
-@runtime_checkable
-class AbstractAsyncContextManager(Protocol[_T_co]):
-    async def __aenter__(self) -> _T_co: ...
-    @abstractmethod
-    async def __aexit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
-    ) -> bool | None: ...
-
-class ContextDecorator:
-    def __call__(self, func: _F) -> _F: ...
-
-class _GeneratorContextManager(AbstractContextManager[_T_co], ContextDecorator):
-    # __init__ and all instance attributes are actually inherited from _GeneratorContextManagerBase
-    # _GeneratorContextManagerBase is more trouble than it's worth to include in the stub; see #6676
-    def __init__(self, func: Callable[..., Iterator[_T_co]], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
-    gen: Generator[_T_co, Any, Any]
-    func: Callable[..., Generator[_T_co, Any, Any]]
-    args: tuple[Any, ...]
-    kwds: dict[str, Any]
-    if sys.version_info >= (3, 9):
-        def __exit__(
-            self, typ: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-        ) -> bool | None: ...
-    else:
-        def __exit__(
-            self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-        ) -> bool | None: ...
-
-def contextmanager(func: Callable[_P, Iterator[_T_co]]) -> Callable[_P, _GeneratorContextManager[_T_co]]: ...
-
-if sys.version_info >= (3, 10):
-    _AF = TypeVar("_AF", bound=Callable[..., Awaitable[Any]])
-
-    class AsyncContextDecorator:
-        def __call__(self, func: _AF) -> _AF: ...
-
-    class _AsyncGeneratorContextManager(AbstractAsyncContextManager[_T_co], AsyncContextDecorator):
-        # __init__ and these attributes are actually defined in the base class _GeneratorContextManagerBase,
-        # which is more trouble than it's worth to include in the stub (see #6676)
-        def __init__(self, func: Callable[..., AsyncIterator[_T_co]], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
-        gen: AsyncGenerator[_T_co, Any]
-        func: Callable[..., AsyncGenerator[_T_co, Any]]
-        args: tuple[Any, ...]
-        kwds: dict[str, Any]
-        async def __aexit__(
-            self, typ: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-        ) -> bool | None: ...
-
-else:
-    class _AsyncGeneratorContextManager(AbstractAsyncContextManager[_T_co]):
-        def __init__(self, func: Callable[..., AsyncIterator[_T_co]], args: tuple[Any, ...], kwds: dict[str, Any]) -> None: ...
-        gen: AsyncGenerator[_T_co, Any]
-        func: Callable[..., AsyncGenerator[_T_co, Any]]
-        args: tuple[Any, ...]
-        kwds: dict[str, Any]
-        async def __aexit__(
-            self, typ: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
-        ) -> bool | None: ...
-
-def asynccontextmanager(func: Callable[_P, AsyncIterator[_T_co]]) -> Callable[_P, _AsyncGeneratorContextManager[_T_co]]: ...
-
-class _SupportsClose(Protocol):
-    def close(self) -> object: ...
-
-_SupportsCloseT = TypeVar("_SupportsCloseT", bound=_SupportsClose)
-
-class closing(AbstractContextManager[_SupportsCloseT]):
-    def __init__(self, thing: _SupportsCloseT) -> None: ...
-    def __exit__(self, *exc_info: Unused) -> None: ...
-
-if sys.version_info >= (3, 10):
-    class _SupportsAclose(Protocol):
-        def aclose(self) -> Awaitable[object]: ...
-
-    _SupportsAcloseT = TypeVar("_SupportsAcloseT", bound=_SupportsAclose)
-
-    class aclosing(AbstractAsyncContextManager[_SupportsAcloseT]):
-        def __init__(self, thing: _SupportsAcloseT) -> None: ...
-        async def __aexit__(self, *exc_info: Unused) -> None: ...
-
-class suppress(AbstractContextManager[None]):
-    def __init__(self, *exceptions: type[BaseException]) -> None: ...
-    def __exit__(
-        self, exctype: type[BaseException] | None, excinst: BaseException | None, exctb: TracebackType | None
-    ) -> bool: ...
-
-class _RedirectStream(AbstractContextManager[_T_io]):
-    def __init__(self, new_target: _T_io) -> None: ...
-    def __exit__(
-        self, exctype: type[BaseException] | None, excinst: BaseException | None, exctb: TracebackType | None
-    ) -> None: ...
-
-class redirect_stdout(_RedirectStream[_T_io]): ...
-class redirect_stderr(_RedirectStream[_T_io]): ...
-
-# In reality this is a subclass of `AbstractContextManager`;
-# see #7961 for why we don't do that in the stub
-class ExitStack(metaclass=abc.ABCMeta):
-    def enter_context(self, cm: AbstractContextManager[_T]) -> _T: ...
-    def push(self, exit: _CM_EF) -> _CM_EF: ...
-    def callback(self, callback: Callable[_P, _T], /, *args: _P.args, **kwds: _P.kwargs) -> Callable[_P, _T]: ...
-    def pop_all(self) -> Self: ...
-    def close(self) -> None: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
-    ) -> bool: ...
-
-_ExitCoroFunc: TypeAlias = Callable[
-    [type[BaseException] | None, BaseException | None, TracebackType | None], Awaitable[bool | None]
-]
-_ACM_EF = TypeVar("_ACM_EF", bound=AbstractAsyncContextManager[Any] | _ExitCoroFunc)
-
-# In reality this is a subclass of `AbstractAsyncContextManager`;
-# see #7961 for why we don't do that in the stub
-class AsyncExitStack(metaclass=abc.ABCMeta):
-    def enter_context(self, cm: AbstractContextManager[_T]) -> _T: ...
-    async def enter_async_context(self, cm: AbstractAsyncContextManager[_T]) -> _T: ...
-    def push(self, exit: _CM_EF) -> _CM_EF: ...
-    def push_async_exit(self, exit: _ACM_EF) -> _ACM_EF: ...
-    def callback(self, callback: Callable[_P, _T], /, *args: _P.args, **kwds: _P.kwargs) -> Callable[_P, _T]: ...
-    def push_async_callback(
-        self, callback: Callable[_P, Awaitable[_T]], /, *args: _P.args, **kwds: _P.kwargs
-    ) -> Callable[_P, Awaitable[_T]]: ...
-    def pop_all(self) -> Self: ...
-    async def aclose(self) -> None: ...
-    async def __aenter__(self) -> Self: ...
-    async def __aexit__(
-        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None, /
-    ) -> bool: ...
-
-if sys.version_info >= (3, 10):
-    class nullcontext(AbstractContextManager[_T], AbstractAsyncContextManager[_T]):
-        enter_result: _T
-        @overload
-        def __init__(self: nullcontext[None], enter_result: None = None) -> None: ...
-        @overload
-        def __init__(self: nullcontext[_T], enter_result: _T) -> None: ...
-        def __enter__(self) -> _T: ...
-        def __exit__(self, *exctype: Unused) -> None: ...
-        async def __aenter__(self) -> _T: ...
-        async def __aexit__(self, *exctype: Unused) -> None: ...
-
-else:
-    class nullcontext(AbstractContextManager[_T]):
-        enter_result: _T
-        @overload
-        def __init__(self: nullcontext[None], enter_result: None = None) -> None: ...
-        @overload
-        def __init__(self: nullcontext[_T], enter_result: _T) -> None: ...
-        def __enter__(self) -> _T: ...
-        def __exit__(self, *exctype: Unused) -> None: ...
-
-if sys.version_info >= (3, 11):
-    _T_fd_or_any_path = TypeVar("_T_fd_or_any_path", bound=FileDescriptorOrPath)
-
-    class chdir(AbstractContextManager[None], Generic[_T_fd_or_any_path]):
-        path: _T_fd_or_any_path
-        def __init__(self, path: _T_fd_or_any_path) -> None: ...
-        def __enter__(self) -> None: ...
-        def __exit__(self, *excinfo: Unused) -> None: ...

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

@@ -1,63 +0,0 @@
-import sys
-from collections.abc import Callable, Iterator, Mapping
-from typing import Any, ClassVar, Generic, TypeVar, final, overload
-from typing_extensions import ParamSpec
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-
-__all__ = ("Context", "ContextVar", "Token", "copy_context")
-
-_T = TypeVar("_T")
-_D = TypeVar("_D")
-_P = ParamSpec("_P")
-
-@final
-class ContextVar(Generic[_T]):
-    @overload
-    def __init__(self, name: str) -> None: ...
-    @overload
-    def __init__(self, name: str, *, default: _T) -> None: ...
-    def __hash__(self) -> int: ...
-    @property
-    def name(self) -> str: ...
-    @overload
-    def get(self) -> _T: ...
-    @overload
-    def get(self, default: _T, /) -> _T: ...
-    @overload
-    def get(self, default: _D, /) -> _D | _T: ...
-    def set(self, value: _T, /) -> Token[_T]: ...
-    def reset(self, token: Token[_T], /) -> None: ...
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
-@final
-class Token(Generic[_T]):
-    @property
-    def var(self) -> ContextVar[_T]: ...
-    @property
-    def old_value(self) -> Any: ...  # returns either _T or MISSING, but that's hard to express
-    MISSING: ClassVar[object]
-    if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
-
-def copy_context() -> Context: ...
-
-# It doesn't make sense to make this generic, because for most Contexts each ContextVar will have
-# a different value.
-@final
-class Context(Mapping[ContextVar[Any], Any]):
-    def __init__(self) -> None: ...
-    @overload
-    def get(self, key: ContextVar[_T], default: None = None, /) -> _T | None: ...
-    @overload
-    def get(self, key: ContextVar[_T], default: _T, /) -> _T: ...
-    @overload
-    def get(self, key: ContextVar[_T], default: _D, /) -> _T | _D: ...
-    def run(self, callable: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> _T: ...
-    def copy(self) -> Context: ...
-    def __getitem__(self, key: ContextVar[_T], /) -> _T: ...
-    def __iter__(self) -> Iterator[ContextVar[Any]]: ...
-    def __len__(self) -> int: ...
-    def __eq__(self, value: object, /) -> bool: ...

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

@@ -1,16 +0,0 @@
-from typing import Any, TypeVar
-
-__all__ = ["Error", "copy", "deepcopy"]
-
-_T = TypeVar("_T")
-
-# None in CPython but non-None in Jython
-PyStringMap: Any
-
-# Note: memo and _nil are internal kwargs.
-def deepcopy(x: _T, memo: dict[int, Any] | None = None, _nil: Any = []) -> _T: ...
-def copy(x: _T) -> _T: ...
-
-class Error(Exception): ...
-
-error = Error

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

@@ -1,21 +0,0 @@
-from collections.abc import Callable, Hashable
-from typing import Any, SupportsInt, TypeVar
-from typing_extensions import TypeAlias
-
-_T = TypeVar("_T")
-_Reduce: TypeAlias = tuple[Callable[..., _T], tuple[Any, ...]] | tuple[Callable[..., _T], tuple[Any, ...], Any | None]
-
-__all__ = ["pickle", "constructor", "add_extension", "remove_extension", "clear_extension_cache"]
-
-def pickle(
-    ob_type: type[_T],
-    pickle_function: Callable[[_T], str | _Reduce[_T]],
-    constructor_ob: Callable[[_Reduce[_T]], _T] | None = None,
-) -> None: ...
-def constructor(object: Callable[[_Reduce[_T]], _T]) -> None: ...
-def add_extension(module: Hashable, name: Hashable, code: SupportsInt) -> None: ...
-def remove_extension(module: Hashable, name: Hashable, code: int) -> None: ...
-def clear_extension_cache() -> None: ...
-
-_DispatchTableType: TypeAlias = dict[type, Callable[[Any], str | _Reduce[Any]]]  # imported by multiprocessing.reduction
-dispatch_table: _DispatchTableType  # undocumented

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

@@ -1,12 +0,0 @@
-import sys
-
-if sys.platform != "win32":
-    class _Method: ...
-    METHOD_CRYPT: _Method
-    METHOD_MD5: _Method
-    METHOD_SHA256: _Method
-    METHOD_SHA512: _Method
-    METHOD_BLOWFISH: _Method
-    methods: list[_Method]
-    def mksalt(method: _Method | None = None, *, rounds: int | None = None) -> str: ...
-    def crypt(word: str, salt: str | _Method | None = None) -> str: ...