layermap 0.1.0

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

@@ -0,0 +1,121 @@
+import sys
+from _bz2 import BZ2Compressor as BZ2Compressor, BZ2Decompressor as BZ2Decompressor
+from _typeshed import ReadableBuffer, StrOrBytesPath, WriteableBuffer
+from collections.abc import Iterable
+from io import TextIOWrapper
+from typing import IO, Literal, Protocol, SupportsIndex, TypeAlias, overload, type_check_only
+from typing_extensions import Self
+
+if sys.version_info >= (3, 14):
+    from compression._common._streams import BaseStream, _Reader
+else:
+    from _compression import BaseStream, _Reader
+
+__all__ = ["BZ2File", "BZ2Compressor", "BZ2Decompressor", "open", "compress", "decompress"]
+
+# The following attributes and methods are optional:
+# def fileno(self) -> int: ...
+# def close(self) -> object: ...
+@type_check_only
+class _ReadableFileobj(_Reader, Protocol): ...
+
+@type_check_only
+class _WritableFileobj(Protocol):
+    def write(self, b: bytes, /) -> object: ...
+    # The following attributes and methods are optional:
+    # def fileno(self) -> int: ...
+    # def close(self) -> object: ...
+
+def compress(data: ReadableBuffer, compresslevel: int = 9) -> bytes: ...
+def decompress(data: ReadableBuffer) -> bytes: ...
+
+_ReadBinaryMode: TypeAlias = Literal["", "r", "rb"]
+_WriteBinaryMode: TypeAlias = Literal["w", "wb", "x", "xb", "a", "ab"]
+_ReadTextMode: TypeAlias = Literal["rt"]
+_WriteTextMode: TypeAlias = Literal["wt", "xt", "at"]
+
+@overload
+def open(
+    filename: _ReadableFileobj,
+    mode: _ReadBinaryMode = "rb",
+    compresslevel: int = 9,
+    encoding: None = None,
+    errors: None = None,
+    newline: None = None,
+) -> BZ2File: ...
+@overload
+def open(
+    filename: _ReadableFileobj,
+    mode: _ReadTextMode,
+    compresslevel: int = 9,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
+) -> TextIOWrapper: ...
+@overload
+def open(
+    filename: _WritableFileobj,
+    mode: _WriteBinaryMode,
+    compresslevel: int = 9,
+    encoding: None = None,
+    errors: None = None,
+    newline: None = None,
+) -> BZ2File: ...
+@overload
+def open(
+    filename: _WritableFileobj,
+    mode: _WriteTextMode,
+    compresslevel: int = 9,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
+) -> TextIOWrapper: ...
+@overload
+def open(
+    filename: StrOrBytesPath,
+    mode: _ReadBinaryMode | _WriteBinaryMode = "rb",
+    compresslevel: int = 9,
+    encoding: None = None,
+    errors: None = None,
+    newline: None = None,
+) -> BZ2File: ...
+@overload
+def open(
+    filename: StrOrBytesPath,
+    mode: _ReadTextMode | _WriteTextMode,
+    compresslevel: int = 9,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
+) -> TextIOWrapper: ...
+@overload
+def open(
+    filename: StrOrBytesPath | _ReadableFileobj | _WritableFileobj,
+    mode: str,
+    compresslevel: int = 9,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
+) -> BZ2File | TextIOWrapper: ...
+
+class BZ2File(BaseStream, IO[bytes]):
+    def __enter__(self) -> Self: ...
+
+    @overload
+    def __init__(self, filename: _WritableFileobj, mode: _WriteBinaryMode, *, compresslevel: int = 9) -> None: ...
+    @overload
+    def __init__(self, filename: _ReadableFileobj, mode: _ReadBinaryMode = "r", *, compresslevel: int = 9) -> None: ...
+    @overload
+    def __init__(
+        self, filename: StrOrBytesPath, mode: _ReadBinaryMode | _WriteBinaryMode = "r", *, compresslevel: int = 9
+    ) -> None: ...
+
+    def read(self, size: int | None = -1) -> bytes: ...
+    def read1(self, size: int = -1) -> bytes: ...
+    def readline(self, size: SupportsIndex = -1) -> bytes: ...  # type: ignore[override]
+    def readinto(self, b: WriteableBuffer) -> int: ...
+    def readlines(self, size: SupportsIndex = -1) -> list[bytes]: ...
+    def peek(self, n: int = 0) -> bytes: ...
+    def seek(self, offset: int, whence: int = 0) -> int: ...
+    def write(self, data: ReadableBuffer) -> int: ...
+    def writelines(self, seq: Iterable[ReadableBuffer]) -> None: ...

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

