layermap 0.1.0

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

@@ -0,0 +1,301 @@
+import email.message
+import io
+import sys
+from _typeshed import StrPath, SupportsItems, SupportsNoArgReadline, SupportsRead, SupportsWrite, Unused
+from abc import ABCMeta, abstractmethod
+from collections.abc import Callable, Iterable, Iterator, Mapping, Sequence
+from types import GenericAlias, TracebackType
+from typing import Any, Generic, Literal, Protocol, TypeAlias, TypeVar, overload, type_check_only
+from typing_extensions import Self
+
+__all__ = [
+    "Mailbox",
+    "Maildir",
+    "mbox",
+    "MH",
+    "Babyl",
+    "MMDF",
+    "Message",
+    "MaildirMessage",
+    "mboxMessage",
+    "MHMessage",
+    "BabylMessage",
+    "MMDFMessage",
+    "Error",
+    "NoSuchMailboxError",
+    "NotEmptyError",
+    "ExternalClashError",
+    "FormatError",
+]
+
+_T = TypeVar("_T")
+
+@type_check_only
+class _SupportsReadAndReadline(SupportsRead[bytes], SupportsNoArgReadline[bytes], Protocol): ...
+
+# As opposed to _MessageT_co in email._policybase, this type is bound to
+# mailbox.Message instead of email.message.Message.
+_MessageT_co = TypeVar("_MessageT_co", bound=Message, default=Message, covariant=True)
+
+_MessageData: TypeAlias = email.message.Message | bytes | str | io.StringIO | _SupportsReadAndReadline
+
+@type_check_only
+class _HasIteritems(Protocol):
+    def iteritems(self) -> Iterator[tuple[str, _MessageData]]: ...
+
+linesep: bytes
+
+# Common interface for get_file() return types.
+@type_check_only
+class _GetFileReturn(Protocol):
+    def __iter__(self) -> Iterator[bytes]: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc: BaseException | None, tb: TracebackType | None, /
+    ) -> bool | None: ...
+    def read(self, size: int | None = None, /) -> bytes: ...
+    def read1(self, size: int | None = None, /) -> bytes: ...
+    def readline(self, size: int | None = None, /) -> bytes: ...
+    def readlines(self, sizehint: int | None = None, /) -> list[bytes]: ...
+    def tell(self) -> int: ...
+    def seek(self, offset: int, whence: int = 0, /) -> object: ...
+    def close(self) -> object: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def seekable(self) -> bool: ...
+    def flush(self) -> object: ...
+    @property
+    def closed(self) -> bool: ...
+
+class Mailbox(Generic[_MessageT_co]):
+    _path: str  # undocumented
+    _factory: Callable[[_GetFileReturn], _MessageT_co] | None  # undocumented
+
+    @overload
+    def __init__(self, path: StrPath, factory: Callable[[_GetFileReturn], _MessageT_co], create: bool = True) -> None: ...
+    @overload
+    def __init__(self, path: StrPath, factory: None = None, create: bool = True) -> None: ...
+
+    @abstractmethod
+    def add(self, message: _MessageData) -> str: ...
+    @abstractmethod
+    def remove(self, key: str) -> None: ...
+    def __delitem__(self, key: str) -> None: ...
+    def discard(self, key: str) -> None: ...
+    @abstractmethod
+    def __setitem__(self, key: str, message: _MessageData) -> None: ...
+
+    @overload
+    def get(self, key: str, default: None = None) -> _MessageT_co | None: ...
+    @overload
+    def get(self, key: str, default: _T) -> _MessageT_co | _T: ...
+
+    def __getitem__(self, key: str) -> _MessageT_co: ...
+    @abstractmethod
+    def get_message(self, key: str) -> _MessageT_co: ...
+    def get_string(self, key: str) -> str: ...
+    @abstractmethod
+    def get_bytes(self, key: str) -> bytes: ...
+    @abstractmethod
+    def get_file(self, key: str) -> _GetFileReturn: ...
+    @abstractmethod
+    def iterkeys(self) -> Iterator[str]: ...
+    def keys(self) -> list[str]: ...
+    def itervalues(self) -> Iterator[_MessageT_co]: ...
+    def __iter__(self) -> Iterator[_MessageT_co]: ...
+    def values(self) -> list[_MessageT_co]: ...
+    def iteritems(self) -> Iterator[tuple[str, _MessageT_co]]: ...
+    def items(self) -> list[tuple[str, _MessageT_co]]: ...
+    @abstractmethod
+    def __contains__(self, key: str) -> bool: ...
+    @abstractmethod
+    def __len__(self) -> int: ...
+    def clear(self) -> None: ...
+
+    @overload
+    def pop(self, key: str, default: None = None) -> _MessageT_co | None: ...
+    @overload
+    def pop(self, key: str, default: _T) -> _MessageT_co | _T: ...
+
+    def popitem(self) -> tuple[str, _MessageT_co]: ...
+    def update(
+        self, arg: _HasIteritems | SupportsItems[str, _MessageData] | Iterable[tuple[str, _MessageData]] | None = None
+    ) -> None: ...
+    @abstractmethod
+    def flush(self) -> None: ...
+    @abstractmethod
+    def lock(self) -> None: ...
+    @abstractmethod
+    def unlock(self) -> None: ...
+    @abstractmethod
+    def close(self) -> None: ...
+    # Undocumented, called by subclasses to parse added messages.
+    def _dump_message(self, message: _MessageData, target: SupportsWrite[bytes], mangle_from_: bool = False) -> None: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+class Maildir(Mailbox[MaildirMessage]):
+    colon: str
+    def __init__(
+        self, dirname: StrPath, factory: Callable[[_GetFileReturn], MaildirMessage] | None = None, create: bool = True
+    ) -> None: ...
+    def add(self, message: _MessageData | MaildirMessage) -> str: ...
+    def remove(self, key: str) -> None: ...
+    def __setitem__(self, key: str, message: _MessageData | MaildirMessage) -> None: ...
+    def get_message(self, key: str) -> MaildirMessage: ...
+    def get_bytes(self, key: str) -> bytes: ...
+    def get_file(self, key: str) -> _ProxyFile: ...
+    if sys.version_info >= (3, 13):
+        def get_info(self, key: str) -> str: ...
+        def set_info(self, key: str, info: str) -> None: ...
+        def get_flags(self, key: str) -> str: ...
+        def set_flags(self, key: str, flags: str) -> None: ...
+        def add_flag(self, key: str, flag: str) -> None: ...
+        def remove_flag(self, key: str, flag: str) -> None: ...
+
+    def iterkeys(self) -> Iterator[str]: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __len__(self) -> int: ...
+    def flush(self) -> None: ...
+    def lock(self) -> None: ...
+    def unlock(self) -> None: ...
+    def close(self) -> None: ...
+    def list_folders(self) -> list[str]: ...
+    def get_folder(self, folder: str) -> Maildir: ...
+    def add_folder(self, folder: str) -> Maildir: ...
+    def remove_folder(self, folder: str) -> None: ...
+    def clean(self) -> None: ...
+    def next(self) -> str | None: ...
+
+class _singlefileMailbox(Mailbox[_MessageT_co], metaclass=ABCMeta):
+    def add(self, message: _MessageData) -> str: ...
+    def remove(self, key: str) -> None: ...
+    def __setitem__(self, key: str, message: _MessageData) -> None: ...
+    def iterkeys(self) -> Iterator[str]: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __len__(self) -> int: ...
+    def lock(self) -> None: ...
+    def unlock(self) -> None: ...
+    def flush(self) -> None: ...
+    def close(self) -> None: ...
+
+class _mboxMMDF(_singlefileMailbox[_MessageT_co]):
+    def get_message(self, key: str) -> _MessageT_co: ...
+    def get_file(self, key: str, from_: bool = False) -> _PartialFile: ...
+    def get_bytes(self, key: str, from_: bool = False) -> bytes: ...
+    def get_string(self, key: str, from_: bool = False) -> str: ...
+
+class mbox(_mboxMMDF[mboxMessage]):
+    def __init__(
+        self, path: StrPath, factory: Callable[[_GetFileReturn], mboxMessage] | None = None, create: bool = True
+    ) -> None: ...
+
+class MMDF(_mboxMMDF[MMDFMessage]):
+    def __init__(
+        self, path: StrPath, factory: Callable[[_GetFileReturn], MMDFMessage] | None = None, create: bool = True
+    ) -> None: ...
+
+class MH(Mailbox[MHMessage]):
+    def __init__(
+        self, path: StrPath, factory: Callable[[_GetFileReturn], MHMessage] | None = None, create: bool = True
+    ) -> None: ...
+    def add(self, message: _MessageData) -> str: ...
+    def remove(self, key: str) -> None: ...
+    def __setitem__(self, key: str, message: _MessageData) -> None: ...
+    def get_message(self, key: str) -> MHMessage: ...
+    def get_bytes(self, key: str) -> bytes: ...
+    def get_file(self, key: str) -> _ProxyFile: ...
+    def iterkeys(self) -> Iterator[str]: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __len__(self) -> int: ...
+    def flush(self) -> None: ...
+    def lock(self) -> None: ...
+    def unlock(self) -> None: ...
+    def close(self) -> None: ...
+    def list_folders(self) -> list[str]: ...
+    def get_folder(self, folder: StrPath) -> MH: ...
+    def add_folder(self, folder: StrPath) -> MH: ...
+    def remove_folder(self, folder: StrPath) -> None: ...
+    def get_sequences(self) -> dict[str, list[int]]: ...
+    def set_sequences(self, sequences: Mapping[str, Sequence[int]]) -> None: ...
+    def pack(self) -> None: ...
+
+class Babyl(_singlefileMailbox[BabylMessage]):
+    def __init__(
+        self, path: StrPath, factory: Callable[[_GetFileReturn], BabylMessage] | None = None, create: bool = True
+    ) -> None: ...
+    def get_message(self, key: str) -> BabylMessage: ...
+    def get_bytes(self, key: str) -> bytes: ...
+    def get_file(self, key: str) -> io.BytesIO: ...
+    def get_labels(self) -> list[str]: ...
+
+class Message(email.message.Message[str, str]):
+    def __init__(self, message: _MessageData | None = None) -> None: ...
+
+class MaildirMessage(Message):
+    def get_subdir(self) -> str: ...
+    def set_subdir(self, subdir: Literal["new", "cur"]) -> None: ...
+    def get_flags(self) -> str: ...
+    def set_flags(self, flags: Iterable[str]) -> None: ...
+    def add_flag(self, flag: str) -> None: ...
+    def remove_flag(self, flag: str) -> None: ...
+    def get_date(self) -> int: ...
+    def set_date(self, date: float) -> None: ...
+    def get_info(self) -> str: ...
+    def set_info(self, info: str) -> None: ...
+
+class _mboxMMDFMessage(Message):
+    def get_from(self) -> str: ...
+    def set_from(self, from_: str, time_: bool | tuple[int, int, int, int, int, int, int, int, int] | None = None) -> None: ...
+    def get_flags(self) -> str: ...
+    def set_flags(self, flags: Iterable[str]) -> None: ...
+    def add_flag(self, flag: str) -> None: ...
+    def remove_flag(self, flag: str) -> None: ...
+
+class mboxMessage(_mboxMMDFMessage): ...
+
+class MHMessage(Message):
+    def get_sequences(self) -> list[str]: ...
+    def set_sequences(self, sequences: Iterable[str]) -> None: ...
+    def add_sequence(self, sequence: str) -> None: ...
+    def remove_sequence(self, sequence: str) -> None: ...
+
+class BabylMessage(Message):
+    def get_labels(self) -> list[str]: ...
+    def set_labels(self, labels: Iterable[str]) -> None: ...
+    def add_label(self, label: str) -> None: ...
+    def remove_label(self, label: str) -> None: ...
+    def get_visible(self) -> Message: ...
+    def set_visible(self, visible: _MessageData) -> None: ...
+    def update_visible(self) -> None: ...
+
+class MMDFMessage(_mboxMMDFMessage): ...
+
+# Until Python 3.14, this class was technically - but unnecessarily - generic at runtime.
+class _ProxyFile:
+    def __init__(self, f: _GetFileReturn, pos: int | None = None) -> None: ...
+    def read(self, size: int | None = None) -> bytes: ...
+    def read1(self, size: int | None = None) -> bytes: ...
+    def readline(self, size: int | None = None) -> bytes: ...
+    def readlines(self, sizehint: int | None = None) -> list[bytes]: ...
+    def __iter__(self) -> Iterator[bytes]: ...
+    def tell(self) -> int: ...
+    def seek(self, offset: int, whence: int = 0) -> None: ...
+    def close(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *exc: Unused) -> None: ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def seekable(self) -> bool: ...
+    def flush(self) -> None: ...
+    @property
+    def closed(self) -> bool: ...
+    def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
+
+class _PartialFile(_ProxyFile):
+    def __init__(self, f: _GetFileReturn, start: int | None = None, stop: int | None = None) -> None: ...
+
+class Error(Exception): ...
+class NoSuchMailboxError(Error): ...
+class NotEmptyError(Error): ...
+class ExternalClashError(Error): ...
+class FormatError(Error): ...

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

