layermap 0.1.0

package/analyzers/project-map-python/typeshed/stdlib/http/server.pyi

@@ -0,0 +1,139 @@
+import _socket
+import email.message
+import io
+import socketserver
+import sys
+from _ssl import _PasswordType
+from _typeshed import ReadableBuffer, StrOrBytesPath, StrPath, SupportsRead, SupportsWrite
+from collections.abc import Callable, Iterable, Mapping, Sequence
+from ssl import Purpose, SSLContext
+from typing import Any, AnyStr, BinaryIO, ClassVar, Protocol, type_check_only
+from typing_extensions import Self, deprecated
+
+__all__ = ["HTTPServer", "ThreadingHTTPServer", "BaseHTTPRequestHandler", "SimpleHTTPRequestHandler"]
+if sys.version_info < (3, 15):
+    __all__ += ["CGIHTTPRequestHandler"]
+if sys.version_info >= (3, 14):
+    __all__ = ["HTTPSServer", "ThreadingHTTPSServer"]
+
+class HTTPServer(socketserver.TCPServer):
+    server_name: str
+    server_port: int
+
+class ThreadingHTTPServer(socketserver.ThreadingMixIn, HTTPServer): ...
+
+if sys.version_info >= (3, 14):
+    @type_check_only
+    class _SSLModule(Protocol):
+        @staticmethod
+        def create_default_context(
+            purpose: Purpose = ...,
+            *,
+            cafile: StrOrBytesPath | None = None,
+            capath: StrOrBytesPath | None = None,
+            cadata: str | ReadableBuffer | None = None,
+        ) -> SSLContext: ...
+
+    class HTTPSServer(HTTPServer):
+        ssl: _SSLModule
+        certfile: StrOrBytesPath
+        keyfile: StrOrBytesPath | None
+        password: _PasswordType | None
+        alpn_protocols: Iterable[str]
+        def __init__(
+            self,
+            server_address: socketserver._AfInetAddress,
+            RequestHandlerClass: Callable[[Any, _socket._RetAddress, Self], socketserver.BaseRequestHandler],
+            bind_and_activate: bool = True,
+            *,
+            certfile: StrOrBytesPath,
+            keyfile: StrOrBytesPath | None = None,
+            password: _PasswordType | None = None,
+            alpn_protocols: Iterable[str] | None = None,
+        ) -> None: ...
+        def server_activate(self) -> None: ...
+
+    class ThreadingHTTPSServer(socketserver.ThreadingMixIn, HTTPSServer): ...
+
+class BaseHTTPRequestHandler(socketserver.StreamRequestHandler):
+    client_address: tuple[str, int]
+    close_connection: bool
+    requestline: str
+    command: str
+    path: str
+    request_version: str
+    headers: email.message.Message
+    server_version: str
+    sys_version: str
+    error_message_format: str
+    error_content_type: str
+    protocol_version: str
+    MessageClass: type
+    responses: Mapping[int, tuple[str, str]]
+    if sys.version_info >= (3, 15):
+        default_content_type: str
+    default_request_version: str  # undocumented
+    weekdayname: ClassVar[Sequence[str]]  # undocumented
+    monthname: ClassVar[Sequence[str | None]]  # undocumented
+    def handle_one_request(self) -> None: ...
+    def handle_expect_100(self) -> bool: ...
+    def send_error(self, code: int, message: str | None = None, explain: str | None = None) -> None: ...
+    def send_response(self, code: int, message: str | None = None) -> None: ...
+    def send_header(self, keyword: str, value: str) -> None: ...
+    def send_response_only(self, code: int, message: str | None = None) -> None: ...
+    def end_headers(self) -> None: ...
+    def flush_headers(self) -> None: ...
+    def log_request(self, code: int | str = "-", size: int | str = "-") -> None: ...
+    def log_error(self, format: str, *args: Any) -> None: ...
+    def log_message(self, format: str, *args: Any) -> None: ...
+    def version_string(self) -> str: ...
+    def date_time_string(self, timestamp: float | None = None) -> str: ...
+    def log_date_time_string(self) -> str: ...
+    def address_string(self) -> str: ...
+    def parse_request(self) -> bool: ...  # undocumented
+
+class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
+    extensions_map: dict[str, str]
+    if sys.version_info >= (3, 12):
+        index_pages: ClassVar[tuple[str, ...]]
+    directory: str
+    if sys.version_info >= (3, 15):
+        def __init__(
+            self,
+            request: socketserver._RequestType,
+            client_address: _socket._RetAddress,
+            server: socketserver.BaseServer,
+            *,
+            directory: StrPath | None = None,
+            extra_response_headers: Mapping[str, str] | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            request: socketserver._RequestType,
+            client_address: _socket._RetAddress,
+            server: socketserver.BaseServer,
+            *,
+            directory: StrPath | None = None,
+        ) -> None: ...
+
+    def do_GET(self) -> None: ...
+    def do_HEAD(self) -> None: ...
+    def send_head(self) -> io.BytesIO | BinaryIO | None: ...  # undocumented
+    def list_directory(self, path: StrPath) -> io.BytesIO | None: ...  # undocumented
+    def translate_path(self, path: str) -> str: ...  # undocumented
+    def copyfile(self, source: SupportsRead[AnyStr], outputfile: SupportsWrite[AnyStr]) -> None: ...  # undocumented
+    def guess_type(self, path: StrPath) -> str: ...  # undocumented
+
+def executable(path: StrPath) -> bool: ...  # undocumented
+
+if sys.version_info < (3, 15):
+    @deprecated("Deprecated since Python 3.13; will be removed in Python 3.15.")
+    class CGIHTTPRequestHandler(SimpleHTTPRequestHandler):
+        cgi_directories: list[str]
+        have_fork: bool  # undocumented
+        def do_POST(self) -> None: ...
+        def is_cgi(self) -> bool: ...  # undocumented
+        def is_executable(self, path: StrPath) -> bool: ...  # undocumented
+        def is_python(self, path: StrPath) -> bool: ...  # undocumented
+        def run_cgi(self) -> None: ...  # undocumented