@@ -0,0 +1,33 @@
+import _lsprof
+import sys
+from _typeshed import StrOrBytesPath, Unused
+from collections.abc import Callable, Mapping
+from types import CodeType
+from typing import Any, ParamSpec, TypeAlias, TypeVar
+from typing_extensions import Self
+
+__all__ = ["run", "runctx", "Profile"]
+
+def run(statement: str, filename: str | None = None, sort: str | int = -1) -> None: ...
+def runctx(
+    statement: str, globals: dict[str, Any], locals: Mapping[str, Any], filename: str | None = None, sort: str | int = -1
+) -> None: ...
+
+_T = TypeVar("_T")
+_P = ParamSpec("_P")
+_Label: TypeAlias = tuple[str, int, str]
+
+class Profile(_lsprof.Profiler):
+    stats: dict[_Label, tuple[int, int, int, int, dict[_Label, tuple[int, int, int, int]]]]  # undocumented
+    def print_stats(self, sort: str | int = -1) -> None: ...
+    def dump_stats(self, file: StrOrBytesPath) -> None: ...
+    def create_stats(self) -> None: ...
+    def snapshot_stats(self) -> None: ...
+    def run(self, cmd: str) -> Self: ...
+    def runctx(self, cmd: str, globals: dict[str, Any], locals: Mapping[str, Any]) -> Self: ...
+    def runcall(self, func: Callable[_P, _T], /, *args: _P.args, **kw: _P.kwargs) -> _T: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *exc_info: Unused) -> None: ...
+
+if sys.version_info < (3, 15):
+    def label(code: str | CodeType) -> _Label: ...  # undocumented

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

