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

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

@@ -1,168 +0,0 @@
-import subprocess
-import sys
-import time
-from _typeshed import ReadableBuffer, SizedBuffer
-from builtins import list as _list  # conflicts with a method named "list"
-from collections.abc import Callable
-from datetime import datetime
-from re import Pattern
-from socket import socket as _socket
-from ssl import SSLContext, SSLSocket
-from types import TracebackType
-from typing import IO, Any, Literal, SupportsAbs, SupportsInt
-from typing_extensions import Self, TypeAlias
-
-__all__ = ["IMAP4", "IMAP4_stream", "Internaldate2tuple", "Int2AP", "ParseFlags", "Time2Internaldate", "IMAP4_SSL"]
-
-# TODO: Commands should use their actual return types, not this type alias.
-#       E.g. Tuple[Literal["OK"], List[bytes]]
-_CommandResults: TypeAlias = tuple[str, list[Any]]
-
-_AnyResponseData: TypeAlias = list[None] | list[bytes | tuple[bytes, bytes]]
-
-Commands: dict[str, tuple[str, ...]]
-
-class IMAP4:
-    class error(Exception): ...
-    class abort(error): ...
-    class readonly(abort): ...
-    mustquote: Pattern[str]
-    debug: int
-    state: str
-    literal: str | None
-    tagged_commands: dict[bytes, _list[bytes] | None]
-    untagged_responses: dict[str, _list[bytes | tuple[bytes, bytes]]]
-    continuation_response: str
-    is_readonly: bool
-    tagnum: int
-    tagpre: str
-    tagre: Pattern[str]
-    welcome: bytes
-    capabilities: tuple[str, ...]
-    PROTOCOL_VERSION: str
-    if sys.version_info >= (3, 9):
-        def __init__(self, host: str = "", port: int = 143, timeout: float | None = None) -> None: ...
-        def open(self, host: str = "", port: int = 143, timeout: float | None = None) -> None: ...
-    else:
-        def __init__(self, host: str = "", port: int = 143) -> None: ...
-        def open(self, host: str = "", port: int = 143) -> None: ...
-
-    def __getattr__(self, attr: str) -> Any: ...
-    host: str
-    port: int
-    sock: _socket
-    file: IO[str] | IO[bytes]
-    def read(self, size: int) -> bytes: ...
-    def readline(self) -> bytes: ...
-    def send(self, data: ReadableBuffer) -> None: ...
-    def shutdown(self) -> None: ...
-    def socket(self) -> _socket: ...
-    def recent(self) -> _CommandResults: ...
-    def response(self, code: str) -> _CommandResults: ...
-    def append(self, mailbox: str, flags: str, date_time: str, message: ReadableBuffer) -> str: ...
-    def authenticate(self, mechanism: str, authobject: Callable[[bytes], bytes | None]) -> tuple[str, str]: ...
-    def capability(self) -> _CommandResults: ...
-    def check(self) -> _CommandResults: ...
-    def close(self) -> _CommandResults: ...
-    def copy(self, message_set: str, new_mailbox: str) -> _CommandResults: ...
-    def create(self, mailbox: str) -> _CommandResults: ...
-    def delete(self, mailbox: str) -> _CommandResults: ...
-    def deleteacl(self, mailbox: str, who: str) -> _CommandResults: ...
-    def enable(self, capability: str) -> _CommandResults: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
-    def expunge(self) -> _CommandResults: ...
-    def fetch(self, message_set: str, message_parts: str) -> tuple[str, _AnyResponseData]: ...
-    def getacl(self, mailbox: str) -> _CommandResults: ...
-    def getannotation(self, mailbox: str, entry: str, attribute: str) -> _CommandResults: ...
-    def getquota(self, root: str) -> _CommandResults: ...
-    def getquotaroot(self, mailbox: str) -> _CommandResults: ...
-    def list(self, directory: str = '""', pattern: str = "*") -> tuple[str, _AnyResponseData]: ...
-    def login(self, user: str, password: str) -> tuple[Literal["OK"], _list[bytes]]: ...
-    def login_cram_md5(self, user: str, password: str) -> _CommandResults: ...
-    def logout(self) -> tuple[str, _AnyResponseData]: ...
-    def lsub(self, directory: str = '""', pattern: str = "*") -> _CommandResults: ...
-    def myrights(self, mailbox: str) -> _CommandResults: ...
-    def namespace(self) -> _CommandResults: ...
-    def noop(self) -> tuple[str, _list[bytes]]: ...
-    def partial(self, message_num: str, message_part: str, start: str, length: str) -> _CommandResults: ...
-    def proxyauth(self, user: str) -> _CommandResults: ...
-    def rename(self, oldmailbox: str, newmailbox: str) -> _CommandResults: ...
-    def search(self, charset: str | None, *criteria: str) -> _CommandResults: ...
-    def select(self, mailbox: str = "INBOX", readonly: bool = False) -> tuple[str, _list[bytes | None]]: ...
-    def setacl(self, mailbox: str, who: str, what: str) -> _CommandResults: ...
-    def setannotation(self, *args: str) -> _CommandResults: ...
-    def setquota(self, root: str, limits: str) -> _CommandResults: ...
-    def sort(self, sort_criteria: str, charset: str, *search_criteria: str) -> _CommandResults: ...
-    def starttls(self, ssl_context: Any | None = None) -> tuple[Literal["OK"], _list[None]]: ...
-    def status(self, mailbox: str, names: str) -> _CommandResults: ...
-    def store(self, message_set: str, command: str, flags: str) -> _CommandResults: ...
-    def subscribe(self, mailbox: str) -> _CommandResults: ...
-    def thread(self, threading_algorithm: str, charset: str, *search_criteria: str) -> _CommandResults: ...
-    def uid(self, command: str, *args: str) -> _CommandResults: ...
-    def unsubscribe(self, mailbox: str) -> _CommandResults: ...
-    if sys.version_info >= (3, 9):
-        def unselect(self) -> _CommandResults: ...
-
-    def xatom(self, name: str, *args: str) -> _CommandResults: ...
-    def print_log(self) -> None: ...
-
-class IMAP4_SSL(IMAP4):
-    if sys.version_info < (3, 12):
-        keyfile: str
-        certfile: str
-    if sys.version_info >= (3, 12):
-        def __init__(
-            self, host: str = "", port: int = 993, *, ssl_context: SSLContext | None = None, timeout: float | None = None
-        ) -> None: ...
-    elif sys.version_info >= (3, 9):
-        def __init__(
-            self,
-            host: str = "",
-            port: int = 993,
-            keyfile: str | None = None,
-            certfile: str | None = None,
-            ssl_context: SSLContext | None = None,
-            timeout: float | None = None,
-        ) -> None: ...
-    else:
-        def __init__(
-            self,
-            host: str = "",
-            port: int = 993,
-            keyfile: str | None = None,
-            certfile: str | None = None,
-            ssl_context: SSLContext | None = None,
-        ) -> None: ...
-    sslobj: SSLSocket
-    file: IO[Any]
-    if sys.version_info >= (3, 9):
-        def open(self, host: str = "", port: int | None = 993, timeout: float | None = None) -> None: ...
-    else:
-        def open(self, host: str = "", port: int | None = 993) -> None: ...
-
-    def ssl(self) -> SSLSocket: ...
-
-class IMAP4_stream(IMAP4):
-    command: str
-    def __init__(self, command: str) -> None: ...
-    file: IO[Any]
-    process: subprocess.Popen[bytes]
-    writefile: IO[Any]
-    readfile: IO[Any]
-    if sys.version_info >= (3, 9):
-        def open(self, host: str | None = None, port: int | None = None, timeout: float | None = None) -> None: ...
-    else:
-        def open(self, host: str | None = None, port: int | None = None) -> None: ...
-
-class _Authenticator:
-    mech: Callable[[bytes], bytes | bytearray | memoryview | str | None]
-    def __init__(self, mechinst: Callable[[bytes], bytes | bytearray | memoryview | str | None]) -> None: ...
-    def process(self, data: str) -> str: ...
-    def encode(self, inp: bytes | bytearray | memoryview) -> str: ...
-    def decode(self, inp: str | SizedBuffer) -> bytes: ...
-
-def Internaldate2tuple(resp: ReadableBuffer) -> time.struct_time | None: ...
-def Int2AP(num: SupportsAbs[SupportsInt]) -> bytes: ...
-def ParseFlags(resp: ReadableBuffer) -> tuple[bytes, ...]: ...
-def Time2Internaldate(date_time: float | time.struct_time | time._TimeTuple | datetime | str) -> str: ...

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

