mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/typeshed/stdlib/importlib/machinery.pyi

@@ -0,0 +1,179 @@
+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: ...

mypy/typeshed/stdlib/importlib/metadata/__init__.pyi

@@ -0,0 +1,276 @@
+import abc
+import pathlib
+import sys
+from _collections_abc import dict_keys, dict_values
+from _typeshed import StrPath
+from collections.abc import Iterable, Iterator, Mapping
+from email.message import Message
+from importlib.abc import MetaPathFinder
+from os import PathLike
+from pathlib import Path
+from re import Pattern
+from typing import Any, ClassVar, Generic, NamedTuple, TypeVar, overload
+from typing_extensions import Self
+
+_T = TypeVar("_T")
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+
+__all__ = [
+    "Distribution",
+    "DistributionFinder",
+    "PackageNotFoundError",
+    "distribution",
+    "distributions",
+    "entry_points",
+    "files",
+    "metadata",
+    "requires",
+    "version",
+]
+
+if sys.version_info >= (3, 10):
+    __all__ += ["PackageMetadata", "packages_distributions"]
+
+if sys.version_info >= (3, 10):
+    from importlib.metadata._meta import PackageMetadata as PackageMetadata
+    def packages_distributions() -> Mapping[str, list[str]]: ...
+
+class PackageNotFoundError(ModuleNotFoundError):
+    @property
+    def name(self) -> str: ...  # type: ignore[override]
+
+if sys.version_info >= (3, 11):
+    class DeprecatedTuple:
+        def __getitem__(self, item: int) -> str: ...
+    _EntryPointBase = DeprecatedTuple
+else:
+    class _EntryPointBase(NamedTuple):
+        name: str
+        value: str
+        group: str
+
+class EntryPoint(_EntryPointBase):
+    pattern: ClassVar[Pattern[str]]
+    if sys.version_info >= (3, 11):
+        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]: ...
+    if sys.version_info >= (3, 9):
+        @property
+        def module(self) -> str: ...
+        @property
+        def attr(self) -> str: ...
+    if sys.version_info >= (3, 10):
+        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: ...
+    if sys.version_info >= (3, 11):
+        def __lt__(self, other: object) -> bool: ...
+    if sys.version_info < (3, 12):
+        def __iter__(self) -> Iterator[Any]: ...  # result of iter((str, Self)), really
+
+if sys.version_info >= (3, 12):
+    class EntryPoints(tuple[EntryPoint, ...]):
+        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]: ...
+
+elif sys.version_info >= (3, 10):
+    class DeprecatedList(list[_T]): ...
+
+    class EntryPoints(DeprecatedList[EntryPoint]):  # use as list is deprecated since 3.10
+        # int argument is deprecated since 3.10
+        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, 10) and sys.version_info < (3, 12):
+    class Deprecated(Generic[_KT, _VT]):
+        def __getitem__(self, name: _KT) -> _VT: ...
+        @overload
+        def get(self, name: _KT) -> _VT | None: ...
+        @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]: ...
+
+    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: ...  # type: ignore[misc]
+        @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, 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) -> PathLike[str]: ...
+    @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: ...
+
+    if sys.version_info >= (3, 10):
+        @property
+        def metadata(self) -> PackageMetadata: ...
+        @property
+        def entry_points(self) -> EntryPoints: ...
+    else:
+        @property
+        def metadata(self) -> Message: ...
+        @property
+        def entry_points(self) -> list[EntryPoint]: ...
+
+    @property
+    def version(self) -> str: ...
+    @property
+    def files(self) -> list[PackagePath] | None: ...
+    @property
+    def requires(self) -> list[str] | None: ...
+    if sys.version_info >= (3, 10):
+        @property
+        def name(self) -> str: ...
+
+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, 10):
+        # Yes, this is an instance method that has argumend named "cls"
+        def invalidate_caches(cls) -> None: ...
+
+class PathDistribution(Distribution):
+    _path: Path
+    def __init__(self, path: Path) -> None: ...
+    def read_text(self, filename: StrPath) -> str: ...
+    def locate_file(self, path: StrPath) -> PathLike[str]: ...
+
+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]: ...
+
+if sys.version_info >= (3, 10):
+    def metadata(distribution_name: str) -> PackageMetadata: ...
+
+else:
+    def metadata(distribution_name: str) -> Message: ...
+
+if sys.version_info >= (3, 12):
+    def entry_points(
+        *, name: str = ..., value: str = ..., group: str = ..., module: str = ..., attr: str = ..., extras: list[str] = ...
+    ) -> EntryPoints: ...
+
+elif sys.version_info >= (3, 10):
+    @overload
+    def entry_points() -> SelectableGroups: ...  # type: ignore[overload-overlap]
+    @overload
+    def entry_points(
+        *, name: str = ..., value: str = ..., group: str = ..., module: str = ..., attr: str = ..., extras: list[str] = ...
+    ) -> EntryPoints: ...
+
+else:
+    def entry_points() -> dict[str, list[EntryPoint]]: ...
+
+def version(distribution_name: str) -> str: ...
+def files(distribution_name: str) -> list[PackagePath] | None: ...
+def requires(distribution_name: str) -> list[str] | None: ...

mypy/typeshed/stdlib/importlib/metadata/_meta.pyi

