layermap 0.1.0

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

@@ -0,0 +1,310 @@
+import abc
+import pathlib
+import sys
+import types
+from _collections_abc import dict_keys, dict_values
+from _typeshed import StrPath
+from collections.abc import Iterable, Iterator, Mapping
+from importlib.abc import MetaPathFinder
+from importlib.metadata._meta import PackageMetadata as PackageMetadata, SimplePath
+from os import PathLike
+from re import Pattern
+from typing import Any, ClassVar, Generic, NamedTuple, TypeAlias, TypeVar, overload, type_check_only
+from typing_extensions import Self, deprecated, disjoint_base
+
+_T = TypeVar("_T")
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+
+__all__ = [
+    "Distribution",
+    "DistributionFinder",
+    "PackageMetadata",
+    "PackageNotFoundError",
+    "distribution",
+    "distributions",
+    "entry_points",
+    "files",
+    "metadata",
+    "packages_distributions",
+    "requires",
+    "version",
+]
+
+if sys.version_info >= (3, 15):
+    __all__ += ["PackagePath", "MetadataNotFound", "SimplePath"]
+
+_SimplePath: TypeAlias = SimplePath
+
+def packages_distributions() -> Mapping[str, list[str]]: ...
+
+class PackageNotFoundError(ModuleNotFoundError):
+    @property
+    def name(self) -> str: ...  # type: ignore[override]
+
+if sys.version_info >= (3, 15):
+    class MetadataNotFound(FileNotFoundError): ...
+
+if sys.version_info >= (3, 13):
+    _EntryPointBase = object
+elif sys.version_info >= (3, 11):
+    class DeprecatedTuple:
+        def __getitem__(self, item: int) -> str: ...
+
+    _EntryPointBase = DeprecatedTuple
+else:
+    @type_check_only
+    class _EntryPointBase(NamedTuple):
+        name: str
+        value: str
+        group: str
+
+if sys.version_info >= (3, 11):
+    class EntryPoint(_EntryPointBase):
+        pattern: ClassVar[Pattern[str]]
+        name: str
+        value: str
+        group: str
+
+        def __init__(self, name: str, value: str, group: str) -> None: ...
+        def load(self) -> Any: ...  # Callable[[], Any] or an importable module
+        @property
+        def extras(self) -> list[str]: ...
+        @property
+        def module(self) -> str: ...
+        @property
+        def attr(self) -> str: ...
+        dist: ClassVar[Distribution | None]
+        def matches(
+            self,
+            *,
+            name: str = ...,
+            value: str = ...,
+            group: str = ...,
+            module: str = ...,
+            attr: str = ...,
+            extras: list[str] = ...,
+        ) -> bool: ...  # undocumented
+        def __hash__(self) -> int: ...
+        def __eq__(self, other: object) -> bool: ...
+        def __lt__(self, other: object) -> bool: ...
+        if sys.version_info < (3, 12):
+            def __iter__(self) -> Iterator[Any]: ...  # result of iter((str, Self)), really
+
+else:
+    @disjoint_base
+    class EntryPoint(_EntryPointBase):
+        pattern: ClassVar[Pattern[str]]
+
+        def load(self) -> Any: ...  # Callable[[], Any] or an importable module
+        @property
+        def extras(self) -> list[str]: ...
+        @property
+        def module(self) -> str: ...
+        @property
+        def attr(self) -> str: ...
+        dist: ClassVar[Distribution | None]
+        def matches(
+            self,
+            *,
+            name: str = ...,
+            value: str = ...,
+            group: str = ...,
+            module: str = ...,
+            attr: str = ...,
+            extras: list[str] = ...,
+        ) -> bool: ...  # undocumented
+        def __hash__(self) -> int: ...
+        def __iter__(self) -> Iterator[Any]: ...  # result of iter((str, Self)), really
+
+if sys.version_info >= (3, 12):
+    class EntryPoints(tuple[EntryPoint, ...]):
+        __slots__ = ()
+        def __getitem__(self, name: str) -> EntryPoint: ...  # type: ignore[override]
+        def select(
+            self,
+            *,
+            name: str = ...,
+            value: str = ...,
+            group: str = ...,
+            module: str = ...,
+            attr: str = ...,
+            extras: list[str] = ...,
+        ) -> EntryPoints: ...
+        @property
+        def names(self) -> set[str]: ...
+        @property
+        def groups(self) -> set[str]: ...
+
+else:
+    class DeprecatedList(list[_T]):
+        __slots__ = ()
+
+    class EntryPoints(DeprecatedList[EntryPoint]):  # use as list is deprecated since 3.10
+        # int argument is deprecated since 3.10
+        __slots__ = ()
+        def __getitem__(self, name: int | str) -> EntryPoint: ...  # type: ignore[override]
+        def select(
+            self,
+            *,
+            name: str = ...,
+            value: str = ...,
+            group: str = ...,
+            module: str = ...,
+            attr: str = ...,
+            extras: list[str] = ...,
+        ) -> EntryPoints: ...
+        @property
+        def names(self) -> set[str]: ...
+        @property
+        def groups(self) -> set[str]: ...
+
+if sys.version_info < (3, 12):
+    class Deprecated(Generic[_KT, _VT]):
+        def __getitem__(self, name: _KT) -> _VT: ...
+
+        @overload
+        def get(self, name: _KT, default: None = None) -> _VT | None: ...
+        @overload
+        def get(self, name: _KT, default: _VT) -> _VT: ...
+        @overload
+        def get(self, name: _KT, default: _T) -> _VT | _T: ...
+
+        def __iter__(self) -> Iterator[_KT]: ...
+        def __contains__(self, *args: object) -> bool: ...
+        def keys(self) -> dict_keys[_KT, _VT]: ...
+        def values(self) -> dict_values[_KT, _VT]: ...
+
+    @deprecated("Deprecated since Python 3.10; removed in Python 3.12. Use `select` instead.")
+    class SelectableGroups(Deprecated[str, EntryPoints], dict[str, EntryPoints]):  # use as dict is deprecated since 3.10
+        @classmethod
+        def load(cls, eps: Iterable[EntryPoint]) -> Self: ...
+        @property
+        def groups(self) -> set[str]: ...
+        @property
+        def names(self) -> set[str]: ...
+
+        @overload
+        def select(self) -> Self: ...
+        @overload
+        def select(
+            self,
+            *,
+            name: str = ...,
+            value: str = ...,
+            group: str = ...,
+            module: str = ...,
+            attr: str = ...,
+            extras: list[str] = ...,
+        ) -> EntryPoints: ...
+
+class PackagePath(pathlib.PurePosixPath):
+    def read_text(self, encoding: str = "utf-8") -> str: ...
+    def read_binary(self) -> bytes: ...
+    def locate(self) -> PathLike[str]: ...
+    # The following attributes are not defined on PackagePath, but are dynamically added by Distribution.files:
+    hash: FileHash | None
+    size: int | None
+    dist: Distribution
+
+class FileHash:
+    mode: str
+    value: str
+    def __init__(self, spec: str) -> None: ...
+
+if sys.version_info >= (3, 15):
+    _distribution_parent = abc.ABC
+elif sys.version_info >= (3, 12):
+    class DeprecatedNonAbstract: ...
+    _distribution_parent = DeprecatedNonAbstract
+else:
+    _distribution_parent = object
+
+class Distribution(_distribution_parent):
+    @abc.abstractmethod
+    def read_text(self, filename: str) -> str | None: ...
+    @abc.abstractmethod
+    def locate_file(self, path: StrPath) -> _SimplePath: ...
+    @classmethod
+    def from_name(cls, name: str) -> Distribution: ...
+
+    @overload
+    @classmethod
+    def discover(cls, *, context: DistributionFinder.Context) -> Iterable[Distribution]: ...
+    @overload
+    @classmethod
+    def discover(
+        cls, *, context: None = None, name: str | None = ..., path: list[str] = ..., **kwargs: Any
+    ) -> Iterable[Distribution]: ...
+
+    @staticmethod
+    def at(path: StrPath) -> PathDistribution: ...
+    @property
+    def metadata(self) -> PackageMetadata: ...
+    @property
+    def entry_points(self) -> EntryPoints: ...
+    @property
+    def version(self) -> str: ...
+    @property
+    def files(self) -> list[PackagePath] | None: ...
+    @property
+    def requires(self) -> list[str] | None: ...
+    @property
+    def name(self) -> str: ...
+    if sys.version_info >= (3, 13):
+        @property
+        def origin(self) -> types.SimpleNamespace | None: ...
+
+class DistributionFinder(MetaPathFinder):
+    class Context:
+        name: str | None
+        def __init__(self, *, name: str | None = ..., path: list[str] = ..., **kwargs: Any) -> None: ...
+        @property
+        def path(self) -> list[str]: ...
+
+    @abc.abstractmethod
+    def find_distributions(self, context: DistributionFinder.Context = ...) -> Iterable[Distribution]: ...
+
+class MetadataPathFinder(DistributionFinder):
+    @classmethod
+    def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
+    if sys.version_info >= (3, 11):
+        @classmethod
+        def invalidate_caches(cls) -> None: ...
+    else:
+        # Yes, this is an instance method that has a parameter named "cls"
+        def invalidate_caches(cls) -> None: ...
+
+class PathDistribution(Distribution):
+    _path: _SimplePath
+    def __init__(self, path: _SimplePath) -> None: ...
+    def read_text(self, filename: StrPath) -> str | None: ...
+    def locate_file(self, path: StrPath) -> _SimplePath: ...
+
+def distribution(distribution_name: str) -> Distribution: ...
+
+@overload
+def distributions(*, context: DistributionFinder.Context) -> Iterable[Distribution]: ...
+@overload
+def distributions(
+    *, context: None = None, name: str | None = ..., path: list[str] = ..., **kwargs: Any
+) -> Iterable[Distribution]: ...
+
+def metadata(distribution_name: str) -> PackageMetadata: ...
+
+if sys.version_info >= (3, 12):
+    def entry_points(
+        *, name: str = ..., value: str = ..., group: str = ..., module: str = ..., attr: str = ..., extras: list[str] = ...
+    ) -> EntryPoints: ...
+
+else:
+    @overload
+    def entry_points() -> SelectableGroups: ...
+    @overload
+    def entry_points(
+        *, name: str = ..., value: str = ..., group: str = ..., module: str = ..., attr: str = ..., extras: list[str] = ...
+    ) -> EntryPoints: ...
+
+def version(distribution_name: str) -> str: ...
+def files(distribution_name: str) -> list[PackagePath] | None: ...
+def requires(distribution_name: str) -> list[str] | None: ...

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