@@ -1,17 +0,0 @@
-from _typeshed import StrPath
-from collections.abc import Callable
-from typing import Any, BinaryIO, Protocol, overload
-
-__all__ = ["what"]
-
-class _ReadableBinary(Protocol):
-    def tell(self) -> int: ...
-    def read(self, size: int, /) -> bytes: ...
-    def seek(self, offset: int, /) -> Any: ...
-
-@overload
-def what(file: StrPath | _ReadableBinary, h: None = None) -> str | None: ...
-@overload
-def what(file: Any, h: bytes) -> str | None: ...
-
-tests: list[Callable[[bytes, BinaryIO | None], str | None]]

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

@@ -1,62 +0,0 @@
-import types
-from _imp import (
-    acquire_lock as acquire_lock,
-    create_dynamic as create_dynamic,
-    get_frozen_object as get_frozen_object,
-    init_frozen as init_frozen,
-    is_builtin as is_builtin,
-    is_frozen as is_frozen,
-    is_frozen_package as is_frozen_package,
-    lock_held as lock_held,
-    release_lock as release_lock,
-)
-from _typeshed import StrPath
-from os import PathLike
-from types import TracebackType
-from typing import IO, Any, Protocol
-
-SEARCH_ERROR: int
-PY_SOURCE: int
-PY_COMPILED: int
-C_EXTENSION: int
-PY_RESOURCE: int
-PKG_DIRECTORY: int
-C_BUILTIN: int
-PY_FROZEN: int
-PY_CODERESOURCE: int
-IMP_HOOK: int
-
-def new_module(name: str) -> types.ModuleType: ...
-def get_magic() -> bytes: ...
-def get_tag() -> str: ...
-def cache_from_source(path: StrPath, debug_override: bool | None = None) -> str: ...
-def source_from_cache(path: StrPath) -> str: ...
-def get_suffixes() -> list[tuple[str, str, int]]: ...
-
-class NullImporter:
-    def __init__(self, path: StrPath) -> None: ...
-    def find_module(self, fullname: Any) -> None: ...
-
-# Technically, a text file has to support a slightly different set of operations than a binary file,
-# but we ignore that here.
-class _FileLike(Protocol):
-    closed: bool
-    mode: str
-    def read(self) -> str | bytes: ...
-    def close(self) -> Any: ...
-    def __enter__(self) -> Any: ...
-    def __exit__(self, typ: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None, /) -> Any: ...
-
-# PathLike doesn't work for the pathname argument here
-def load_source(name: str, pathname: str, file: _FileLike | None = None) -> types.ModuleType: ...
-def load_compiled(name: str, pathname: str, file: _FileLike | None = None) -> types.ModuleType: ...
-def load_package(name: str, path: StrPath) -> types.ModuleType: ...
-def load_module(name: str, file: _FileLike | None, filename: str, details: tuple[str, str, int]) -> types.ModuleType: ...
-
-# IO[Any] is a TextIOWrapper if name is a .py file, and a FileIO otherwise.
-def find_module(
-    name: str, path: None | list[str] | list[PathLike[str]] | list[StrPath] = None
-) -> tuple[IO[Any], str, tuple[str, str, int]]: ...
-def reload(module: types.ModuleType) -> types.ModuleType: ...
-def init_builtin(name: str) -> types.ModuleType | None: ...
-def load_dynamic(name: str, path: str, file: Any = None) -> types.ModuleType: ...  # file argument is ignored

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