package/analyzers/project-map-python/typeshed/stdlib/imaplib.pyi

@@ -0,0 +1,195 @@
+import subprocess
+import sys
+import time
+from _typeshed import ReadableBuffer, SizedBuffer, StrOrBytesPath, Unused
+from builtins import list as _list  # conflicts with a method named "list"
+from collections.abc import Callable, Generator
+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, TypeAlias, overload
+from typing_extensions import Self, deprecated
+
+__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): ...
+    utf8_enabled: bool
+    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
+    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: ...
+    if sys.version_info >= (3, 14):
+        @property
+        @deprecated("IMAP4.file is unsupported, can cause errors, and may be removed.")
+        def file(self) -> IO[str] | IO[bytes]: ...
+    else:
+        file: IO[str] | IO[bytes]
+
+    def __getattr__(self, attr: str) -> Any: ...
+    host: str
+    port: int
+    sock: _socket
+    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 | None, flags: str | None, date_time: _TimeLike | None, message: ReadableBuffer
+    ) -> tuple[str, _list[bytes]]: ...
+    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: ...
+    if sys.version_info >= (3, 14):
+        def idle(self, duration: float | None = None) -> Idler: ...
+
+    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: ...
+    def unselect(self) -> _CommandResults: ...
+    def xatom(self, name: str, *args: str) -> _CommandResults: ...
+    def print_log(self) -> None: ...
+
+if sys.version_info >= (3, 14):
+    class Idler:
+        def __init__(self, imap: IMAP4, duration: float | None = None) -> None: ...
+        def __enter__(self) -> Self: ...
+        def __exit__(self, exc_type: object, exc_val: Unused, exc_tb: Unused) -> Literal[False]: ...
+        def __iter__(self) -> Self: ...
+        def __next__(self) -> tuple[str, float | None]: ...
+        def burst(self, interval: float = 0.1) -> Generator[tuple[str, float | None]]: ...
+
+class IMAP4_SSL(IMAP4):
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self, host: str = "", port: int = 993, *, ssl_context: SSLContext | None = None, timeout: float | None = None
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(
+            self,
+            host: str = "",
+            port: int = 993,
+            keyfile: None = None,
+            certfile: None = None,
+            ssl_context: SSLContext | None = None,
+            timeout: float | None = None,
+        ) -> None: ...
+        @overload
+        @deprecated(
+            "The `keyfile`, `certfile` parameters are deprecated since Python 3.6; "
+            "removed in Python 3.12. Use `ssl_context` parameter instead."
+        )
+        def __init__(
+            self,
+            host: str = "",
+            port: int = 993,
+            keyfile: StrOrBytesPath | None = None,
+            certfile: StrOrBytesPath | None = None,
+            ssl_context: None = None,
+            timeout: float | None = None,
+        ) -> None: ...
+
+        keyfile: StrOrBytesPath | None
+        certfile: StrOrBytesPath | None
+    sslobj: SSLSocket
+    if sys.version_info >= (3, 14):
+        @property
+        @deprecated("IMAP4_SSL.file is unsupported, can cause errors, and may be removed.")
+        def file(self) -> IO[Any]: ...
+    else:
+        file: IO[Any]
+
+    def open(self, host: str = "", port: int | None = 993, timeout: float | None = None) -> None: ...
+    def ssl(self) -> SSLSocket: ...
+
+class IMAP4_stream(IMAP4):
+    command: str
+    def __init__(self, command: str) -> None: ...
+    if sys.version_info >= (3, 14):
+        @property
+        @deprecated("IMAP4_stream.file is unsupported, can cause errors, and may be removed.")
+        def file(self) -> IO[Any]: ...
+    else:
+        file: IO[Any]
+    process: subprocess.Popen[bytes]
+    writefile: IO[Any]
+    readfile: IO[Any]
+    def open(self, host: str | None = None, port: int | None = None, timeout: float | 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, ...]: ...
+
+_TimeLike: TypeAlias = float | time.struct_time | time._TimeTuple | datetime | str
+
+def Time2Internaldate(date_time: _TimeLike) -> str: ...