@@ -0,0 +1,249 @@
+import datetime
+import enum
+import sys
+from _typeshed import Unused
+from collections.abc import Iterable, Iterator
+from time import struct_time
+from typing import ClassVar, Final, TypeAlias, overload
+
+__all__ = [
+    "FRIDAY",
+    "MONDAY",
+    "SATURDAY",
+    "SUNDAY",
+    "THURSDAY",
+    "TUESDAY",
+    "WEDNESDAY",
+    "IllegalMonthError",
+    "IllegalWeekdayError",
+    "setfirstweekday",
+    "firstweekday",
+    "isleap",
+    "leapdays",
+    "weekday",
+    "monthrange",
+    "monthcalendar",
+    "prmonth",
+    "month",
+    "prcal",
+    "calendar",
+    "timegm",
+    "month_name",
+    "month_abbr",
+    "day_name",
+    "day_abbr",
+    "Calendar",
+    "TextCalendar",
+    "HTMLCalendar",
+    "LocaleTextCalendar",
+    "LocaleHTMLCalendar",
+    "weekheader",
+]
+
+if sys.version_info >= (3, 12):
+    __all__ += [
+        "Day",
+        "Month",
+        "JANUARY",
+        "FEBRUARY",
+        "MARCH",
+        "APRIL",
+        "MAY",
+        "JUNE",
+        "JULY",
+        "AUGUST",
+        "SEPTEMBER",
+        "OCTOBER",
+        "NOVEMBER",
+        "DECEMBER",
+    ]
+if sys.version_info >= (3, 15):
+    __all__ += ["standalone_month_name", "standalone_month_abbr"]
+
+_LocaleType: TypeAlias = tuple[str | None, str | None]
+
+class IllegalMonthError(ValueError, IndexError):
+    month: int
+    def __init__(self, month: int) -> None: ...
+
+class IllegalWeekdayError(ValueError):
+    weekday: int
+    def __init__(self, weekday: int) -> None: ...
+
+def isleap(year: int) -> bool: ...
+def leapdays(y1: int, y2: int) -> int: ...
+def weekday(year: int, month: int, day: int) -> int: ...
+def monthrange(year: int, month: int) -> tuple[int, int]: ...
+
+class Calendar:
+    firstweekday: int
+    def __init__(self, firstweekday: int = 0) -> None: ...
+    def getfirstweekday(self) -> int: ...
+    def setfirstweekday(self, firstweekday: int) -> None: ...
+    def iterweekdays(self) -> Iterator[int]: ...
+    def itermonthdates(self, year: int, month: int) -> Iterator[datetime.date]: ...
+    def itermonthdays2(self, year: int, month: int) -> Iterator[tuple[int, int]]: ...
+    def itermonthdays(self, year: int, month: int) -> Iterator[int]: ...
+    def monthdatescalendar(self, year: int, month: int) -> list[list[datetime.date]]: ...
+    def monthdays2calendar(self, year: int, month: int) -> list[list[tuple[int, int]]]: ...
+    def monthdayscalendar(self, year: int, month: int) -> list[list[int]]: ...
+    def yeardatescalendar(self, year: int, width: int = 3) -> list[list[list[list[datetime.date]]]]: ...
+    def yeardays2calendar(self, year: int, width: int = 3) -> list[list[list[list[tuple[int, int]]]]]: ...
+    def yeardayscalendar(self, year: int, width: int = 3) -> list[list[list[list[int]]]]: ...
+    def itermonthdays3(self, year: int, month: int) -> Iterator[tuple[int, int, int]]: ...
+    def itermonthdays4(self, year: int, month: int) -> Iterator[tuple[int, int, int, int]]: ...
+
+class TextCalendar(Calendar):
+    def prweek(self, theweek: Iterable[tuple[int, int]], width: int) -> None: ...
+    def formatday(self, day: int, weekday: int, width: int) -> str: ...
+    def formatweek(self, theweek: Iterable[tuple[int, int]], width: int) -> str: ...
+    def formatweekday(self, day: int, width: int) -> str: ...
+    def formatweekheader(self, width: int) -> str: ...
+    def formatmonthname(self, theyear: int, themonth: int, width: int, withyear: bool = True) -> str: ...
+    def prmonth(self, theyear: int, themonth: int, w: int = 0, l: int = 0) -> None: ...
+    def formatmonth(self, theyear: int, themonth: int, w: int = 0, l: int = 0) -> str: ...
+    def formatyear(self, theyear: int, w: int = 2, l: int = 1, c: int = 6, m: int = 3) -> str: ...
+    def pryear(self, theyear: int, w: int = 0, l: int = 0, c: int = 6, m: int = 3) -> None: ...
+
+def firstweekday() -> int: ...
+def monthcalendar(year: int, month: int) -> list[list[int]]: ...
+def prweek(theweek: int, width: int) -> None: ...
+def week(theweek: int, width: int) -> str: ...
+def weekheader(width: int) -> str: ...
+def prmonth(theyear: int, themonth: int, w: int = 0, l: int = 0) -> None: ...
+def month(theyear: int, themonth: int, w: int = 0, l: int = 0) -> str: ...
+def calendar(theyear: int, w: int = 2, l: int = 1, c: int = 6, m: int = 3) -> str: ...
+def prcal(theyear: int, w: int = 0, l: int = 0, c: int = 6, m: int = 3) -> None: ...
+
+class HTMLCalendar(Calendar):
+    cssclasses: ClassVar[list[str]]
+    cssclass_noday: ClassVar[str]
+    cssclasses_weekday_head: ClassVar[list[str]]
+    cssclass_month_head: ClassVar[str]
+    cssclass_month: ClassVar[str]
+    cssclass_year: ClassVar[str]
+    cssclass_year_head: ClassVar[str]
+    def formatday(self, day: int, weekday: int) -> str: ...
+    def formatweek(self, theweek: int) -> str: ...
+    def formatweekday(self, day: int) -> str: ...
+    def formatweekheader(self) -> str: ...
+    def formatmonthname(self, theyear: int, themonth: int, withyear: bool = True) -> str: ...
+    def formatmonth(self, theyear: int, themonth: int, withyear: bool = True) -> str: ...
+    if sys.version_info >= (3, 15):
+        def formatmonthpage(
+            self, theyear: int, themonth: int, width: int = 3, css: str | None = "calendar.css", encoding: str | None = None
+        ) -> bytes: ...
+
+    def formatyear(self, theyear: int, width: int = 3) -> str: ...
+    def formatyearpage(
+        self, theyear: int, width: int = 3, css: str | None = "calendar.css", encoding: str | None = None
+    ) -> bytes: ...
+
+class different_locale:
+    def __init__(self, locale: _LocaleType) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(self, *args: Unused) -> None: ...
+
+class LocaleTextCalendar(TextCalendar):
+    def __init__(self, firstweekday: int = 0, locale: _LocaleType | None = None) -> None: ...
+
+class LocaleHTMLCalendar(HTMLCalendar):
+    def __init__(self, firstweekday: int = 0, locale: _LocaleType | None = None) -> None: ...
+    def formatweekday(self, day: int) -> str: ...
+    def formatmonthname(self, theyear: int, themonth: int, withyear: bool = True) -> str: ...
+
+c: TextCalendar
+
+def setfirstweekday(firstweekday: int) -> None: ...
+def format(cols: int, colwidth: int = 20, spacing: int = 6) -> str: ...
+def formatstring(cols: Iterable[str], colwidth: int = 20, spacing: int = 6) -> str: ...
+def timegm(tuple: tuple[int, ...] | struct_time) -> int: ...
+
+# Data attributes
+class _localized_month:
+    format: str
+    def __init__(self, format: str) -> None: ...
+
+    @overload
+    def __getitem__(self, i: int) -> str: ...
+    @overload
+    def __getitem__(self, i: slice) -> list[str]: ...
+
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[str]: ...
+
+class _localized_day:
+    format: str
+    def __init__(self, format: str) -> None: ...
+
+    @overload
+    def __getitem__(self, i: int) -> str: ...
+    @overload
+    def __getitem__(self, i: slice) -> list[str]: ...
+
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[str]: ...
+
+day_name: _localized_day
+day_abbr: _localized_day
+month_name: _localized_month
+month_abbr: _localized_month
+
+if sys.version_info >= (3, 12):
+    class Month(enum.IntEnum):
+        JANUARY = 1
+        FEBRUARY = 2
+        MARCH = 3
+        APRIL = 4
+        MAY = 5
+        JUNE = 6
+        JULY = 7
+        AUGUST = 8
+        SEPTEMBER = 9
+        OCTOBER = 10
+        NOVEMBER = 11
+        DECEMBER = 12
+
+    JANUARY: Final = Month.JANUARY
+    FEBRUARY: Final = Month.FEBRUARY
+    MARCH: Final = Month.MARCH
+    APRIL: Final = Month.APRIL
+    MAY: Final = Month.MAY
+    JUNE: Final = Month.JUNE
+    JULY: Final = Month.JULY
+    AUGUST: Final = Month.AUGUST
+    SEPTEMBER: Final = Month.SEPTEMBER
+    OCTOBER: Final = Month.OCTOBER
+    NOVEMBER: Final = Month.NOVEMBER
+    DECEMBER: Final = Month.DECEMBER
+
+    class Day(enum.IntEnum):
+        MONDAY = 0
+        TUESDAY = 1
+        WEDNESDAY = 2
+        THURSDAY = 3
+        FRIDAY = 4
+        SATURDAY = 5
+        SUNDAY = 6
+
+    MONDAY: Final = Day.MONDAY
+    TUESDAY: Final = Day.TUESDAY
+    WEDNESDAY: Final = Day.WEDNESDAY
+    THURSDAY: Final = Day.THURSDAY
+    FRIDAY: Final = Day.FRIDAY
+    SATURDAY: Final = Day.SATURDAY
+    SUNDAY: Final = Day.SUNDAY
+else:
+    MONDAY: Final = 0
+    TUESDAY: Final = 1
+    WEDNESDAY: Final = 2
+    THURSDAY: Final = 3
+    FRIDAY: Final = 4
+    SATURDAY: Final = 5
+    SUNDAY: Final = 6
+
+EPOCH: Final = 1970
+
+if sys.version_info >= (3, 15):
+    standalone_month_name: _localized_month
+    standalone_month_abbr: _localized_month

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

