layermap 0.1.0

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

@@ -0,0 +1,293 @@
+import sys
+from _typeshed import SupportsWrite, Unused
+from collections.abc import Generator, Iterable, Iterator, Mapping
+from types import FrameType, TracebackType
+from typing import Any, ClassVar, Literal, SupportsIndex, TypeAlias, overload
+from typing_extensions import Self, deprecated
+
+__all__ = [
+    "extract_stack",
+    "extract_tb",
+    "format_exception",
+    "format_exception_only",
+    "format_list",
+    "format_stack",
+    "format_tb",
+    "print_exc",
+    "format_exc",
+    "print_exception",
+    "print_last",
+    "print_stack",
+    "print_tb",
+    "clear_frames",
+    "FrameSummary",
+    "StackSummary",
+    "TracebackException",
+    "walk_stack",
+    "walk_tb",
+]
+
+if sys.version_info >= (3, 14):
+    __all__ += ["print_list"]
+
+_FrameSummaryTuple: TypeAlias = tuple[str, int, str, str | None]
+
+def print_tb(tb: TracebackType | None, limit: int | None = None, file: SupportsWrite[str] | None = None) -> None: ...
+
+@overload
+def print_exception(
+    exc: type[BaseException] | None,
+    /,
+    value: BaseException | None = ...,
+    tb: TracebackType | None = ...,
+    limit: int | None = None,
+    file: SupportsWrite[str] | None = None,
+    chain: bool = True,
+) -> None: ...
+@overload
+def print_exception(
+    exc: BaseException, /, *, limit: int | None = None, file: SupportsWrite[str] | None = None, chain: bool = True
+) -> None: ...
+
+@overload
+def format_exception(
+    exc: type[BaseException] | None,
+    /,
+    value: BaseException | None = ...,
+    tb: TracebackType | None = ...,
+    limit: int | None = None,
+    chain: bool = True,
+) -> list[str]: ...
+@overload
+def format_exception(exc: BaseException, /, *, limit: int | None = None, chain: bool = True) -> list[str]: ...
+
+def print_exc(limit: int | None = None, file: SupportsWrite[str] | None = None, chain: bool = True) -> None: ...
+def print_last(limit: int | None = None, file: SupportsWrite[str] | None = None, chain: bool = True) -> None: ...
+def print_stack(f: FrameType | None = None, limit: int | None = None, file: SupportsWrite[str] | None = None) -> None: ...
+def extract_tb(tb: TracebackType | None, limit: int | None = None) -> StackSummary: ...
+def extract_stack(f: FrameType | None = None, limit: int | None = None) -> StackSummary: ...
+def format_list(extracted_list: Iterable[FrameSummary | _FrameSummaryTuple]) -> list[str]: ...
+def print_list(extracted_list: Iterable[FrameSummary | _FrameSummaryTuple], file: SupportsWrite[str] | None = None) -> None: ...
+
+if sys.version_info >= (3, 13):
+    @overload
+    def format_exception_only(exc: BaseException | None, /, *, show_group: bool = False) -> list[str]: ...
+    @overload
+    def format_exception_only(exc: Unused, /, value: BaseException | None, *, show_group: bool = False) -> list[str]: ...
+else:
+    @overload
+    def format_exception_only(exc: BaseException | None, /) -> list[str]: ...
+    @overload
+    def format_exception_only(exc: Unused, /, value: BaseException | None) -> list[str]: ...
+
+def format_exc(limit: int | None = None, chain: bool = True) -> str: ...
+def format_tb(tb: TracebackType | None, limit: int | None = None) -> list[str]: ...
+def format_stack(f: FrameType | None = None, limit: int | None = None) -> list[str]: ...
+def clear_frames(tb: TracebackType | None) -> None: ...
+def walk_stack(f: FrameType | None) -> Iterator[tuple[FrameType, int]]: ...
+def walk_tb(tb: TracebackType | None) -> Iterator[tuple[FrameType, int]]: ...
+
+if sys.version_info >= (3, 11):
+    class _ExceptionPrintContext:
+        def indent(self) -> str: ...
+        def emit(self, text_gen: str | Iterable[str], margin_char: str | None = None) -> Generator[str]: ...
+
+class TracebackException:
+    __cause__: TracebackException | None
+    __context__: TracebackException | None
+    if sys.version_info >= (3, 11):
+        exceptions: list[TracebackException] | None
+    __suppress_context__: bool
+    if sys.version_info >= (3, 11):
+        __notes__: list[str] | None
+    stack: StackSummary
+
+    # These fields only exist for `SyntaxError`s, but there is no way to express that in the type system.
+    filename: str
+    lineno: str | None
+    end_lineno: str | None
+    text: str
+    offset: int
+    end_offset: int | None
+    msg: str
+
+    if sys.version_info >= (3, 13):
+        @property
+        def exc_type_str(self) -> str: ...
+        @property
+        @deprecated("Deprecated since Python 3.13. Use `exc_type_str` instead.")
+        def exc_type(self) -> type[BaseException] | None: ...
+    else:
+        exc_type: type[BaseException]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            exc_type: type[BaseException],
+            exc_value: BaseException,
+            exc_traceback: TracebackType | None,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            compact: bool = False,
+            max_group_width: int = 15,
+            max_group_depth: int = 10,
+            save_exc_type: bool = True,
+            _seen: set[int] | None = None,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            exc_type: type[BaseException],
+            exc_value: BaseException,
+            exc_traceback: TracebackType | None,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            compact: bool = False,
+            max_group_width: int = 15,
+            max_group_depth: int = 10,
+            _seen: set[int] | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            exc_type: type[BaseException],
+            exc_value: BaseException,
+            exc_traceback: TracebackType | None,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            compact: bool = False,
+            _seen: set[int] | None = None,
+        ) -> None: ...
+
+    if sys.version_info >= (3, 11):
+        @classmethod
+        def from_exception(
+            cls,
+            exc: BaseException,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            compact: bool = False,
+            max_group_width: int = 15,
+            max_group_depth: int = 10,
+        ) -> Self: ...
+    else:
+        @classmethod
+        def from_exception(
+            cls,
+            exc: BaseException,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            compact: bool = False,
+        ) -> Self: ...
+
+    def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    if sys.version_info >= (3, 11):
+        def format(self, *, chain: bool = True, _ctx: _ExceptionPrintContext | None = None) -> Generator[str]: ...
+    else:
+        def format(self, *, chain: bool = True) -> Generator[str]: ...
+
+    if sys.version_info >= (3, 13):
+        def format_exception_only(self, *, show_group: bool = False, _depth: int = 0) -> Generator[str]: ...
+    else:
+        def format_exception_only(self) -> Generator[str]: ...
+
+    if sys.version_info >= (3, 11):
+        def print(self, *, file: SupportsWrite[str] | None = None, chain: bool = True) -> None: ...
+
+class FrameSummary:
+    if sys.version_info >= (3, 13):
+        __slots__ = (
+            "filename",
+            "lineno",
+            "end_lineno",
+            "colno",
+            "end_colno",
+            "name",
+            "_lines",
+            "_lines_dedented",
+            "locals",
+            "_code",
+        )
+    elif sys.version_info >= (3, 11):
+        __slots__ = ("filename", "lineno", "end_lineno", "colno", "end_colno", "name", "_line", "locals")
+    else:
+        __slots__ = ("filename", "lineno", "name", "_line", "locals")
+    if sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            filename: str,
+            lineno: int | None,
+            name: str,
+            *,
+            lookup_line: bool = True,
+            locals: Mapping[str, str] | None = None,
+            line: str | None = None,
+            end_lineno: int | None = None,
+            colno: int | None = None,
+            end_colno: int | None = None,
+        ) -> None: ...
+        end_lineno: int | None
+        colno: int | None
+        end_colno: int | None
+    else:
+        def __init__(
+            self,
+            filename: str,
+            lineno: int | None,
+            name: str,
+            *,
+            lookup_line: bool = True,
+            locals: Mapping[str, str] | None = None,
+            line: str | None = None,
+        ) -> None: ...
+    filename: str
+    lineno: int | None
+    name: str
+    locals: dict[str, str] | None
+    @property
+    def line(self) -> str | None: ...
+
+    @overload
+    def __getitem__(self, pos: Literal[0]) -> str: ...
+    @overload
+    def __getitem__(self, pos: Literal[1]) -> int: ...
+    @overload
+    def __getitem__(self, pos: Literal[2]) -> str: ...
+    @overload
+    def __getitem__(self, pos: Literal[3]) -> str | None: ...
+    @overload
+    def __getitem__(self, pos: SupportsIndex) -> Any: ...
+    @overload
+    def __getitem__(self, pos: slice[SupportsIndex | None]) -> tuple[Any, ...]: ...
+
+    def __iter__(self) -> Iterator[Any]: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __len__(self) -> Literal[4]: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+
+class StackSummary(list[FrameSummary]):
+    @classmethod
+    def extract(
+        cls,
+        frame_gen: Iterable[tuple[FrameType, int]],
+        *,
+        limit: int | None = None,
+        lookup_lines: bool = True,
+        capture_locals: bool = False,
+    ) -> StackSummary: ...
+    @classmethod
+    def from_list(cls, a_list: Iterable[FrameSummary | _FrameSummaryTuple]) -> StackSummary: ...
+    if sys.version_info >= (3, 11):
+        def format_frame_summary(self, frame_summary: FrameSummary) -> str: ...
+
+    def format(self) -> list[str]: ...

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