@@ -0,0 +1,65 @@
+import sys
+from _typeshed import StrPath
+from collections.abc import Iterator
+from os import PathLike
+from typing import Any, Protocol, overload
+from typing_extensions import TypeVar
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True, default=Any)
+
+class PackageMetadata(Protocol):
+    def __len__(self) -> int: ...
+    def __contains__(self, item: str) -> bool: ...
+    def __getitem__(self, key: str) -> str: ...
+    def __iter__(self) -> Iterator[str]: ...
+    @property
+    def json(self) -> dict[str, str | list[str]]: ...
+
+    @overload
+    def get_all(self, name: str, failobj: None = None) -> list[Any] | None: ...
+    @overload
+    def get_all(self, name: str, failobj: _T) -> list[Any] | _T: ...
+
+    if sys.version_info >= (3, 12):
+        @overload
+        def get(self, name: str, failobj: None = None) -> str | None: ...
+        @overload
+        def get(self, name: str, failobj: _T) -> _T | str: ...
+
+if sys.version_info >= (3, 13):
+    class SimplePath(Protocol):
+        def joinpath(self, other: StrPath, /) -> SimplePath: ...
+        def __truediv__(self, other: StrPath, /) -> SimplePath: ...
+        # Incorrect at runtime
+        @property
+        def parent(self) -> PathLike[str]: ...
+        def read_text(self, encoding: str | None = None) -> str: ...
+        def read_bytes(self) -> bytes: ...
+        def exists(self) -> bool: ...
+
+elif sys.version_info >= (3, 12):
+    class SimplePath(Protocol[_T_co]):
+        # At runtime this is defined as taking `str | _T`, but that causes trouble.
+        # See #11436.
+        def joinpath(self, other: str, /) -> _T_co: ...
+        @property
+        def parent(self) -> _T_co: ...
+        def read_text(self) -> str: ...
+        # As with joinpath(), this is annotated as taking `str | _T` at runtime.
+        def __truediv__(self, other: str, /) -> _T_co: ...
+
+else:
+    class SimplePath(Protocol):
+        # Actually takes only self at runtime, but that's clearly wrong
+        def joinpath(self, other: Any, /) -> SimplePath: ...
+        # Not defined as a property at runtime, but it should be
+        @property
+        def parent(self) -> Any: ...
+        def read_text(self) -> str: ...
+        # There was a bug in `SimplePath` definition in cpython, see #8451
+        #  Strictly speaking `__div__` was defined in 3.10, not __truediv__,
+        # but it should have always been `__truediv__`.
+        # Also, the runtime defines this method as taking no arguments,
+        # which is obviously wrong.
+        def __truediv__(self, other: Any, /) -> SimplePath: ...

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