@@ -0,0 +1,120 @@
+import os
+from _typeshed import SupportsContainsAndGetItem, SupportsGetItem, SupportsItemAccess, Unused
+from builtins import list as _list, type as _type
+from collections.abc import Iterable, Iterator, Mapping
+from email.message import Message
+from types import TracebackType
+from typing import IO, Any, Protocol, type_check_only
+from typing_extensions import Self
+
+__all__ = [
+    "MiniFieldStorage",
+    "FieldStorage",
+    "parse",
+    "parse_multipart",
+    "parse_header",
+    "test",
+    "print_exception",
+    "print_environ",
+    "print_form",
+    "print_directory",
+    "print_arguments",
+    "print_environ_usage",
+]
+
+def parse(
+    fp: IO[Any] | None = None,
+    environ: SupportsItemAccess[str, str] = os.environ,
+    keep_blank_values: bool = ...,
+    strict_parsing: bool = ...,
+    separator: str = "&",
+) -> dict[str, list[str]]: ...
+def parse_multipart(
+    fp: IO[Any], pdict: SupportsGetItem[str, bytes], encoding: str = "utf-8", errors: str = "replace", separator: str = "&"
+) -> dict[str, list[Any]]: ...
+
+@type_check_only
+class _Environ(Protocol):
+    def __getitem__(self, k: str, /) -> str: ...
+    def keys(self) -> Iterable[str]: ...
+
+def parse_header(line: str) -> tuple[str, dict[str, str]]: ...
+def test(environ: _Environ = os.environ) -> None: ...
+def print_environ(environ: _Environ = os.environ) -> None: ...
+def print_form(form: dict[str, Any]) -> None: ...
+def print_directory() -> None: ...
+def print_environ_usage() -> None: ...
+
+class MiniFieldStorage:
+    # The first five "Any" attributes here are always None, but mypy doesn't support that
+    filename: Any
+    list: Any
+    type: Any
+    file: IO[bytes] | None
+    type_options: dict[Any, Any]
+    disposition: Any
+    disposition_options: dict[Any, Any]
+    headers: dict[Any, Any]
+    name: Any
+    value: Any
+    def __init__(self, name: Any, value: Any) -> None: ...
+
+class FieldStorage:
+    FieldStorageClass: _type | None
+    keep_blank_values: int
+    strict_parsing: int
+    qs_on_post: str | None
+    headers: Mapping[str, str] | Message
+    fp: IO[bytes]
+    encoding: str
+    errors: str
+    outerboundary: bytes
+    bytes_read: int
+    limit: int | None
+    disposition: str
+    disposition_options: dict[str, str]
+    filename: str | None
+    file: IO[bytes] | None
+    type: str
+    type_options: dict[str, str]
+    innerboundary: bytes
+    length: int
+    done: int
+    list: _list[Any] | None
+    value: None | bytes | _list[Any]
+    def __init__(
+        self,
+        fp: IO[Any] | None = None,
+        headers: Mapping[str, str] | Message | None = None,
+        outerboundary: bytes = b"",
+        environ: SupportsContainsAndGetItem[str, str] = os.environ,
+        keep_blank_values: int = 0,
+        strict_parsing: int = 0,
+        limit: int | None = None,
+        encoding: str = "utf-8",
+        errors: str = "replace",
+        max_num_fields: int | None = None,
+        separator: str = "&",
+    ) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *args: Unused) -> None: ...
+    def __iter__(self) -> Iterator[str]: ...
+    def __getitem__(self, key: str) -> Any: ...
+    def getvalue(self, key: str, default: Any = None) -> Any: ...
+    def getfirst(self, key: str, default: Any = None) -> Any: ...
+    def getlist(self, key: str) -> _list[Any]: ...
+    def keys(self) -> _list[str]: ...
+    def __contains__(self, key: str) -> bool: ...
+    def __len__(self) -> int: ...
+    def __bool__(self) -> bool: ...
+    def __del__(self) -> None: ...
+    # Returns bytes or str IO depending on an internal flag
+    def make_file(self) -> IO[Any]: ...
+
+def print_exception(
+    type: type[BaseException] | None = None,
+    value: BaseException | None = None,
+    tb: TracebackType | None = None,
+    limit: int | None = None,
+) -> None: ...
+def print_arguments() -> None: ...

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