@@ -1,24 +0,0 @@
-import sys
-from collections.abc import Mapping, Sequence
-from importlib.abc import Loader
-from types import ModuleType
-
-__all__ = ["__import__", "import_module", "invalidate_caches", "reload"]
-
-# Signature of `builtins.__import__` should be kept identical to `importlib.__import__`
-def __import__(
-    name: str,
-    globals: Mapping[str, object] | None = None,
-    locals: Mapping[str, object] | None = None,
-    fromlist: Sequence[str] = (),
-    level: int = 0,
-) -> ModuleType: ...
-
-# `importlib.import_module` return type should be kept the same as `builtins.__import__`
-def import_module(name: str, package: str | None = None) -> ModuleType: ...
-
-if sys.version_info < (3, 12):
-    def find_loader(name: str, path: str | None = None) -> Loader | None: ...
-
-def invalidate_caches() -> None: ...
-def reload(module: ModuleType) -> ModuleType: ...

jaclang/vendor/mypy/typeshed/stdlib/importlib/_abc.pyi

@@ -1,15 +0,0 @@
-import sys
-import types
-from abc import ABCMeta
-from importlib.machinery import ModuleSpec
-
-if sys.version_info >= (3, 10):
-    class Loader(metaclass=ABCMeta):
-        def load_module(self, fullname: str) -> types.ModuleType: ...
-        if sys.version_info < (3, 12):
-            def module_repr(self, module: types.ModuleType) -> str: ...
-
-        def create_module(self, spec: ModuleSpec) -> types.ModuleType | None: ...
-        # Not defined on the actual class for backwards-compatibility reasons,
-        # but expected in new code.
-        def exec_module(self, module: types.ModuleType) -> None: ...