@@ -0,0 +1,2 @@
+def inspect(path: str) -> None: ...
+def run() -> None: ...

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

@@ -0,0 +1,69 @@
+# On py311+, things are actually defined in importlib.resources.readers,
+# and re-exported here,
+# but doing it this way leads to less code duplication for us
+
+import pathlib
+import sys
+import zipfile
+from _typeshed import StrPath
+from collections.abc import Iterable, Iterator
+from importlib._bootstrap_external import FileLoader
+from io import BufferedReader
+from typing import Literal, NoReturn, TypeVar
+from typing_extensions import Never
+from zipimport import zipimporter
+
+if sys.version_info >= (3, 11):
+    from importlib.resources import abc
+else:
+    from importlib import abc
+
+if sys.version_info >= (3, 11):
+    __all__ = ["FileReader", "ZipReader", "MultiplexedPath", "NamespaceReader"]
+
+if sys.version_info < (3, 11):
+    _T = TypeVar("_T")
+
+    def remove_duplicates(items: Iterable[_T]) -> Iterator[_T]: ...
+
+class FileReader(abc.TraversableResources):
+    path: pathlib.Path
+    def __init__(self, loader: FileLoader) -> None: ...
+    def resource_path(self, resource: StrPath) -> str: ...
+    def files(self) -> pathlib.Path: ...
+
+class ZipReader(abc.TraversableResources):
+    prefix: str
+    archive: str
+    def __init__(self, loader: zipimporter, module: str) -> None: ...
+    def open_resource(self, resource: str) -> BufferedReader: ...
+    def is_resource(self, path: StrPath) -> bool: ...
+    def files(self) -> zipfile.Path: ...
+
+class MultiplexedPath(abc.Traversable):
+    def __init__(self, *paths: abc.Traversable) -> None: ...
+    def iterdir(self) -> Iterator[abc.Traversable]: ...
+    def read_bytes(self) -> NoReturn: ...
+    def read_text(self, *args: Never, **kwargs: Never) -> NoReturn: ...  # type: ignore[override]
+    def is_dir(self) -> Literal[True]: ...
+    def is_file(self) -> Literal[False]: ...
+
+    if sys.version_info >= (3, 12):
+        def joinpath(self, *descendants: StrPath) -> abc.Traversable: ...
+    elif sys.version_info >= (3, 11):
+        def joinpath(self, child: StrPath) -> abc.Traversable: ...  # type: ignore[override]
+    else:
+        def joinpath(self, child: str) -> abc.Traversable: ...
+
+    if sys.version_info < (3, 12):
+        __truediv__ = joinpath
+
+    def open(self, *args: Never, **kwargs: Never) -> NoReturn: ...  # type: ignore[override]
+    @property
+    def name(self) -> str: ...
+
+class NamespaceReader(abc.TraversableResources):
+    path: MultiplexedPath
+    def __init__(self, namespace_path: Iterable[str]) -> None: ...
+    def resource_path(self, resource: str) -> str: ...
+    def files(self) -> MultiplexedPath: ...

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