@@ -0,0 +1,32 @@
+from _typeshed import OptExcInfo, StrOrBytesPath
+from collections.abc import Callable
+from types import FrameType, TracebackType
+from typing import IO, Any, Final
+
+__UNDEF__: Final[object]  # undocumented sentinel
+
+def reset() -> str: ...  # undocumented
+def small(text: str) -> str: ...  # undocumented
+def strong(text: str) -> str: ...  # undocumented
+def grey(text: str) -> str: ...  # undocumented
+def lookup(name: str, frame: FrameType, locals: dict[str, Any]) -> tuple[str | None, Any]: ...  # undocumented
+def scanvars(
+    reader: Callable[[], bytes], frame: FrameType, locals: dict[str, Any]
+) -> list[tuple[str, str | None, Any]]: ...  # undocumented
+def html(einfo: OptExcInfo, context: int = 5) -> str: ...
+def text(einfo: OptExcInfo, context: int = 5) -> str: ...
+
+class Hook:  # undocumented
+    def __init__(
+        self,
+        display: int = 1,
+        logdir: StrOrBytesPath | None = None,
+        context: int = 5,
+        file: IO[str] | None = None,
+        format: str = "html",
+    ) -> None: ...
+    def __call__(self, etype: type[BaseException] | None, evalue: BaseException | None, etb: TracebackType | None) -> None: ...
+    def handle(self, info: OptExcInfo | None = None) -> None: ...
+
+def handler(info: OptExcInfo | None = None) -> None: ...
+def enable(display: int = 1, logdir: StrOrBytesPath | None = None, context: int = 5, format: str = "html") -> None: ...

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

