layermap 0.1.0

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

@@ -0,0 +1,174 @@
+import sys
+from _typeshed import StrOrBytesPath, SupportsRead, SupportsReadline
+from collections.abc import Callable, Iterable, Iterator
+from socket import socket
+from ssl import SSLContext
+from types import TracebackType
+from typing import Any, Final, Literal, TextIO, overload
+from typing_extensions import Self, deprecated
+
+__all__ = ["FTP", "error_reply", "error_temp", "error_perm", "error_proto", "all_errors", "FTP_TLS"]
+
+MSG_OOB: Final = 1
+FTP_PORT: Final = 21
+MAXLINE: Final = 8192
+CRLF: Final = "\r\n"
+B_CRLF: Final = b"\r\n"
+
+class Error(Exception): ...
+class error_reply(Error): ...
+class error_temp(Error): ...
+class error_perm(Error): ...
+class error_proto(Error): ...
+
+all_errors: tuple[type[Exception], ...]
+
+class FTP:
+    debugging: int
+    host: str
+    port: int
+    maxline: int
+    sock: socket | None
+    welcome: str | None
+    passiveserver: int
+    timeout: float | None
+    af: int
+    lastresp: str
+    file: TextIO | None
+    encoding: str
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
+    ) -> None: ...
+    source_address: tuple[str, int] | None
+    def __init__(
+        self,
+        host: str = "",
+        user: str = "",
+        passwd: str = "",
+        acct: str = "",
+        timeout: float | None = ...,
+        source_address: tuple[str, int] | None = None,
+        *,
+        encoding: str = "utf-8",
+    ) -> None: ...
+    def connect(
+        self, host: str = "", port: int = 0, timeout: float = -999, source_address: tuple[str, int] | None = None
+    ) -> str: ...
+    def getwelcome(self) -> str: ...
+    def set_debuglevel(self, level: int) -> None: ...
+    def debug(self, level: int) -> None: ...
+    def set_pasv(self, val: bool | Literal[0, 1]) -> None: ...
+    def sanitize(self, s: str) -> str: ...
+    def putline(self, line: str) -> None: ...
+    def putcmd(self, line: str) -> None: ...
+    def getline(self) -> str: ...
+    def getmultiline(self) -> str: ...
+    def getresp(self) -> str: ...
+    def voidresp(self) -> str: ...
+    def abort(self) -> str: ...
+    def sendcmd(self, cmd: str) -> str: ...
+    def voidcmd(self, cmd: str) -> str: ...
+    def sendport(self, host: str, port: int) -> str: ...
+    def sendeprt(self, host: str, port: int) -> str: ...
+    def makeport(self) -> socket: ...
+    def makepasv(self) -> tuple[str, int]: ...
+    def login(self, user: str = "", passwd: str = "", acct: str = "") -> str: ...
+    # In practice, `rest` can actually be anything whose str() is an integer sequence, so to make it simple we allow integers
+    def ntransfercmd(self, cmd: str, rest: int | str | None = None) -> tuple[socket, int | None]: ...
+    def transfercmd(self, cmd: str, rest: int | str | None = None) -> socket: ...
+    def retrbinary(
+        self, cmd: str, callback: Callable[[bytes], object], blocksize: int = 8192, rest: int | str | None = None
+    ) -> str: ...
+    def storbinary(
+        self,
+        cmd: str,
+        fp: SupportsRead[bytes],
+        blocksize: int = 8192,
+        callback: Callable[[bytes], object] | None = None,
+        rest: int | str | None = None,
+    ) -> str: ...
+    def retrlines(self, cmd: str, callback: Callable[[str], object] | None = None) -> str: ...
+    def storlines(self, cmd: str, fp: SupportsReadline[bytes], callback: Callable[[bytes], object] | None = None) -> str: ...
+    def acct(self, password: str) -> str: ...
+    def nlst(self, *args: str) -> list[str]: ...
+    # Technically only the last arg can be a Callable but ...
+    def dir(self, *args: str | Callable[[str], object]) -> None: ...
+    def mlsd(self, path: str = "", facts: Iterable[str] = []) -> Iterator[tuple[str, dict[str, str]]]: ...
+    def rename(self, fromname: str, toname: str) -> str: ...
+    def delete(self, filename: str) -> str: ...
+    def cwd(self, dirname: str) -> str: ...
+    def size(self, filename: str) -> int | None: ...
+    def mkd(self, dirname: str) -> str: ...
+    def rmd(self, dirname: str) -> str: ...
+    def pwd(self) -> str: ...
+    def quit(self) -> str: ...
+    def close(self) -> None: ...
+
+class FTP_TLS(FTP):
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            host: str = "",
+            user: str = "",
+            passwd: str = "",
+            acct: str = "",
+            *,
+            context: SSLContext | None = None,
+            timeout: float | None = ...,
+            source_address: tuple[str, int] | None = None,
+            encoding: str = "utf-8",
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(
+            self,
+            host: str = "",
+            user: str = "",
+            passwd: str = "",
+            acct: str = "",
+            keyfile: None = None,
+            certfile: None = None,
+            context: SSLContext | None = None,
+            timeout: float | None = ...,
+            source_address: tuple[str, int] | None = None,
+            *,
+            encoding: str = "utf-8",
+        ) -> None: ...
+        @overload
+        @deprecated(
+            "The `keyfile`, `certfile` parameters are deprecated since Python 3.6; "
+            "removed in Python 3.12. Use `context` parameter instead."
+        )
+        def __init__(
+            self,
+            host: str = "",
+            user: str = "",
+            passwd: str = "",
+            acct: str = "",
+            keyfile: StrOrBytesPath | None = None,
+            certfile: StrOrBytesPath | None = None,
+            context: None = None,
+            timeout: float | None = ...,
+            source_address: tuple[str, int] | None = None,
+            *,
+            encoding: str = "utf-8",
+        ) -> None: ...
+
+        ssl_version: int
+        keyfile: StrOrBytesPath | None
+        certfile: StrOrBytesPath | None
+    context: SSLContext
+    def login(self, user: str = "", passwd: str = "", acct: str = "", secure: bool = True) -> str: ...
+    def auth(self) -> str: ...
+    def prot_p(self) -> str: ...
+    def prot_c(self) -> str: ...
+    def ccc(self) -> str: ...
+
+def parse150(resp: str) -> int | None: ...  # undocumented
+def parse227(resp: str) -> tuple[str, int]: ...  # undocumented
+def parse229(resp: str, peer: Any) -> tuple[str, int]: ...  # undocumented
+def parse257(resp: str) -> str: ...  # undocumented
+def ftpcp(
+    source: FTP, sourcename: str, target: FTP, targetname: str = "", type: Literal["A", "I"] = "I"
+) -> None: ...  # undocumented

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