jaclang/vendor/mypy/typeshed/stdlib/importlib/abc.pyi

@@ -1,172 +0,0 @@
-import _ast
-import sys
-import types
-from _typeshed import ReadableBuffer, StrPath
-from abc import ABCMeta, abstractmethod
-from collections.abc import Iterator, Mapping, Sequence
-from importlib.machinery import ModuleSpec
-from io import BufferedReader
-from typing import IO, Any, Literal, Protocol, overload, runtime_checkable
-
-if sys.version_info >= (3, 11):
-    __all__ = [
-        "Loader",
-        "MetaPathFinder",
-        "PathEntryFinder",
-        "ResourceLoader",
-        "InspectLoader",
-        "ExecutionLoader",
-        "FileLoader",
-        "SourceLoader",
-    ]
-
-    if sys.version_info < (3, 12):
-        __all__ += ["Finder", "ResourceReader", "Traversable", "TraversableResources"]
-
-if sys.version_info >= (3, 10):
-    from importlib._abc import Loader as Loader
-else:
-    class Loader(metaclass=ABCMeta):
-        def load_module(self, fullname: str) -> types.ModuleType: ...
-        def module_repr(self, module: types.ModuleType) -> str: ...
-        def create_module(self, spec: ModuleSpec) -> types.ModuleType | None: ...
-        # Not defined on the actual class for backwards-compatibility reasons,
-        # but expected in new code.
-        def exec_module(self, module: types.ModuleType) -> None: ...
-
-if sys.version_info < (3, 12):
-    class Finder(metaclass=ABCMeta): ...
-
-class ResourceLoader(Loader):
-    @abstractmethod
-    def get_data(self, path: str) -> bytes: ...
-
-class InspectLoader(Loader):
-    def is_package(self, fullname: str) -> bool: ...
-    def get_code(self, fullname: str) -> types.CodeType | None: ...
-    @abstractmethod
-    def get_source(self, fullname: str) -> str | None: ...
-    def exec_module(self, module: types.ModuleType) -> None: ...
-    @staticmethod
-    def source_to_code(
-        data: ReadableBuffer | str | _ast.Module | _ast.Expression | _ast.Interactive, path: ReadableBuffer | StrPath = "<string>"
-    ) -> types.CodeType: ...
-
-class ExecutionLoader(InspectLoader):
-    @abstractmethod
-    def get_filename(self, fullname: str) -> str: ...
-
-class SourceLoader(ResourceLoader, ExecutionLoader, metaclass=ABCMeta):
-    def path_mtime(self, path: str) -> float: ...
-    def set_data(self, path: str, data: bytes) -> None: ...
-    def get_source(self, fullname: str) -> str | None: ...
-    def path_stats(self, path: str) -> Mapping[str, Any]: ...
-
-# The base classes differ starting in 3.10:
-if sys.version_info >= (3, 10):
-    # Please keep in sync with sys._MetaPathFinder
-    class MetaPathFinder(metaclass=ABCMeta):
-        if sys.version_info < (3, 12):
-            def find_module(self, fullname: str, path: Sequence[str] | None) -> Loader | None: ...
-
-        def invalidate_caches(self) -> None: ...
-        # Not defined on the actual class, but expected to exist.
-        def find_spec(
-            self, fullname: str, path: Sequence[str] | None, target: types.ModuleType | None = ..., /
-        ) -> ModuleSpec | None: ...
-
-    class PathEntryFinder(metaclass=ABCMeta):
-        if sys.version_info < (3, 12):
-            def find_module(self, fullname: str) -> Loader | None: ...
-            def find_loader(self, fullname: str) -> tuple[Loader | None, Sequence[str]]: ...
-
-        def invalidate_caches(self) -> None: ...
-        # Not defined on the actual class, but expected to exist.
-        def find_spec(self, fullname: str, target: types.ModuleType | None = ...) -> ModuleSpec | None: ...
-
-else:
-    # Please keep in sync with sys._MetaPathFinder
-    class MetaPathFinder(Finder):
-        def find_module(self, fullname: str, path: Sequence[str] | None) -> Loader | None: ...
-        def invalidate_caches(self) -> None: ...
-        # Not defined on the actual class, but expected to exist.
-        def find_spec(
-            self, fullname: str, path: Sequence[str] | None, target: types.ModuleType | None = ..., /
-        ) -> ModuleSpec | None: ...
-
-    class PathEntryFinder(Finder):
-        def find_module(self, fullname: str) -> Loader | None: ...
-        def find_loader(self, fullname: str) -> tuple[Loader | None, Sequence[str]]: ...
-        def invalidate_caches(self) -> None: ...
-        # Not defined on the actual class, but expected to exist.
-        def find_spec(self, fullname: str, target: types.ModuleType | None = ...) -> ModuleSpec | None: ...
-
-class FileLoader(ResourceLoader, ExecutionLoader, metaclass=ABCMeta):
-    name: str
-    path: str
-    def __init__(self, fullname: str, path: str) -> None: ...
-    def get_data(self, path: str) -> bytes: ...
-    def get_filename(self, name: str | None = None) -> str: ...
-    def load_module(self, name: str | None = None) -> types.ModuleType: ...
-
-class ResourceReader(metaclass=ABCMeta):
-    @abstractmethod
-    def open_resource(self, resource: str) -> IO[bytes]: ...
-    @abstractmethod
-    def resource_path(self, resource: str) -> str: ...
-    if sys.version_info >= (3, 10):
-        @abstractmethod
-        def is_resource(self, path: str) -> bool: ...
-    else:
-        @abstractmethod
-        def is_resource(self, name: str) -> bool: ...
-
-    @abstractmethod
-    def contents(self) -> Iterator[str]: ...
-
-if sys.version_info >= (3, 9):
-    @runtime_checkable
-    class Traversable(Protocol):
-        @abstractmethod
-        def is_dir(self) -> bool: ...
-        @abstractmethod
-        def is_file(self) -> bool: ...
-        @abstractmethod
-        def iterdir(self) -> Iterator[Traversable]: ...
-        if sys.version_info >= (3, 11):
-            @abstractmethod
-            def joinpath(self, *descendants: str) -> Traversable: ...
-        else:
-            @abstractmethod
-            def joinpath(self, child: str, /) -> Traversable: ...
-
-        # The documentation and runtime protocol allows *args, **kwargs arguments,
-        # but this would mean that all implementers would have to support them,
-        # which is not the case.
-        @overload
-        @abstractmethod
-        def open(self, mode: Literal["r"] = "r", /, *, encoding: str | None = None, errors: str | None = None) -> IO[str]: ...
-        @overload
-        @abstractmethod
-        def open(self, mode: Literal["rb"], /) -> IO[bytes]: ...
-        @property
-        @abstractmethod
-        def name(self) -> str: ...
-        if sys.version_info >= (3, 10):
-            def __truediv__(self, child: str, /) -> Traversable: ...
-        else:
-            @abstractmethod
-            def __truediv__(self, child: str, /) -> Traversable: ...
-
-        @abstractmethod
-        def read_bytes(self) -> bytes: ...
-        @abstractmethod
-        def read_text(self, encoding: str | None = None) -> str: ...
-
-    class TraversableResources(ResourceReader):
-        @abstractmethod
-        def files(self) -> Traversable: ...
-        def open_resource(self, resource: str) -> BufferedReader: ...
-        def resource_path(self, resource: Any) -> str: ...
-        def is_resource(self, path: str) -> bool: ...
-        def contents(self) -> Iterator[str]: ...