@@ -0,0 +1,20 @@
+from typing import IO
+
+class Chunk:
+    closed: bool
+    align: bool
+    file: IO[bytes]
+    chunkname: bytes
+    chunksize: int
+    size_read: int
+    offset: int
+    seekable: bool
+    def __init__(self, file: IO[bytes], align: bool = True, bigendian: bool = True, inclheader: bool = False) -> None: ...
+    def getname(self) -> bytes: ...
+    def getsize(self) -> int: ...
+    def close(self) -> None: ...
+    def isatty(self) -> bool: ...
+    def seek(self, pos: int, whence: int = 0) -> None: ...
+    def tell(self) -> int: ...
+    def read(self, size: int = -1) -> bytes: ...
+    def skip(self) -> None: ...

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

@@ -0,0 +1,36 @@
+from typing import Final, SupportsComplex, SupportsFloat, SupportsIndex, TypeAlias
+
+e: Final[float]
+pi: Final[float]
+inf: Final[float]
+infj: Final[complex]
+nan: Final[float]
+nanj: Final[complex]
+tau: Final[float]
+
+_F: TypeAlias = SupportsFloat | SupportsIndex
+_C: TypeAlias = SupportsFloat | SupportsComplex | SupportsIndex | complex
+
+def acos(z: _C, /) -> complex: ...
+def acosh(z: _C, /) -> complex: ...
+def asin(z: _C, /) -> complex: ...
+def asinh(z: _C, /) -> complex: ...
+def atan(z: _C, /) -> complex: ...
+def atanh(z: _C, /) -> complex: ...
+def cos(z: _C, /) -> complex: ...
+def cosh(z: _C, /) -> complex: ...
+def exp(z: _C, /) -> complex: ...
+def isclose(a: _C, b: _C, *, rel_tol: SupportsFloat = 1e-09, abs_tol: SupportsFloat = 0.0) -> bool: ...
+def isinf(z: _C, /) -> bool: ...
+def isnan(z: _C, /) -> bool: ...
+def log(z: _C, base: _C = ..., /) -> complex: ...
+def log10(z: _C, /) -> complex: ...
+def phase(z: _C, /) -> float: ...
+def polar(z: _C, /) -> tuple[float, float]: ...
+def rect(r: _F, phi: _F, /) -> complex: ...
+def sin(z: _C, /) -> complex: ...
+def sinh(z: _C, /) -> complex: ...
+def sqrt(z: _C, /) -> complex: ...
+def tan(z: _C, /) -> complex: ...
+def tanh(z: _C, /) -> complex: ...
+def isfinite(z: _C, /) -> bool: ...

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