@@ -0,0 +1,81 @@
+import os
+import sys
+from collections.abc import Iterator
+from contextlib import AbstractContextManager
+from pathlib import Path
+from types import ModuleType
+from typing import Any, BinaryIO, Literal, TextIO, TypeAlias
+from typing_extensions import deprecated
+
+if sys.version_info >= (3, 11):
+    from importlib.resources.abc import Traversable
+else:
+    from importlib.abc import Traversable
+
+if sys.version_info >= (3, 11):
+    from importlib.resources._common import Package as Package
+else:
+    Package: TypeAlias = str | ModuleType
+
+__all__ = [
+    "Package",
+    "ResourceReader",
+    "as_file",
+    "contents",
+    "files",
+    "is_resource",
+    "open_binary",
+    "open_text",
+    "path",
+    "read_binary",
+    "read_text",
+]
+
+if sys.version_info < (3, 13):
+    __all__ += ["Resource"]
+
+if sys.version_info < (3, 11):
+    Resource: TypeAlias = str | os.PathLike[Any]
+elif sys.version_info < (3, 13):
+    Resource: TypeAlias = str
+
+if sys.version_info >= (3, 12):
+    from importlib.resources._common import Anchor as Anchor
+
+    __all__ += ["Anchor"]
+
+if sys.version_info >= (3, 13):
+    from importlib.resources._functional import (
+        contents as contents,
+        is_resource as is_resource,
+        open_binary as open_binary,
+        open_text as open_text,
+        path as path,
+        read_binary as read_binary,
+        read_text as read_text,
+    )
+
+else:
+    def open_binary(package: Package, resource: Resource) -> BinaryIO: ...
+    def open_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> TextIO: ...
+    def read_binary(package: Package, resource: Resource) -> bytes: ...
+    def read_text(package: Package, resource: Resource, encoding: str = "utf-8", errors: str = "strict") -> str: ...
+    def path(package: Package, resource: Resource) -> AbstractContextManager[Path, Literal[False]]: ...
+    def is_resource(package: Package, name: str) -> bool: ...
+    @deprecated("Deprecated since Python 3.11. Use `files(anchor).iterdir()`.")
+    def contents(package: Package) -> Iterator[str]: ...
+
+if sys.version_info >= (3, 11):
+    from importlib.resources._common import as_file as as_file
+else:
+    def as_file(path: Traversable) -> AbstractContextManager[Path, Literal[False]]: ...
+
+if sys.version_info >= (3, 11):
+    from importlib.resources._common import files as files
+else:
+    def files(package: Package) -> Traversable: ...
+
+if sys.version_info >= (3, 11):
+    from importlib.resources.abc import ResourceReader as ResourceReader
+else:
+    from importlib.abc import ResourceReader as ResourceReader

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