@@ -0,0 +1,11 @@
+from collections.abc import Mapping, Sequence
+from typing import TypeAlias
+
+_Cap: TypeAlias = dict[str, str | int]
+
+__all__ = ["getcaps", "findmatch"]
+
+def findmatch(
+    caps: Mapping[str, list[_Cap]], MIMEtype: str, key: str = "view", filename: str = "/dev/null", plist: Sequence[str] = []
+) -> tuple[str | None, _Cap | None]: ...
+def getcaps() -> dict[str, list[_Cap]]: ...

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

@@ -0,0 +1,52 @@
+import builtins
+import sys
+import types
+from _typeshed import ReadableBuffer, SupportsRead, SupportsWrite
+from typing import Any, Final, TypeAlias
+
+version: Final[int]
+
+_Marshallable: TypeAlias = (
+    # handled in w_object() in marshal.c
+    None
+    | type[StopIteration]
+    | builtins.ellipsis
+    | bool
+    # handled in w_complex_object() in marshal.c
+    | int
+    | float
+    | complex
+    | bytes
+    | str
+    | tuple[_Marshallable, ...]
+    | list[Any]
+    | dict[Any, Any]
+    | set[Any]
+    | frozenset[_Marshallable]
+    | types.CodeType
+    | ReadableBuffer
+)
+
+if sys.version_info >= (3, 15):
+    def dump(value: _Marshallable, file: SupportsWrite[bytes], version: int = 6, /, *, allow_code: bool = True) -> None: ...
+    def dumps(value: _Marshallable, version: int = 6, /, *, allow_code: bool = True) -> bytes: ...
+
+elif sys.version_info >= (3, 14):
+    def dump(value: _Marshallable, file: SupportsWrite[bytes], version: int = 5, /, *, allow_code: bool = True) -> None: ...
+    def dumps(value: _Marshallable, version: int = 5, /, *, allow_code: bool = True) -> bytes: ...
+
+elif sys.version_info >= (3, 13):
+    def dump(value: _Marshallable, file: SupportsWrite[bytes], version: int = 4, /, *, allow_code: bool = True) -> None: ...
+    def dumps(value: _Marshallable, version: int = 4, /, *, allow_code: bool = True) -> bytes: ...
+
+else:
+    def dump(value: _Marshallable, file: SupportsWrite[bytes], version: int = 4, /) -> None: ...
+    def dumps(value: _Marshallable, version: int = 4, /) -> bytes: ...
+
+if sys.version_info >= (3, 13):
+    def load(file: SupportsRead[bytes], /, *, allow_code: bool = True) -> Any: ...
+    def loads(bytes: ReadableBuffer, /, *, allow_code: bool = True) -> Any: ...
+
+else:
+    def load(file: SupportsRead[bytes], /) -> Any: ...
+    def loads(bytes: ReadableBuffer, /) -> Any: ...

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