jaclang/vendor/mypy/typeshed/stdlib/importlib/machinery.pyi

@@ -1,179 +0,0 @@
-import importlib.abc
-import sys
-import types
-from _typeshed import ReadableBuffer
-from collections.abc import Callable, Iterable, MutableSequence, Sequence
-from importlib.metadata import DistributionFinder, PathDistribution
-from typing import Any, Literal
-from typing_extensions import deprecated
-
-class ModuleSpec:
-    def __init__(
-        self,
-        name: str,
-        loader: importlib.abc.Loader | None,
-        *,
-        origin: str | None = None,
-        loader_state: Any = None,
-        is_package: bool | None = None,
-    ) -> None: ...
-    name: str
-    loader: importlib.abc.Loader | None
-    origin: str | None
-    submodule_search_locations: list[str] | None
-    loader_state: Any
-    cached: str | None
-    @property
-    def parent(self) -> str | None: ...
-    has_location: bool
-    def __eq__(self, other: object) -> bool: ...
-
-class BuiltinImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
-    # MetaPathFinder
-    if sys.version_info < (3, 12):
-        @classmethod
-        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
-
-    @classmethod
-    def find_spec(
-        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
-    ) -> ModuleSpec | None: ...
-    # InspectLoader
-    @classmethod
-    def is_package(cls, fullname: str) -> bool: ...
-    @classmethod
-    def load_module(cls, fullname: str) -> types.ModuleType: ...
-    @classmethod
-    def get_code(cls, fullname: str) -> None: ...
-    @classmethod
-    def get_source(cls, fullname: str) -> None: ...
-    # Loader
-    if sys.version_info < (3, 12):
-        @staticmethod
-        def module_repr(module: types.ModuleType) -> str: ...
-    if sys.version_info >= (3, 10):
-        @staticmethod
-        def create_module(spec: ModuleSpec) -> types.ModuleType | None: ...
-        @staticmethod
-        def exec_module(module: types.ModuleType) -> None: ...
-    else:
-        @classmethod
-        def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None: ...
-        @classmethod
-        def exec_module(cls, module: types.ModuleType) -> None: ...
-
-class FrozenImporter(importlib.abc.MetaPathFinder, importlib.abc.InspectLoader):
-    # MetaPathFinder
-    if sys.version_info < (3, 12):
-        @classmethod
-        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
-
-    @classmethod
-    def find_spec(
-        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
-    ) -> ModuleSpec | None: ...
-    # InspectLoader
-    @classmethod
-    def is_package(cls, fullname: str) -> bool: ...
-    @classmethod
-    def load_module(cls, fullname: str) -> types.ModuleType: ...
-    @classmethod
-    def get_code(cls, fullname: str) -> None: ...
-    @classmethod
-    def get_source(cls, fullname: str) -> None: ...
-    # Loader
-    if sys.version_info < (3, 12):
-        @staticmethod
-        def module_repr(m: types.ModuleType) -> str: ...
-    if sys.version_info >= (3, 10):
-        @staticmethod
-        def create_module(spec: ModuleSpec) -> types.ModuleType | None: ...
-    else:
-        @classmethod
-        def create_module(cls, spec: ModuleSpec) -> types.ModuleType | None: ...
-
-    @staticmethod
-    def exec_module(module: types.ModuleType) -> None: ...
-
-class WindowsRegistryFinder(importlib.abc.MetaPathFinder):
-    if sys.version_info < (3, 12):
-        @classmethod
-        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
-
-    @classmethod
-    def find_spec(
-        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
-    ) -> ModuleSpec | None: ...
-
-class PathFinder:
-    if sys.version_info >= (3, 10):
-        @staticmethod
-        def invalidate_caches() -> None: ...
-    else:
-        @classmethod
-        def invalidate_caches(cls) -> None: ...
-    if sys.version_info >= (3, 10):
-        @staticmethod
-        def find_distributions(context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
-    else:
-        @classmethod
-        def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
-
-    @classmethod
-    def find_spec(
-        cls, fullname: str, path: Sequence[str] | None = None, target: types.ModuleType | None = None
-    ) -> ModuleSpec | None: ...
-    if sys.version_info < (3, 12):
-        @classmethod
-        def find_module(cls, fullname: str, path: Sequence[str] | None = None) -> importlib.abc.Loader | None: ...
-
-SOURCE_SUFFIXES: list[str]
-DEBUG_BYTECODE_SUFFIXES: list[str]
-OPTIMIZED_BYTECODE_SUFFIXES: list[str]
-BYTECODE_SUFFIXES: list[str]
-EXTENSION_SUFFIXES: list[str]
-
-def all_suffixes() -> list[str]: ...
-
-class FileFinder(importlib.abc.PathEntryFinder):
-    path: str
-    def __init__(self, path: str, *loader_details: tuple[type[importlib.abc.Loader], list[str]]) -> None: ...
-    @classmethod
-    def path_hook(
-        cls, *loader_details: tuple[type[importlib.abc.Loader], list[str]]
-    ) -> Callable[[str], importlib.abc.PathEntryFinder]: ...
-
-class SourceFileLoader(importlib.abc.FileLoader, importlib.abc.SourceLoader):
-    def set_data(self, path: str, data: ReadableBuffer, *, _mode: int = 0o666) -> None: ...
-
-class SourcelessFileLoader(importlib.abc.FileLoader, importlib.abc.SourceLoader): ...
-
-class ExtensionFileLoader(importlib.abc.ExecutionLoader):
-    def __init__(self, name: str, path: str) -> None: ...
-    def get_filename(self, name: str | None = None) -> str: ...
-    def get_source(self, fullname: str) -> None: ...
-    def create_module(self, spec: ModuleSpec) -> types.ModuleType: ...
-    def exec_module(self, module: types.ModuleType) -> None: ...
-    def get_code(self, fullname: str) -> None: ...
-    def __eq__(self, other: object) -> bool: ...
-    def __hash__(self) -> int: ...
-
-if sys.version_info >= (3, 11):
-    import importlib.readers
-
-    class NamespaceLoader(importlib.abc.InspectLoader):
-        def __init__(
-            self, name: str, path: MutableSequence[str], path_finder: Callable[[str, tuple[str, ...]], ModuleSpec]
-        ) -> None: ...
-        def is_package(self, fullname: str) -> Literal[True]: ...
-        def get_source(self, fullname: str) -> Literal[""]: ...
-        def get_code(self, fullname: str) -> types.CodeType: ...
-        def create_module(self, spec: ModuleSpec) -> None: ...
-        def exec_module(self, module: types.ModuleType) -> None: ...
-        @deprecated("load_module() is deprecated; use exec_module() instead")
-        def load_module(self, fullname: str) -> types.ModuleType: ...
-        def get_resource_reader(self, module: types.ModuleType) -> importlib.readers.NamespaceReader: ...
-        if sys.version_info < (3, 12):
-            @staticmethod
-            @deprecated("module_repr() is deprecated, and has been removed in Python 3.12")
-            def module_repr(module: types.ModuleType) -> str: ...