@@ -0,0 +1,43 @@
+import sys
+
+# Even though this file is 3.11+ only, Pyright will complain in stubtest for older versions.
+if sys.version_info >= (3, 11):
+    import types
+    from collections.abc import Callable
+    from contextlib import AbstractContextManager
+    from importlib.resources.abc import ResourceReader, Traversable
+    from pathlib import Path
+    from typing import Literal, TypeAlias, overload
+    from typing_extensions import deprecated
+
+    Package: TypeAlias = str | types.ModuleType
+
+    if sys.version_info >= (3, 12):
+        Anchor: TypeAlias = Package
+
+        def package_to_anchor(
+            func: Callable[[Anchor | None], Traversable],
+        ) -> Callable[[Anchor | None, Anchor | None], Traversable]: ...
+
+        @overload
+        def files(anchor: Anchor | None = None) -> Traversable: ...
+        @overload
+        @deprecated("Deprecated since Python 3.12; will be removed in Python 3.15. Use `anchor` parameter instead.")
+        def files(package: Anchor | None = None) -> Traversable: ...
+
+    else:
+        def files(package: Package) -> Traversable: ...
+
+    def get_resource_reader(package: types.ModuleType) -> ResourceReader | None: ...
+
+    if sys.version_info >= (3, 12):
+        def resolve(cand: Anchor | None) -> types.ModuleType: ...
+
+    else:
+        def resolve(cand: Package) -> types.ModuleType: ...
+
+    if sys.version_info < (3, 12):
+        def get_package(package: Package) -> types.ModuleType: ...
+
+    def from_package(package: types.ModuleType) -> Traversable: ...
+    def as_file(path: Traversable) -> AbstractContextManager[Path, Literal[False]]: ...

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