@@ -0,0 +1,123 @@
+import sys
+from _tracemalloc import *
+from collections.abc import Sequence
+from typing import Any, SupportsIndex, TypeAlias, overload
+
+def get_object_traceback(obj: object) -> Traceback | None: ...
+def take_snapshot() -> Snapshot: ...
+
+class BaseFilter:
+    inclusive: bool
+    def __init__(self, inclusive: bool) -> None: ...
+
+class DomainFilter(BaseFilter):
+    @property
+    def domain(self) -> int: ...
+    def __init__(self, inclusive: bool, domain: int) -> None: ...
+
+class Filter(BaseFilter):
+    domain: int | None
+    lineno: int | None
+    @property
+    def filename_pattern(self) -> str: ...
+    all_frames: bool
+    def __init__(
+        self,
+        inclusive: bool,
+        filename_pattern: str,
+        lineno: int | None = None,
+        all_frames: bool = False,
+        domain: int | None = None,
+    ) -> None: ...
+
+class Statistic:
+    __slots__ = ("traceback", "size", "count")
+    count: int
+    size: int
+    traceback: Traceback
+    def __init__(self, traceback: Traceback, size: int, count: int) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+
+class StatisticDiff:
+    __slots__ = ("traceback", "size", "size_diff", "count", "count_diff")
+    count: int
+    count_diff: int
+    size: int
+    size_diff: int
+    traceback: Traceback
+    def __init__(self, traceback: Traceback, size: int, size_diff: int, count: int, count_diff: int) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+
+_FrameTuple: TypeAlias = tuple[str, int]
+
+class Frame:
+    __slots__ = ("_frame",)
+    @property
+    def filename(self) -> str: ...
+    @property
+    def lineno(self) -> int: ...
+    def __init__(self, frame: _FrameTuple) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __lt__(self, other: Frame) -> bool: ...
+    if sys.version_info >= (3, 11):
+        def __gt__(self, other: Frame) -> bool: ...
+        def __ge__(self, other: Frame) -> bool: ...
+        def __le__(self, other: Frame) -> bool: ...
+    else:
+        def __gt__(self, other: Frame, NotImplemented: Any = ...) -> bool: ...
+        def __ge__(self, other: Frame, NotImplemented: Any = ...) -> bool: ...
+        def __le__(self, other: Frame, NotImplemented: Any = ...) -> bool: ...
+
+_TraceTuple: TypeAlias = tuple[int, int, Sequence[_FrameTuple], int | None] | tuple[int, int, Sequence[_FrameTuple]]
+
+class Trace:
+    __slots__ = ("_trace",)
+    @property
+    def domain(self) -> int: ...
+    @property
+    def size(self) -> int: ...
+    @property
+    def traceback(self) -> Traceback: ...
+    def __init__(self, trace: _TraceTuple) -> None: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+
+class Traceback(Sequence[Frame]):
+    __slots__ = ("_frames", "_total_nframe")
+    @property
+    def total_nframe(self) -> int | None: ...
+    def __init__(self, frames: Sequence[_FrameTuple], total_nframe: int | None = None) -> None: ...
+    def format(self, limit: int | None = None, most_recent_first: bool = False) -> list[str]: ...
+
+    @overload
+    def __getitem__(self, index: SupportsIndex) -> Frame: ...
+    @overload
+    def __getitem__(self, index: slice[SupportsIndex | None]) -> Sequence[Frame]: ...
+
+    def __contains__(self, frame: Frame) -> bool: ...  # type: ignore[override]
+    def __len__(self) -> int: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __lt__(self, other: Traceback) -> bool: ...
+    if sys.version_info >= (3, 11):
+        def __gt__(self, other: Traceback) -> bool: ...
+        def __ge__(self, other: Traceback) -> bool: ...
+        def __le__(self, other: Traceback) -> bool: ...
+    else:
+        def __gt__(self, other: Traceback, NotImplemented: Any = ...) -> bool: ...
+        def __ge__(self, other: Traceback, NotImplemented: Any = ...) -> bool: ...
+        def __le__(self, other: Traceback, NotImplemented: Any = ...) -> bool: ...
+
+class Snapshot:
+    def __init__(self, traces: Sequence[_TraceTuple], traceback_limit: int) -> None: ...
+    def compare_to(self, old_snapshot: Snapshot, key_type: str, cumulative: bool = False) -> list[StatisticDiff]: ...
+    def dump(self, filename: str) -> None: ...
+    def filter_traces(self, filters: Sequence[DomainFilter | Filter]) -> Snapshot: ...
+    @staticmethod
+    def load(filename: str) -> Snapshot: ...
+    def statistics(self, key_type: str, cumulative: bool = False) -> list[Statistic]: ...
+    traceback_limit: int
+    traces: Sequence[Trace]

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

@@ -0,0 +1,29 @@
+import sys
+import termios
+from typing import IO, Final, TypeAlias
+
+if sys.platform != "win32":
+    __all__ = ["setraw", "setcbreak"]
+    if sys.version_info >= (3, 12):
+        __all__ += ["cfmakeraw", "cfmakecbreak"]
+
+        _ModeSetterReturn: TypeAlias = termios._AttrReturn
+    else:
+        _ModeSetterReturn: TypeAlias = None
+
+    _FD: TypeAlias = int | IO[str]
+
+    # XXX: Undocumented integer constants
+    IFLAG: Final = 0
+    OFLAG: Final = 1
+    CFLAG: Final = 2
+    LFLAG: Final = 3
+    ISPEED: Final = 4
+    OSPEED: Final = 5
+    CC: Final = 6
+    def setraw(fd: _FD, when: int = 2) -> _ModeSetterReturn: ...
+    def setcbreak(fd: _FD, when: int = 2) -> _ModeSetterReturn: ...
+
+    if sys.version_info >= (3, 12):
+        def cfmakeraw(mode: termios._Attr) -> None: ...
+        def cfmakecbreak(mode: termios._Attr) -> None: ...