@@ -0,0 +1,46 @@
+from collections.abc import Callable
+from typing import IO, Any, Final
+from typing_extensions import LiteralString
+
+__all__ = ["Cmd"]
+
+PROMPT: Final = "(Cmd) "
+IDENTCHARS: Final[LiteralString]  # Too big to be `Literal`
+
+class Cmd:
+    prompt: str
+    identchars: str
+    ruler: str
+    lastcmd: str
+    intro: Any | None
+    doc_leader: str
+    doc_header: str
+    misc_header: str
+    undoc_header: str
+    nohelp: str
+    use_rawinput: bool
+    stdin: IO[str]
+    stdout: IO[str]
+    cmdqueue: list[str]
+    completekey: str
+    def __init__(self, completekey: str = "tab", stdin: IO[str] | None = None, stdout: IO[str] | None = None) -> None: ...
+    old_completer: Callable[[str, int], str | None] | None
+    def cmdloop(self, intro: Any | None = None) -> None: ...
+    def precmd(self, line: str) -> str: ...
+    def postcmd(self, stop: bool, line: str) -> bool: ...
+    def preloop(self) -> None: ...
+    def postloop(self) -> None: ...
+    def parseline(self, line: str) -> tuple[str | None, str | None, str]: ...
+    def onecmd(self, line: str) -> bool: ...
+    def emptyline(self) -> bool: ...
+    def default(self, line: str) -> None: ...
+    def completedefault(self, *ignored: Any) -> list[str]: ...
+    def completenames(self, text: str, *ignored: Any) -> list[str]: ...
+    completion_matches: list[str] | None
+    def complete(self, text: str, state: int) -> list[str] | None: ...
+    def get_names(self) -> list[str]: ...
+    # Only the first element of args matters.
+    def complete_help(self, *args: Any) -> list[str]: ...
+    def do_help(self, arg: str) -> bool | None: ...
+    def print_topics(self, header: str, cmds: list[str] | None, cmdlen: Any, maxcol: int) -> None: ...
+    def columnize(self, list: list[str] | None, displaywidth: int = 80) -> None: ...