@@ -0,0 +1,157 @@
+import sys
+from _typeshed import SupportsMul, SupportsRMul
+from collections.abc import Iterable
+from typing import Any, Final, Literal, Protocol, SupportsFloat, SupportsIndex, TypeAlias, TypeVar, overload, type_check_only
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+
+_SupportsFloatOrIndex: TypeAlias = SupportsFloat | SupportsIndex
+
+e: Final[float]
+pi: Final[float]
+inf: Final[float]
+nan: Final[float]
+tau: Final[float]
+
+def acos(x: _SupportsFloatOrIndex, /) -> float: ...
+def acosh(x: _SupportsFloatOrIndex, /) -> float: ...
+def asin(x: _SupportsFloatOrIndex, /) -> float: ...
+def asinh(x: _SupportsFloatOrIndex, /) -> float: ...
+def atan(x: _SupportsFloatOrIndex, /) -> float: ...
+def atan2(y: _SupportsFloatOrIndex, x: _SupportsFloatOrIndex, /) -> float: ...
+def atanh(x: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 11):
+    def cbrt(x: _SupportsFloatOrIndex, /) -> float: ...
+
+@type_check_only
+class _SupportsCeil(Protocol[_T_co]):
+    def __ceil__(self) -> _T_co: ...
+
+@overload
+def ceil(x: _SupportsCeil[_T], /) -> _T: ...
+@overload
+def ceil(x: _SupportsFloatOrIndex, /) -> int: ...
+
+def comb(n: SupportsIndex, k: SupportsIndex, /) -> int: ...
+def copysign(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+def cos(x: _SupportsFloatOrIndex, /) -> float: ...
+def cosh(x: _SupportsFloatOrIndex, /) -> float: ...
+def degrees(x: _SupportsFloatOrIndex, /) -> float: ...
+def dist(p: Iterable[_SupportsFloatOrIndex], q: Iterable[_SupportsFloatOrIndex], /) -> float: ...
+def erf(x: _SupportsFloatOrIndex, /) -> float: ...
+def erfc(x: _SupportsFloatOrIndex, /) -> float: ...
+def exp(x: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 11):
+    def exp2(x: _SupportsFloatOrIndex, /) -> float: ...
+
+def expm1(x: _SupportsFloatOrIndex, /) -> float: ...
+def fabs(x: _SupportsFloatOrIndex, /) -> float: ...
+def factorial(x: SupportsIndex, /) -> int: ...
+
+@type_check_only
+class _SupportsFloor(Protocol[_T_co]):
+    def __floor__(self) -> _T_co: ...
+
+@overload
+def floor(x: _SupportsFloor[_T], /) -> _T: ...
+@overload
+def floor(x: _SupportsFloatOrIndex, /) -> int: ...
+
+def fmod(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 15):
+    def fmax(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+    def fmin(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+
+def frexp(x: _SupportsFloatOrIndex, /) -> tuple[float, int]: ...
+def fsum(seq: Iterable[_SupportsFloatOrIndex], /) -> float: ...
+def gamma(x: _SupportsFloatOrIndex, /) -> float: ...
+def gcd(*integers: SupportsIndex) -> int: ...
+def hypot(*coordinates: _SupportsFloatOrIndex) -> float: ...
+def isclose(
+    a: _SupportsFloatOrIndex,
+    b: _SupportsFloatOrIndex,
+    *,
+    rel_tol: _SupportsFloatOrIndex = 1e-09,
+    abs_tol: _SupportsFloatOrIndex = 0.0,
+) -> bool: ...
+def isinf(x: _SupportsFloatOrIndex, /) -> bool: ...
+def isfinite(x: _SupportsFloatOrIndex, /) -> bool: ...
+def isnan(x: _SupportsFloatOrIndex, /) -> bool: ...
+
+if sys.version_info >= (3, 15):
+    def isnormal(x: _SupportsFloatOrIndex, /) -> bool: ...
+    def issubnormal(x: _SupportsFloatOrIndex, /) -> bool: ...
+
+def isqrt(n: SupportsIndex, /) -> int: ...
+def lcm(*integers: SupportsIndex) -> int: ...
+def ldexp(x: _SupportsFloatOrIndex, i: int, /) -> float: ...
+def lgamma(x: _SupportsFloatOrIndex, /) -> float: ...
+def log(x: _SupportsFloatOrIndex, base: _SupportsFloatOrIndex = ...) -> float: ...
+def log10(x: _SupportsFloatOrIndex, /) -> float: ...
+def log1p(x: _SupportsFloatOrIndex, /) -> float: ...
+def log2(x: _SupportsFloatOrIndex, /) -> float: ...
+def modf(x: _SupportsFloatOrIndex, /) -> tuple[float, float]: ...
+
+if sys.version_info >= (3, 12):
+    def nextafter(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /, *, steps: SupportsIndex | None = None) -> float: ...
+
+else:
+    def nextafter(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+
+def perm(n: SupportsIndex, k: SupportsIndex | None = None, /) -> int: ...
+def pow(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+
+_PositiveInteger: TypeAlias = Literal[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
+_NegativeInteger: TypeAlias = Literal[-1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16, -17, -18, -19, -20]
+_LiteralInteger = _PositiveInteger | _NegativeInteger | Literal[0]  # noqa: Y026  # TODO: Use TypeAlias once mypy bugs are fixed
+
+_MultiplicableT1 = TypeVar("_MultiplicableT1", bound=SupportsMul[Any, Any])
+_MultiplicableT2 = TypeVar("_MultiplicableT2", bound=SupportsMul[Any, Any])
+
+@type_check_only
+class _SupportsProdWithNoDefaultGiven(SupportsMul[Any, Any], SupportsRMul[int, Any], Protocol): ...
+
+_SupportsProdNoDefaultT = TypeVar("_SupportsProdNoDefaultT", bound=_SupportsProdWithNoDefaultGiven)
+
+# This stub is based on the type stub for `builtins.sum`.
+# Like `builtins.sum`, it cannot be precisely represented in a type stub
+# without introducing many false positives.
+# For more details on its limitations and false positives, see #13572.
+# Instead, just like `builtins.sum`, we explicitly handle several useful cases.
+@overload
+def prod(iterable: Iterable[bool | _LiteralInteger], /, *, start: int = 1) -> int: ...  # type: ignore[overload-overlap]
+@overload
+def prod(iterable: Iterable[_SupportsProdNoDefaultT], /) -> _SupportsProdNoDefaultT | Literal[1]: ...
+@overload
+def prod(iterable: Iterable[_MultiplicableT1], /, *, start: _MultiplicableT2) -> _MultiplicableT1 | _MultiplicableT2: ...
+
+def radians(x: _SupportsFloatOrIndex, /) -> float: ...
+def remainder(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, /) -> float: ...
+def sin(x: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 15):
+    def signbit(x: _SupportsFloatOrIndex, /) -> bool: ...
+
+def sinh(x: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 12):
+    def sumprod(p: Iterable[float], q: Iterable[float], /) -> float: ...
+
+def sqrt(x: _SupportsFloatOrIndex, /) -> float: ...
+def tan(x: _SupportsFloatOrIndex, /) -> float: ...
+def tanh(x: _SupportsFloatOrIndex, /) -> float: ...
+
+# Is different from `_typeshed.SupportsTrunc`, which is not generic
+@type_check_only
+class _SupportsTrunc(Protocol[_T_co]):
+    def __trunc__(self) -> _T_co: ...
+
+def trunc(x: _SupportsTrunc[_T], /) -> _T: ...
+def ulp(x: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 13):
+    def fma(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, z: _SupportsFloatOrIndex, /) -> float: ...

package/analyzers/project-map-python/typeshed/stdlib/math/integer.pyi

@@ -0,0 +1,8 @@
+from typing import SupportsIndex
+
+def comb(n: SupportsIndex, k: SupportsIndex, /) -> int: ...
+def factorial(n: SupportsIndex, /) -> int: ...
+def gcd(*integers: SupportsIndex) -> int: ...
+def isqrt(n: SupportsIndex, /) -> int: ...
+def lcm(*integers: SupportsIndex) -> int: ...
+def perm(n: SupportsIndex, k: SupportsIndex | None = None, /) -> int: ...

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

@@ -0,0 +1,56 @@
+import sys
+from _typeshed import StrPath
+from collections.abc import Iterable
+from typing import IO
+
+__all__ = [
+    "knownfiles",
+    "inited",
+    "MimeTypes",
+    "guess_type",
+    "guess_all_extensions",
+    "guess_extension",
+    "add_type",
+    "init",
+    "read_mime_types",
+    "suffix_map",
+    "encodings_map",
+    "types_map",
+    "common_types",
+]
+
+if sys.version_info >= (3, 13):
+    __all__ += ["guess_file_type"]
+
+def guess_type(url: StrPath, strict: bool = True) -> tuple[str | None, str | None]: ...
+def guess_all_extensions(type: str, strict: bool = True) -> list[str]: ...
+def guess_extension(type: str, strict: bool = True) -> str | None: ...
+def init(files: Iterable[StrPath] | None = None) -> None: ...
+def read_mime_types(file: StrPath) -> dict[str, str] | None: ...
+def add_type(type: str, ext: str, strict: bool = True) -> None: ...
+
+if sys.version_info >= (3, 13):
+    def guess_file_type(path: StrPath, *, strict: bool = True) -> tuple[str | None, str | None]: ...
+
+inited: bool
+knownfiles: list[StrPath]
+suffix_map: dict[str, str]
+encodings_map: dict[str, str]
+types_map: dict[str, str]
+common_types: dict[str, str]
+
+class MimeTypes:
+    suffix_map: dict[str, str]
+    encodings_map: dict[str, str]
+    types_map: tuple[dict[str, str], dict[str, str]]
+    types_map_inv: tuple[dict[str, str], dict[str, str]]
+    def __init__(self, filenames: Iterable[StrPath] = (), strict: bool = True) -> None: ...
+    def add_type(self, type: str, ext: str, strict: bool = True) -> None: ...
+    def guess_extension(self, type: str, strict: bool = True) -> str | None: ...
+    def guess_type(self, url: StrPath, strict: bool = True) -> tuple[str | None, str | None]: ...
+    def guess_all_extensions(self, type: str, strict: bool = True) -> list[str]: ...
+    def read(self, filename: StrPath, strict: bool = True) -> None: ...
+    def readfp(self, fp: IO[str], strict: bool = True) -> None: ...
+    def read_windows_registry(self, strict: bool = True) -> None: ...
+    if sys.version_info >= (3, 13):
+        def guess_file_type(self, path: StrPath, *, strict: bool = True) -> tuple[str | None, str | None]: ...