@@ -0,0 +1,40 @@
+import sys
+from collections.abc import Iterator
+from typing import Any, Protocol, TypeVar, overload
+
+_T = TypeVar("_T")
+
+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, 12):
+    class SimplePath(Protocol[_T]):
+        def joinpath(self) -> _T: ...
+        @property
+        def parent(self) -> _T: ...
+        def read_text(self) -> str: ...
+        def __truediv__(self, other: _T | str) -> _T: ...
+
+else:
+    class SimplePath(Protocol):
+        def joinpath(self) -> SimplePath: ...
+        def parent(self) -> SimplePath: ...
+        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__`.
+        def __truediv__(self) -> SimplePath: ...

mypy/typeshed/stdlib/importlib/readers.pyi

@@ -0,0 +1,68 @@
+# 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 Incomplete, StrPath
+from collections.abc import Iterable, Iterator
+from io import BufferedReader
+from typing import Literal, NoReturn, TypeVar
+from typing_extensions import Never
+
+if sys.version_info >= (3, 11):
+    import importlib.resources.abc as abc
+else:
+    import importlib.abc as abc
+
+if sys.version_info >= (3, 10):
+    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) -> None: ...
+        def resource_path(self, resource: StrPath) -> str: ...
+        def files(self) -> pathlib.Path: ...
+
+    class ZipReader(abc.TraversableResources):
+        prefix: str
+        archive: Incomplete
+        def __init__(self, loader, 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: str) -> abc.Traversable: ...
+        elif sys.version_info >= (3, 11):
+            def joinpath(self, child: str) -> 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) -> None: ...
+        def resource_path(self, resource: str) -> str: ...
+        def files(self) -> MultiplexedPath: ...

mypy/typeshed/stdlib/importlib/resources/__init__.pyi

@@ -0,0 +1,46 @@
+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, TextIO
+from typing_extensions import TypeAlias
+
+if sys.version_info >= (3, 9):
+    from importlib.abc import Traversable
+
+__all__ = ["Package", "Resource", "contents", "is_resource", "open_binary", "open_text", "path", "read_binary", "read_text"]
+
+if sys.version_info >= (3, 9):
+    __all__ += ["as_file", "files"]
+
+if sys.version_info >= (3, 10):
+    __all__ += ["ResourceReader"]
+
+Package: TypeAlias = str | ModuleType
+
+if sys.version_info >= (3, 11):
+    Resource: TypeAlias = str
+else:
+    Resource: TypeAlias = str | os.PathLike[Any]
+
+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]: ...
+def is_resource(package: Package, name: str) -> bool: ...
+def contents(package: Package) -> Iterator[str]: ...
+
+if sys.version_info >= (3, 9):
+    def as_file(path: Traversable) -> AbstractContextManager[Path]: ...
+
+if sys.version_info >= (3, 12):
+    def files(anchor: Package | None = ...) -> Traversable: ...
+
+elif sys.version_info >= (3, 9):
+    def files(package: Package) -> Traversable: ...
+
+if sys.version_info >= (3, 10):
+    from importlib.abc import ResourceReader as ResourceReader

mypy/typeshed/stdlib/importlib/resources/abc.pyi

@@ -0,0 +1,12 @@
+import sys
+
+if sys.version_info >= (3, 11):
+    # These are all actually defined in this file on 3.11+,
+    # and re-exported from importlib.abc,
+    # but it's much less code duplication for typeshed if we pretend that they're still defined
+    # in importlib.abc on 3.11+, and re-exported from this file
+    from importlib.abc import (
+        ResourceReader as ResourceReader,
+        Traversable as Traversable,
+        TraversableResources as TraversableResources,
+    )

mypy/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]: ...

mypy/typeshed/stdlib/importlib/resources/simple.pyi

@@ -0,0 +1,49 @@
+import abc
+import sys
+from _typeshed import Incomplete, OpenBinaryMode, OpenTextMode, Unused
+from collections.abc import Iterator
+from io import TextIOWrapper
+from typing import IO, Any, BinaryIO, Literal, NoReturn, overload
+from typing_extensions import Never
+
+if sys.version_info >= (3, 11):
+    from .abc import Traversable, TraversableResources
+
+    class SimpleReader(abc.ABC):
+        @property
+        @abc.abstractmethod
+        def package(self) -> str: ...
+        @abc.abstractmethod
+        def children(self) -> list[SimpleReader]: ...
+        @abc.abstractmethod
+        def resources(self) -> list[str]: ...
+        @abc.abstractmethod
+        def open_binary(self, resource: str) -> BinaryIO: ...
+        @property
+        def name(self) -> str: ...
+
+    class ResourceHandle(Traversable, metaclass=abc.ABCMeta):
+        parent: ResourceContainer
+        def __init__(self, parent: ResourceContainer, name: str) -> None: ...
+        def is_file(self) -> Literal[True]: ...
+        def is_dir(self) -> Literal[False]: ...
+        @overload
+        def open(self, mode: OpenTextMode = "r", *args: Incomplete, **kwargs: Incomplete) -> TextIOWrapper: ...
+        @overload
+        def open(self, mode: OpenBinaryMode, *args: Unused, **kwargs: Unused) -> BinaryIO: ...
+        @overload
+        def open(self, mode: str, *args: Incomplete, **kwargs: Incomplete) -> IO[Any]: ...
+        def joinpath(self, name: Never) -> NoReturn: ...  # type: ignore[override]
+
+    class ResourceContainer(Traversable, metaclass=abc.ABCMeta):
+        reader: SimpleReader
+        def __init__(self, reader: SimpleReader) -> None: ...
+        def is_dir(self) -> Literal[True]: ...
+        def is_file(self) -> Literal[False]: ...
+        def iterdir(self) -> Iterator[ResourceHandle | ResourceContainer]: ...
+        def open(self, *args: Never, **kwargs: Never) -> NoReturn: ...  # type: ignore[override]
+        if sys.version_info < (3, 12):
+            def joinpath(self, *descendants: str) -> Traversable: ...
+
+    class TraversableReader(TraversableResources, SimpleReader, metaclass=abc.ABCMeta):
+        def files(self) -> ResourceContainer: ...