package/analyzers/project-map-python/typeshed/stdlib/imghdr.pyi

@@ -0,0 +1,18 @@
+from _typeshed import StrPath
+from collections.abc import Callable
+from typing import Any, BinaryIO, Protocol, overload, type_check_only
+
+__all__ = ["what"]
+
+@type_check_only
+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]]

package/analyzers/project-map-python/typeshed/stdlib/imp.pyi

@@ -0,0 +1,63 @@
+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, Final, Protocol, type_check_only
+
+SEARCH_ERROR: Final = 0
+PY_SOURCE: Final = 1
+PY_COMPILED: Final = 2
+C_EXTENSION: Final = 3
+PY_RESOURCE: Final = 4
+PKG_DIRECTORY: Final = 5
+C_BUILTIN: Final = 6
+PY_FROZEN: Final = 7
+PY_CODERESOURCE: Final = 8
+IMP_HOOK: Final = 9
+
+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.
+@type_check_only
+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

package/analyzers/project-map-python/typeshed/stdlib/importlib/__init__.pyi

@@ -0,0 +1,17 @@
+import sys
+from importlib._bootstrap import __import__ as __import__
+from importlib.abc import Loader
+from types import ModuleType
+from typing_extensions import deprecated
+
+__all__ = ["__import__", "import_module", "invalidate_caches", "reload"]
+
+# `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):
+    @deprecated("Deprecated since Python 3.4; removed in Python 3.12. Use `importlib.util.find_spec()` instead.")
+    def find_loader(name: str, path: str | None = None) -> Loader | None: ...
+
+def invalidate_caches() -> None: ...
+def reload(module: ModuleType) -> ModuleType: ...

package/analyzers/project-map-python/typeshed/stdlib/importlib/_abc.pyi

@@ -0,0 +1,19 @@
+import sys
+import types
+from abc import ABCMeta
+from importlib.machinery import ModuleSpec
+from typing_extensions import deprecated
+
+class Loader(metaclass=ABCMeta):
+    def load_module(self, fullname: str) -> types.ModuleType: ...
+    if sys.version_info < (3, 12):
+        @deprecated(
+            "Deprecated since Python 3.4; removed in Python 3.12. "
+            "The module spec is now used by the import machinery to generate a module repr."
+        )
+        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: ...

package/analyzers/project-map-python/typeshed/stdlib/importlib/_bootstrap.pyi

@@ -0,0 +1,2 @@
+from _frozen_importlib import *
+from _frozen_importlib import __import__ as __import__, _init_module_attrs as _init_module_attrs

package/analyzers/project-map-python/typeshed/stdlib/importlib/_bootstrap_external.pyi

@@ -0,0 +1,2 @@
+from _frozen_importlib_external import *
+from _frozen_importlib_external import _NamespaceLoader as _NamespaceLoader

package/analyzers/project-map-python/typeshed/stdlib/importlib/abc.pyi