@@ -0,0 +1,35 @@
+import sys
+
+# Even though this file is 3.13+ only, Pyright will complain in stubtest for older versions.
+if sys.version_info >= (3, 13):
+    from _typeshed import StrPath
+    from collections.abc import Iterator
+    from contextlib import AbstractContextManager
+    from importlib.resources._common import Anchor
+    from io import TextIOWrapper
+    from pathlib import Path
+    from typing import BinaryIO, Literal, overload
+    from typing_extensions import Unpack, deprecated
+
+    def open_binary(anchor: Anchor, *path_names: StrPath) -> BinaryIO: ...
+
+    @overload
+    def open_text(
+        anchor: Anchor, *path_names: Unpack[tuple[StrPath]], encoding: str | None = "utf-8", errors: str | None = "strict"
+    ) -> TextIOWrapper: ...
+    @overload
+    def open_text(anchor: Anchor, *path_names: StrPath, encoding: str | None, errors: str | None = "strict") -> TextIOWrapper: ...
+
+    def read_binary(anchor: Anchor, *path_names: StrPath) -> bytes: ...
+
+    @overload
+    def read_text(
+        anchor: Anchor, *path_names: Unpack[tuple[StrPath]], encoding: str | None = "utf-8", errors: str | None = "strict"
+    ) -> str: ...
+    @overload
+    def read_text(anchor: Anchor, *path_names: StrPath, encoding: str | None, errors: str | None = "strict") -> str: ...
+
+    def path(anchor: Anchor, *path_names: StrPath) -> AbstractContextManager[Path, Literal[False]]: ...
+    def is_resource(anchor: Anchor, *path_names: StrPath) -> bool: ...
+    @deprecated("Deprecated since Python 3.11. Use `files(anchor).iterdir()`.")
+    def contents(anchor: Anchor, *path_names: StrPath) -> Iterator[str]: ...

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

@@ -0,0 +1,64 @@
+import sys
+from _typeshed import StrPath
+from abc import ABCMeta, abstractmethod
+from collections.abc import Iterator
+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):
+    @deprecated("Deprecated since Python 3.12. Use `importlib.resources.abc.TraversableResources` instead.")
+    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]: ...
+        @abstractmethod
+        def joinpath(self, *descendants: StrPath) -> 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: StrPath, /) -> Traversable: ...
+        @abstractmethod
+        def read_bytes(self) -> bytes: ...
+
+        if sys.version_info >= (3, 15):
+            @abstractmethod
+            def read_text(self, encoding: str | None = None, errors: str | None = None) -> str: ...
+        else:
+            @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]: ...
+
+    __all__ = ["ResourceReader", "Traversable", "TraversableResources"]

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

@@ -0,0 +1,14 @@
+# On py311+, things are actually defined here
+# and re-exported from importlib.readers,
+# but doing it this way leads to less code duplication for us
+
+import sys
+from collections.abc import Iterable, Iterator
+from typing import TypeVar
+
+if sys.version_info >= (3, 11):
+    from importlib.readers import *
+
+    _T = TypeVar("_T")
+
+    def remove_duplicates(items: Iterable[_T]) -> Iterator[_T]: ...