@@ -0,0 +1,281 @@
+import sys
+import types
+from _typeshed import SupportsAllComparisons, SupportsItems
+from collections.abc import Callable, Hashable, Iterable, Sized
+from types import GenericAlias
+from typing import (
+    Any,
+    Final,
+    Generic,
+    Literal,
+    NamedTuple,
+    ParamSpec,
+    TypeAlias,
+    TypedDict,
+    TypeVar,
+    final,
+    overload,
+    type_check_only,
+)
+from typing_extensions import Self, disjoint_base
+
+__all__ = [
+    "update_wrapper",
+    "wraps",
+    "WRAPPER_ASSIGNMENTS",
+    "WRAPPER_UPDATES",
+    "total_ordering",
+    "cmp_to_key",
+    "lru_cache",
+    "reduce",
+    "partial",
+    "partialmethod",
+    "singledispatch",
+    "cached_property",
+    "singledispatchmethod",
+    "cache",
+]
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_S = TypeVar("_S")
+_PWrapped = ParamSpec("_PWrapped")
+_RWrapped = TypeVar("_RWrapped")
+_PWrapper = ParamSpec("_PWrapper")
+_RWrapper = TypeVar("_RWrapper")
+
+if sys.version_info >= (3, 14):
+    @overload
+    def reduce(function: Callable[[_T, _S], _T], iterable: Iterable[_S], /, initial: _T) -> _T: ...
+else:
+    @overload
+    def reduce(function: Callable[[_T, _S], _T], iterable: Iterable[_S], initial: _T, /) -> _T: ...
+
+@overload
+def reduce(function: Callable[[_T, _T], _T], iterable: Iterable[_T], /) -> _T: ...
+
+class _CacheInfo(NamedTuple):
+    hits: int
+    misses: int
+    maxsize: int | None
+    currsize: int
+
+@type_check_only
+class _CacheParameters(TypedDict):
+    maxsize: int
+    typed: bool
+
+@final
+class _lru_cache_wrapper(Generic[_T_co]):
+    __wrapped__: Callable[..., _T_co]
+    def __call__(self, *args: Hashable, **kwargs: Hashable) -> _T_co: ...
+    def cache_info(self) -> _CacheInfo: ...
+    def cache_clear(self) -> None: ...
+    def cache_parameters(self) -> _CacheParameters: ...
+    def __copy__(self) -> _lru_cache_wrapper[_T_co]: ...
+    def __deepcopy__(self, memo: Any, /) -> _lru_cache_wrapper[_T_co]: ...
+
+    # as with ``Callable``, we'll assume that these attributes exist
+    __name__: str
+    __qualname__: str
+
+@overload
+def lru_cache(maxsize: int | None = 128, typed: bool = False) -> Callable[[Callable[..., _T]], _lru_cache_wrapper[_T]]: ...
+@overload
+def lru_cache(maxsize: Callable[..., _T], typed: bool = False) -> _lru_cache_wrapper[_T]: ...
+
+if sys.version_info >= (3, 14):
+    WRAPPER_ASSIGNMENTS: Final[
+        tuple[
+            Literal["__module__"],
+            Literal["__name__"],
+            Literal["__qualname__"],
+            Literal["__doc__"],
+            Literal["__annotate__"],
+            Literal["__type_params__"],
+        ]
+    ]
+elif sys.version_info >= (3, 12):
+    WRAPPER_ASSIGNMENTS: Final[
+        tuple[
+            Literal["__module__"],
+            Literal["__name__"],
+            Literal["__qualname__"],
+            Literal["__doc__"],
+            Literal["__annotations__"],
+            Literal["__type_params__"],
+        ]
+    ]
+else:
+    WRAPPER_ASSIGNMENTS: Final[
+        tuple[Literal["__module__"], Literal["__name__"], Literal["__qualname__"], Literal["__doc__"], Literal["__annotations__"]]
+    ]
+
+WRAPPER_UPDATES: Final[tuple[Literal["__dict__"]]]
+
+@type_check_only
+class _Wrapped(Generic[_PWrapped, _RWrapped, _PWrapper, _RWrapper]):
+    __wrapped__: Callable[_PWrapped, _RWrapped]
+    def __call__(self, *args: _PWrapper.args, **kwargs: _PWrapper.kwargs) -> _RWrapper: ...
+    # as with ``Callable``, we'll assume that these attributes exist
+    __name__: str
+    __qualname__: str
+
+@type_check_only
+class _Wrapper(Generic[_PWrapped, _RWrapped]):
+    def __call__(self, f: Callable[_PWrapper, _RWrapper]) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWrapper]: ...
+
+if sys.version_info >= (3, 14):
+    def update_wrapper(
+        wrapper: Callable[_PWrapper, _RWrapper],
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Iterable[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotate__", "__type_params__"),
+        updated: Iterable[str] = ("__dict__",),
+    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWrapper]: ...
+    def wraps(
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Iterable[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotate__", "__type_params__"),
+        updated: Iterable[str] = ("__dict__",),
+    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
+
+elif sys.version_info >= (3, 12):
+    def update_wrapper(
+        wrapper: Callable[_PWrapper, _RWrapper],
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Iterable[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
+        updated: Iterable[str] = ("__dict__",),
+    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWrapper]: ...
+    def wraps(
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Iterable[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
+        updated: Iterable[str] = ("__dict__",),
+    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
+
+else:
+    def update_wrapper(
+        wrapper: Callable[_PWrapper, _RWrapper],
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Iterable[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
+        updated: Iterable[str] = ("__dict__",),
+    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWrapper]: ...
+    def wraps(
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Iterable[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
+        updated: Iterable[str] = ("__dict__",),
+    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
+
+def total_ordering(cls: type[_T]) -> type[_T]: ...
+def cmp_to_key(mycmp: Callable[[_T, _T], int]) -> Callable[[_T], SupportsAllComparisons]: ...
+
+@disjoint_base
+class partial(Generic[_T]):
+    @property
+    def func(self) -> Callable[..., _T]: ...
+    @property
+    def args(self) -> tuple[Any, ...]: ...
+    @property
+    def keywords(self) -> dict[str, Any]: ...
+    def __new__(cls, func: Callable[..., _T], /, *args: Any, **kwargs: Any) -> Self: ...
+    def __call__(self, /, *args: Any, **kwargs: Any) -> _T: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+# With protocols, this could change into a generic protocol that defines __get__ and returns _T
+_Descriptor: TypeAlias = Any
+
+class partialmethod(Generic[_T]):
+    func: Callable[..., _T] | _Descriptor
+    args: tuple[Any, ...]
+    keywords: dict[str, Any]
+    if sys.version_info >= (3, 14):
+        @overload
+        def __new__(self, func: Callable[..., _T], /, *args: Any, **keywords: Any) -> Self: ...
+        @overload
+        def __new__(self, func: _Descriptor, /, *args: Any, **keywords: Any) -> Self: ...
+    else:
+        @overload
+        def __init__(self, func: Callable[..., _T], /, *args: Any, **keywords: Any) -> None: ...
+        @overload
+        def __init__(self, func: _Descriptor, /, *args: Any, **keywords: Any) -> None: ...
+
+    def __get__(self, obj: Any, cls: type[Any] | None = None) -> Callable[..., _T]: ...
+    @property
+    def __isabstractmethod__(self) -> bool: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+if sys.version_info >= (3, 11):
+    _RegType: TypeAlias = type[Any] | types.UnionType
+else:
+    _RegType: TypeAlias = type[Any]
+
+@type_check_only
+class _SingleDispatchCallable(Generic[_T]):
+    registry: types.MappingProxyType[Any, Callable[..., _T]]
+    def dispatch(self, cls: Any) -> Callable[..., _T]: ...
+
+    # @fun.register(complex)
+    # def _(arg, verbose=False): ...
+    @overload
+    def register(self, cls: _RegType, func: None = None) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
+    # @fun.register
+    # def _(arg: int, verbose=False):
+    @overload
+    def register(self, cls: Callable[..., _T], func: None = None) -> Callable[..., _T]: ...
+    # fun.register(int, lambda x: x)
+    @overload
+    def register(self, cls: _RegType, func: Callable[..., _T]) -> Callable[..., _T]: ...
+
+    def _clear_cache(self) -> None: ...
+    def __call__(self, /, *args: Any, **kwargs: Any) -> _T: ...
+
+def singledispatch(func: Callable[..., _T]) -> _SingleDispatchCallable[_T]: ...
+
+class singledispatchmethod(Generic[_T]):
+    dispatcher: _SingleDispatchCallable[_T]
+    func: Callable[..., _T]
+    def __init__(self, func: Callable[..., _T]) -> None: ...
+    @property
+    def __isabstractmethod__(self) -> bool: ...
+
+    @overload
+    def register(self, cls: _RegType, method: None = None) -> Callable[[Callable[..., _T]], Callable[..., _T]]: ...
+    @overload
+    def register(self, cls: Callable[..., _T], method: None = None) -> Callable[..., _T]: ...
+    @overload
+    def register(self, cls: _RegType, method: Callable[..., _T]) -> Callable[..., _T]: ...
+
+    def __get__(self, obj: _S, cls: type[_S] | None = None) -> Callable[..., _T]: ...
+
+class cached_property(Generic[_T_co]):
+    func: Callable[[Any], _T_co]
+    attrname: str | None
+    def __init__(self, func: Callable[[Any], _T_co]) -> None: ...
+
+    @overload
+    def __get__(self, instance: None, owner: type[Any] | None = None) -> Self: ...
+    @overload
+    def __get__(self, instance: object, owner: type[Any] | None = None) -> _T_co: ...
+
+    def __set_name__(self, owner: type[Any], name: str) -> None: ...
+    # __set__ is not defined at runtime, but @cached_property is designed to be settable
+    def __set__(self, instance: object, value: _T_co) -> None: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+def cache(user_function: Callable[..., _T], /) -> _lru_cache_wrapper[_T]: ...
+def _make_key(
+    args: tuple[Hashable, ...],
+    kwds: SupportsItems[Any, Any],
+    typed: bool,
+    kwd_mark: tuple[object, ...] = ...,
+    fasttypes: set[type] = ...,
+    tuple: type = ...,
+    type: Any = ...,
+    len: Callable[[Sized], int] = ...,
+) -> Hashable: ...
+
+if sys.version_info >= (3, 14):
+    @final
+    class _PlaceholderType: ...
+
+    Placeholder: Final[_PlaceholderType]
+
+    __all__ += ["Placeholder"]

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

@@ -0,0 +1,32 @@
+from collections.abc import Callable
+from typing import Any, Final, Literal, TypeAlias
+
+DEBUG_COLLECTABLE: Final = 2
+DEBUG_LEAK: Final = 38
+DEBUG_SAVEALL: Final = 32
+DEBUG_STATS: Final = 1
+DEBUG_UNCOLLECTABLE: Final = 4
+
+_CallbackType: TypeAlias = Callable[[Literal["start", "stop"], dict[str, int]], object]
+
+callbacks: list[_CallbackType]
+garbage: list[Any]
+
+def collect(generation: int = 2) -> int: ...
+def disable() -> None: ...
+def enable() -> None: ...
+def get_count() -> tuple[int, int, int]: ...
+def get_debug() -> int: ...
+def get_objects(generation: int | None = None) -> list[Any]: ...
+def freeze() -> None: ...
+def unfreeze() -> None: ...
+def get_freeze_count() -> int: ...
+def get_referents(*objs: Any) -> list[Any]: ...
+def get_referrers(*objs: Any) -> list[Any]: ...
+def get_stats() -> list[dict[str, Any]]: ...
+def get_threshold() -> tuple[int, int, int]: ...
+def is_tracked(obj: Any, /) -> bool: ...
+def is_finalized(obj: Any, /) -> bool: ...
+def isenabled() -> bool: ...
+def set_debug(flags: int, /) -> None: ...
+def set_threshold(threshold0: int, threshold1: int = 0, threshold2: int = 0, /) -> None: ...

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

@@ -0,0 +1,98 @@
+import os
+import sys
+from _typeshed import BytesPath, FileDescriptorOrPath, StrOrBytesPath, StrPath, SupportsRichComparisonT
+from collections.abc import Sequence
+from typing import Literal, NewType, overload
+from typing_extensions import LiteralString, deprecated
+
+__all__ = [
+    "commonprefix",
+    "exists",
+    "getatime",
+    "getctime",
+    "getmtime",
+    "getsize",
+    "isdir",
+    "isfile",
+    "samefile",
+    "sameopenfile",
+    "samestat",
+    "ALLOW_MISSING",
+]
+if sys.version_info >= (3, 12):
+    __all__ += ["islink"]
+if sys.version_info >= (3, 13):
+    __all__ += ["isjunction", "isdevdrive", "lexists"]
+if sys.version_info >= (3, 15):
+    __all__ += ["ALL_BUT_LAST"]
+
+# All overloads can return empty string. Ideally, Literal[""] would be a valid
+# Iterable[T], so that list[T] | Literal[""] could be used as a return
+# type. But because this only works when T is str, we need Sequence[T] instead.
+if sys.version_info >= (3, 15):
+    @overload
+    @deprecated("Deprecated since Python 3.15; use os.path.commonpath() for path prefixes.")
+    def commonprefix(m: Sequence[LiteralString], /) -> LiteralString: ...
+    @overload
+    @deprecated("Deprecated since Python 3.15; use os.path.commonpath() for path prefixes.")
+    def commonprefix(m: Sequence[StrPath], /) -> str: ...
+    @overload
+    @deprecated("Deprecated since Python 3.15; use os.path.commonpath() for path prefixes.")
+    def commonprefix(m: Sequence[BytesPath], /) -> bytes | Literal[""]: ...
+    @overload
+    @deprecated("Deprecated since Python 3.15; use os.path.commonpath() for path prefixes.")
+    def commonprefix(m: Sequence[list[SupportsRichComparisonT]], /) -> Sequence[SupportsRichComparisonT]: ...
+    @overload
+    @deprecated("Deprecated since Python 3.15; use os.path.commonpath() for path prefixes.")
+    def commonprefix(m: Sequence[tuple[SupportsRichComparisonT, ...]], /) -> Sequence[SupportsRichComparisonT]: ...
+else:
+    @overload
+    def commonprefix(m: Sequence[LiteralString]) -> LiteralString: ...
+    @overload
+    def commonprefix(m: Sequence[StrPath]) -> str: ...
+    @overload
+    def commonprefix(m: Sequence[BytesPath]) -> bytes | Literal[""]: ...
+    @overload
+    def commonprefix(m: Sequence[list[SupportsRichComparisonT]]) -> Sequence[SupportsRichComparisonT]: ...
+    @overload
+    def commonprefix(m: Sequence[tuple[SupportsRichComparisonT, ...]]) -> Sequence[SupportsRichComparisonT]: ...
+
+def exists(path: FileDescriptorOrPath) -> bool: ...
+def isfile(path: FileDescriptorOrPath) -> bool: ...
+def isdir(s: FileDescriptorOrPath) -> bool: ...
+
+if sys.version_info >= (3, 12):
+    def islink(path: StrOrBytesPath) -> bool: ...
+
+# These return float if os.stat_float_times() == True,
+# but int is a subclass of float.
+def sameopenfile(fp1: int, fp2: int) -> bool: ...
+
+if sys.version_info >= (3, 15):
+    def getsize(filename: FileDescriptorOrPath, /) -> int: ...
+    def getatime(filename: FileDescriptorOrPath, /) -> float: ...
+    def getmtime(filename: FileDescriptorOrPath, /) -> float: ...
+    def getctime(filename: FileDescriptorOrPath, /) -> float: ...
+    def samefile(f1: FileDescriptorOrPath, f2: FileDescriptorOrPath, /) -> bool: ...
+    def samestat(s1: os.stat_result, s2: os.stat_result, /) -> bool: ...
+
+else:
+    def getsize(filename: FileDescriptorOrPath) -> int: ...
+    def getatime(filename: FileDescriptorOrPath) -> float: ...
+    def getmtime(filename: FileDescriptorOrPath) -> float: ...
+    def getctime(filename: FileDescriptorOrPath) -> float: ...
+    def samefile(f1: FileDescriptorOrPath, f2: FileDescriptorOrPath) -> bool: ...
+    def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ...
+
+if sys.version_info >= (3, 13):
+    def isjunction(path: StrOrBytesPath) -> bool: ...
+    def isdevdrive(path: StrOrBytesPath) -> bool: ...
+    def lexists(path: StrOrBytesPath) -> bool: ...
+
+# Added in Python 3.9.23, 3.10.18, 3.11.13, 3.12.11, 3.13.4
+_AllowMissingType = NewType("_AllowMissingType", object)
+ALLOW_MISSING: _AllowMissingType
+
+if sys.version_info >= (3, 15):
+    _AllButLastType = NewType("_AllButLastType", object)
+    ALL_BUT_LAST: _AllButLastType

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

@@ -0,0 +1,27 @@
+from collections.abc import Iterable, Sequence
+from typing import Protocol, TypeVar, overload, type_check_only
+
+_StrSequenceT_co = TypeVar("_StrSequenceT_co", covariant=True, bound=Sequence[str])
+
+@type_check_only
+class _SliceableT(Protocol[_StrSequenceT_co]):
+    @overload
+    def __getitem__(self, key: int, /) -> str: ...
+    @overload
+    def __getitem__(self, key: slice, /) -> _StrSequenceT_co: ...
+
+__all__ = ["GetoptError", "error", "getopt", "gnu_getopt"]
+
+def getopt(
+    args: _SliceableT[_StrSequenceT_co], shortopts: str, longopts: Iterable[str] | str = []
+) -> tuple[list[tuple[str, str]], _StrSequenceT_co]: ...
+def gnu_getopt(
+    args: Sequence[str], shortopts: str, longopts: Iterable[str] | str = []
+) -> tuple[list[tuple[str, str]], list[str]]: ...
+
+class GetoptError(Exception):
+    msg: str
+    opt: str
+    def __init__(self, msg: str, opt: str = "") -> None: ...
+
+error = GetoptError

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

@@ -0,0 +1,14 @@
+import sys
+from typing import TextIO
+
+__all__ = ["getpass", "getuser", "GetPassWarning"]
+
+if sys.version_info >= (3, 14):
+    def getpass(prompt: str = "Password: ", stream: TextIO | None = None, *, echo_char: str | None = None) -> str: ...
+
+else:
+    def getpass(prompt: str = "Password: ", stream: TextIO | None = None) -> str: ...
+
+def getuser() -> str: ...
+
+class GetPassWarning(UserWarning): ...