@@ -0,0 +1,150 @@
+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 import _bootstrap_external
+from importlib._abc import Loader as Loader
+from importlib.machinery import ModuleSpec
+from io import BufferedReader
+from typing import IO, Any, Literal, Protocol, overload, runtime_checkable
+from typing_extensions import deprecated
+
+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, 12):
+    @deprecated("Deprecated since Python 3.3; removed in Python 3.12. Use `MetaPathFinder` or `PathEntryFinder` instead.")
+    class Finder(metaclass=ABCMeta): ...
+
+@deprecated("Deprecated since Python 3.7. Use `importlib.resources.abc.TraversableResources` instead.")
+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: bytes | StrPath = "<string>"
+    ) -> types.CodeType: ...
+
+class ExecutionLoader(InspectLoader):
+    @abstractmethod
+    def get_filename(self, fullname: str) -> str: ...
+
+class SourceLoader(_bootstrap_external.SourceLoader, ResourceLoader, ExecutionLoader, metaclass=ABCMeta):  # type: ignore[misc]  # incompatible definitions of source_to_code in the base classes
+    @deprecated("Deprecated since Python 3.3. Use `importlib.resources.abc.SourceLoader.path_stats` instead.")
+    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]: ...
+
+# Please keep in sync with _typeshed.importlib.MetaPathFinderProtocol
+class MetaPathFinder(metaclass=ABCMeta):
+    if sys.version_info < (3, 12):
+        @deprecated("Deprecated since Python 3.4; removed in Python 3.12. Use `MetaPathFinder.find_spec()` instead.")
+        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):
+        @deprecated("Deprecated since Python 3.4; removed in Python 3.12. Use `PathEntryFinder.find_spec()` instead.")
+        def find_module(self, fullname: str) -> Loader | None: ...
+        @deprecated("Deprecated since Python 3.4; removed in Python 3.12. Use `find_spec()` instead.")
+        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(_bootstrap_external.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, fullname: str | None = None) -> str: ...
+    def load_module(self, fullname: str | None = None) -> types.ModuleType: ...
+
+if sys.version_info < (3, 11):
+    class ResourceReader(metaclass=ABCMeta):
+        @abstractmethod
+        def open_resource(self, resource: str) -> IO[bytes]: ...
+        @abstractmethod
+        def resource_path(self, resource: str) -> str: ...
+        @abstractmethod
+        def is_resource(self, path: str) -> bool: ...
+        @abstractmethod
+        def contents(self) -> Iterator[str]: ...
+
+    @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: ...
+        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]: ...
+
+elif sys.version_info < (3, 14):
+    from importlib.resources.abc import (
+        ResourceReader as ResourceReader,
+        Traversable as Traversable,
+        TraversableResources as TraversableResources,
+    )

package/analyzers/project-map-python/typeshed/stdlib/importlib/machinery.pyi

@@ -0,0 +1,43 @@
+import sys
+from importlib._bootstrap import BuiltinImporter as BuiltinImporter, FrozenImporter as FrozenImporter, ModuleSpec as ModuleSpec
+from importlib._bootstrap_external import (
+    BYTECODE_SUFFIXES as BYTECODE_SUFFIXES,
+    DEBUG_BYTECODE_SUFFIXES as DEBUG_BYTECODE_SUFFIXES,
+    EXTENSION_SUFFIXES as EXTENSION_SUFFIXES,
+    OPTIMIZED_BYTECODE_SUFFIXES as OPTIMIZED_BYTECODE_SUFFIXES,
+    SOURCE_SUFFIXES as SOURCE_SUFFIXES,
+    ExtensionFileLoader as ExtensionFileLoader,
+    FileFinder as FileFinder,
+    PathFinder as PathFinder,
+    SourceFileLoader as SourceFileLoader,
+    SourcelessFileLoader as SourcelessFileLoader,
+    WindowsRegistryFinder as WindowsRegistryFinder,
+)
+
+if sys.version_info >= (3, 11):
+    from importlib._bootstrap_external import NamespaceLoader as NamespaceLoader
+if sys.version_info >= (3, 14):
+    from importlib._bootstrap_external import AppleFrameworkLoader as AppleFrameworkLoader
+
+def all_suffixes() -> list[str]: ...
+
+if sys.version_info >= (3, 14):
+    __all__ = [
+        "AppleFrameworkLoader",
+        "BYTECODE_SUFFIXES",
+        "BuiltinImporter",
+        "DEBUG_BYTECODE_SUFFIXES",
+        "EXTENSION_SUFFIXES",
+        "ExtensionFileLoader",
+        "FileFinder",
+        "FrozenImporter",
+        "ModuleSpec",
+        "NamespaceLoader",
+        "OPTIMIZED_BYTECODE_SUFFIXES",
+        "PathFinder",
+        "SOURCE_SUFFIXES",
+        "SourceFileLoader",
+        "SourcelessFileLoader",
+        "WindowsRegistryFinder",
+        "all_suffixes",
+    ]