layermap 0.1.0

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

@@ -0,0 +1,24 @@
+from _typeshed import Unused
+from types import ModuleType
+from typing import Any
+from typing_extensions import Self
+
+__all__ = ["run_module", "run_path"]
+
+class _TempModule:
+    mod_name: str
+    module: ModuleType
+    def __init__(self, mod_name: str) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *args: Unused) -> None: ...
+
+class _ModifiedArgv0:
+    value: Any
+    def __init__(self, value: Any) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(self, *args: Unused) -> None: ...
+
+def run_module(
+    mod_name: str, init_globals: dict[str, Any] | None = None, run_name: str | None = None, alter_sys: bool = False
+) -> dict[str, Any]: ...
+def run_path(path_name: str, init_globals: dict[str, Any] | None = None, run_name: str | None = None) -> dict[str, Any]: ...

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

@@ -0,0 +1,34 @@
+import time
+from collections.abc import Callable
+from typing import Any, NamedTuple, TypeAlias
+
+__all__ = ["scheduler"]
+
+_ActionCallback: TypeAlias = Callable[..., Any]
+
+class Event(NamedTuple):
+    time: float
+    priority: Any
+    sequence: int
+    action: _ActionCallback
+    argument: tuple[Any, ...]
+    kwargs: dict[str, Any]
+
+class scheduler:
+    timefunc: Callable[[], float]
+    delayfunc: Callable[[float], object]
+
+    def __init__(
+        self, timefunc: Callable[[], float] = time.monotonic, delayfunc: Callable[[float], object] = time.sleep
+    ) -> None: ...
+    def enterabs(
+        self, time: float, priority: Any, action: _ActionCallback, argument: tuple[Any, ...] = (), kwargs: dict[str, Any] = ...
+    ) -> Event: ...
+    def enter(
+        self, delay: float, priority: Any, action: _ActionCallback, argument: tuple[Any, ...] = (), kwargs: dict[str, Any] = ...
+    ) -> Event: ...
+    def run(self, blocking: bool = True) -> float | None: ...
+    def cancel(self, event: Event) -> None: ...
+    def empty(self) -> bool: ...
+    @property
+    def queue(self) -> list[Event]: ...

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

@@ -0,0 +1,17 @@
+from _typeshed import SupportsLenAndGetItem
+from hmac import compare_digest as compare_digest
+from random import SystemRandom as SystemRandom
+from typing import Final, TypeVar
+
+__all__ = ["choice", "randbelow", "randbits", "SystemRandom", "token_bytes", "token_hex", "token_urlsafe", "compare_digest"]
+
+_T = TypeVar("_T")
+
+DEFAULT_ENTROPY: Final[int]
+
+def randbelow(exclusive_upper_bound: int) -> int: ...
+def randbits(k: int) -> int: ...
+def choice(seq: SupportsLenAndGetItem[_T]) -> _T: ...
+def token_bytes(nbytes: int | None = None) -> bytes: ...
+def token_hex(nbytes: int | None = None) -> str: ...
+def token_urlsafe(nbytes: int | None = None) -> str: ...

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

@@ -0,0 +1,171 @@
+import sys
+from _typeshed import FileDescriptorLike
+from collections.abc import Iterable
+from types import TracebackType
+from typing import Any, ClassVar, Final, TypeVar, final, overload
+from typing_extensions import Never, Self, deprecated
+
+if sys.platform != "win32":
+    PIPE_BUF: Final[int]
+    POLLERR: Final[int]
+    POLLHUP: Final[int]
+    POLLIN: Final[int]
+    if sys.platform == "linux":
+        POLLMSG: Final[int]
+    POLLNVAL: Final[int]
+    POLLOUT: Final[int]
+    POLLPRI: Final[int]
+    POLLRDBAND: Final[int]
+    if sys.platform == "linux":
+        POLLRDHUP: Final[int]
+    POLLRDNORM: Final[int]
+    POLLWRBAND: Final[int]
+    POLLWRNORM: Final[int]
+
+    # This is actually a function that returns an instance of a class.
+    # The class is not accessible directly, and also calls itself select.poll.
+    @final
+    class poll:
+        # default value is select.POLLIN | select.POLLPRI | select.POLLOUT
+        def register(self, fd: FileDescriptorLike, eventmask: int = 7, /) -> None: ...
+        def modify(self, fd: FileDescriptorLike, eventmask: int, /) -> None: ...
+        def unregister(self, fd: FileDescriptorLike, /) -> None: ...
+        def poll(self, timeout: float | None = None, /) -> list[tuple[int, int]]: ...
+
+_R = TypeVar("_R", default=Never, bound=FileDescriptorLike)
+_W = TypeVar("_W", default=Never, bound=FileDescriptorLike)
+_X = TypeVar("_X", default=Never, bound=FileDescriptorLike)
+
+def select(
+    rlist: Iterable[_R], wlist: Iterable[_W], xlist: Iterable[_X], timeout: float | None = None, /
+) -> tuple[list[_R], list[_W], list[_X]]: ...
+
+error = OSError
+
+if sys.platform != "linux" and sys.platform != "win32":
+    # BSD only
+    @final
+    class kevent:
+        data: Any
+        fflags: int
+        filter: int
+        flags: int
+        ident: int
+        udata: Any
+        def __init__(
+            self, ident: FileDescriptorLike, filter: int = ..., flags: int = ..., fflags: int = 0, data: Any = 0, udata: Any = 0
+        ) -> None: ...
+        __hash__: ClassVar[None]  # type: ignore[assignment]
+
+    # BSD only
+    @final
+    class kqueue:
+        closed: bool
+        def __init__(self) -> None: ...
+        def close(self) -> None: ...
+        def control(
+            self, changelist: Iterable[kevent] | None, maxevents: int, timeout: float | None = None, /
+        ) -> list[kevent]: ...
+        def fileno(self) -> int: ...
+        @classmethod
+        def fromfd(cls, fd: FileDescriptorLike, /) -> kqueue: ...
+
+    KQ_EV_ADD: Final[int]
+    KQ_EV_CLEAR: Final[int]
+    KQ_EV_DELETE: Final[int]
+    KQ_EV_DISABLE: Final[int]
+    KQ_EV_ENABLE: Final[int]
+    KQ_EV_EOF: Final[int]
+    KQ_EV_ERROR: Final[int]
+    KQ_EV_FLAG1: Final[int]
+    KQ_EV_ONESHOT: Final[int]
+    KQ_EV_SYSFLAGS: Final[int]
+    KQ_FILTER_AIO: Final[int]
+    if sys.platform != "darwin":
+        KQ_FILTER_NETDEV: Final[int]
+    KQ_FILTER_PROC: Final[int]
+    KQ_FILTER_READ: Final[int]
+    KQ_FILTER_SIGNAL: Final[int]
+    KQ_FILTER_TIMER: Final[int]
+    KQ_FILTER_VNODE: Final[int]
+    KQ_FILTER_WRITE: Final[int]
+    KQ_NOTE_ATTRIB: Final[int]
+    KQ_NOTE_CHILD: Final[int]
+    KQ_NOTE_DELETE: Final[int]
+    KQ_NOTE_EXEC: Final[int]
+    KQ_NOTE_EXIT: Final[int]
+    KQ_NOTE_EXTEND: Final[int]
+    KQ_NOTE_FORK: Final[int]
+    KQ_NOTE_LINK: Final[int]
+    if sys.platform != "darwin":
+        KQ_NOTE_LINKDOWN: Final[int]
+        KQ_NOTE_LINKINV: Final[int]
+        KQ_NOTE_LINKUP: Final[int]
+    KQ_NOTE_LOWAT: Final[int]
+    KQ_NOTE_PCTRLMASK: Final[int]
+    KQ_NOTE_PDATAMASK: Final[int]
+    KQ_NOTE_RENAME: Final[int]
+    KQ_NOTE_REVOKE: Final[int]
+    KQ_NOTE_TRACK: Final[int]
+    KQ_NOTE_TRACKERR: Final[int]
+    KQ_NOTE_WRITE: Final[int]
+
+if sys.platform == "linux":
+    @final
+    class epoll:
+        @overload
+        def __new__(self, sizehint: int = -1) -> Self: ...
+        @overload
+        @deprecated(
+            "The `flags` parameter is deprecated since Python 3.4. "
+            "Use `os.set_inheritable()` to make the file descriptor inheritable."
+        )
+        def __new__(self, sizehint: int = -1, flags: int = 0) -> Self: ...
+
+        def __enter__(self) -> Self: ...
+        def __exit__(
+            self,
+            exc_type: type[BaseException] | None = None,
+            exc_value: BaseException | None = None,
+            exc_tb: TracebackType | None = None,
+            /,
+        ) -> None: ...
+        def close(self) -> None: ...
+        closed: bool
+        def fileno(self) -> int: ...
+        def register(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ...
+        def modify(self, fd: FileDescriptorLike, eventmask: int) -> None: ...
+        def unregister(self, fd: FileDescriptorLike) -> None: ...
+        def poll(self, timeout: float | None = None, maxevents: int = -1) -> list[tuple[int, int]]: ...
+        @classmethod
+        def fromfd(cls, fd: FileDescriptorLike, /) -> epoll: ...
+
+    EPOLLERR: Final[int]
+    EPOLLEXCLUSIVE: Final[int]
+    EPOLLET: Final[int]
+    EPOLLHUP: Final[int]
+    EPOLLIN: Final[int]
+    EPOLLMSG: Final[int]
+    EPOLLONESHOT: Final[int]
+    EPOLLOUT: Final[int]
+    EPOLLPRI: Final[int]
+    EPOLLRDBAND: Final[int]
+    EPOLLRDHUP: Final[int]
+    EPOLLRDNORM: Final[int]
+    EPOLLWRBAND: Final[int]
+    EPOLLWRNORM: Final[int]
+    EPOLL_CLOEXEC: Final[int]
+    if sys.version_info >= (3, 14):
+        EPOLLWAKEUP: Final[int]
+
+if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32":
+    # Solaris only
+    @final
+    class devpoll:
+        def close(self) -> None: ...
+        closed: bool
+        def fileno(self) -> int: ...
+        def register(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ...
+        def modify(self, fd: FileDescriptorLike, eventmask: int = ...) -> None: ...
+        def unregister(self, fd: FileDescriptorLike) -> None: ...
+        def poll(self, timeout: float | None = None) -> list[tuple[int, int]]: ...

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

@@ -0,0 +1,67 @@
+import sys
+from _typeshed import FileDescriptor, FileDescriptorLike, Unused
+from abc import ABCMeta, abstractmethod
+from collections.abc import Mapping
+from typing import Any, Final, NamedTuple
+from typing_extensions import Self
+
+EVENT_READ: Final = 1
+EVENT_WRITE: Final = 2
+
+class SelectorKey(NamedTuple):
+    fileobj: FileDescriptorLike
+    fd: FileDescriptor
+    events: int
+    data: Any
+
+class BaseSelector(metaclass=ABCMeta):
+    @abstractmethod
+    def register(self, fileobj: FileDescriptorLike, events: int, data: Any = None) -> SelectorKey: ...
+    @abstractmethod
+    def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
+    def modify(self, fileobj: FileDescriptorLike, events: int, data: Any = None) -> SelectorKey: ...
+    @abstractmethod
+    def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, int]]: ...
+    def close(self) -> None: ...
+    def get_key(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
+    @abstractmethod
+    def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *args: Unused) -> None: ...
+
+class _BaseSelectorImpl(BaseSelector, metaclass=ABCMeta):
+    def register(self, fileobj: FileDescriptorLike, events: int, data: Any = None) -> SelectorKey: ...
+    def unregister(self, fileobj: FileDescriptorLike) -> SelectorKey: ...
+    def modify(self, fileobj: FileDescriptorLike, events: int, data: Any = None) -> SelectorKey: ...
+    def get_map(self) -> Mapping[FileDescriptorLike, SelectorKey]: ...
+
+class SelectSelector(_BaseSelectorImpl):
+    def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, int]]: ...
+
+class _PollLikeSelector(_BaseSelectorImpl):
+    def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, int]]: ...
+
+if sys.platform != "win32":
+    class PollSelector(_PollLikeSelector): ...
+
+if sys.platform == "linux":
+    class EpollSelector(_PollLikeSelector):
+        def fileno(self) -> int: ...
+
+if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win32":
+    # Solaris only
+    class DevpollSelector(_PollLikeSelector):
+        def fileno(self) -> int: ...
+
+if sys.platform != "win32" and sys.platform != "linux":
+    class KqueueSelector(_BaseSelectorImpl):
+        def fileno(self) -> int: ...
+        def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, int]]: ...
+
+# Not a real class at runtime, it is just a conditional alias to other real selectors.
+# The runtime logic is more fine-grained than a `sys.platform` check;
+# not really expressible in the stubs
+class DefaultSelector(_BaseSelectorImpl):
+    def select(self, timeout: float | None = None) -> list[tuple[SelectorKey, int]]: ...
+    if sys.platform != "win32":
+        def fileno(self) -> int: ...

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

@@ -0,0 +1,110 @@
+import sys
+from _typeshed import StrOrBytesPath
+from collections.abc import Callable, Iterator, MutableMapping
+from dbm import _TFlags
+from types import TracebackType
+from typing import Any, TypeVar, overload
+from typing_extensions import Self
+
+__all__ = ["Shelf", "BsdDbShelf", "DbfilenameShelf", "open"]
+if sys.version_info >= (3, 15):
+    __all__ += ["ShelveError"]
+
+_T = TypeVar("_T")
+_VT = TypeVar("_VT")
+
+if sys.version_info >= (3, 15):
+    class ShelveError(Exception): ...
+
+class Shelf(MutableMapping[str, _VT]):
+    if sys.version_info >= (3, 15):
+        def __init__(
+            self,
+            dict: MutableMapping[bytes, bytes],
+            protocol: int | None = None,
+            writeback: bool = False,
+            keyencoding: str = "utf-8",
+            *,
+            serializer: Callable[[Any], bytes] | None = None,
+            deserializer: Callable[[bytes], Any] | None = None,
+        ) -> None: ...
+
+    else:
+        def __init__(
+            self,
+            dict: MutableMapping[bytes, bytes],
+            protocol: int | None = None,
+            writeback: bool = False,
+            keyencoding: str = "utf-8",
+        ) -> None: ...
+
+    def __iter__(self) -> Iterator[str]: ...
+    def __len__(self) -> int: ...
+
+    @overload  # type: ignore[override]
+    def get(self, key: str, default: None = None) -> _VT | None: ...
+    @overload
+    def get(self, key: str, default: _VT) -> _VT: ...
+    @overload
+    def get(self, key: str, default: _T) -> _VT | _T: ...
+
+    def __getitem__(self, key: str) -> _VT: ...
+    def __setitem__(self, key: str, value: _VT) -> None: ...
+    def __delitem__(self, key: str) -> None: ...
+    def __contains__(self, key: str) -> bool: ...  # type: ignore[override]
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
+    ) -> None: ...
+    def __del__(self) -> None: ...
+    def close(self) -> None: ...
+    def sync(self) -> None: ...
+    if sys.version_info >= (3, 15):
+        def reorganize(self) -> None: ...
+
+class BsdDbShelf(Shelf[_VT]):
+    def set_location(self, key: str) -> tuple[str, _VT]: ...
+    def next(self) -> tuple[str, _VT]: ...
+    def previous(self) -> tuple[str, _VT]: ...
+    def first(self) -> tuple[str, _VT]: ...
+    def last(self) -> tuple[str, _VT]: ...
+
+class DbfilenameShelf(Shelf[_VT]):
+    if sys.version_info >= (3, 15):
+        def __init__(
+            self,
+            filename: StrOrBytesPath,
+            flag: _TFlags = "c",
+            protocol: int | None = None,
+            writeback: bool = False,
+            *,
+            serializer: Callable[[Any], bytes] | None = None,
+            deserializer: Callable[[bytes], Any] | None = None,
+        ) -> None: ...
+
+    elif sys.version_info >= (3, 11):
+        def __init__(
+            self, filename: StrOrBytesPath, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False
+        ) -> None: ...
+
+    else:
+        def __init__(self, filename: str, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False) -> None: ...
+
+if sys.version_info >= (3, 15):
+    def open(
+        filename: StrOrBytesPath,
+        flag: _TFlags = "c",
+        protocol: int | None = None,
+        writeback: bool = False,
+        *,
+        serializer: Callable[[Any], bytes] | None = None,
+        deserializer: Callable[[bytes], Any] | None = None,
+    ) -> Shelf[Any]: ...
+
+elif sys.version_info >= (3, 11):
+    def open(
+        filename: StrOrBytesPath, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False
+    ) -> Shelf[Any]: ...
+
+else:
+    def open(filename: str, flag: _TFlags = "c", protocol: int | None = None, writeback: bool = False) -> Shelf[Any]: ...

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

@@ -0,0 +1,63 @@
+import sys
+from collections import deque
+from collections.abc import Iterable
+from io import TextIOWrapper
+from typing import Literal, Protocol, overload, type_check_only
+from typing_extensions import Self, deprecated
+
+__all__ = ["shlex", "split", "quote", "join"]
+
+@type_check_only
+class _ShlexInstream(Protocol):
+    def read(self, size: Literal[1], /) -> str: ...
+    def readline(self) -> object: ...
+    def close(self) -> object: ...
+
+if sys.version_info >= (3, 12):
+    def split(s: str | _ShlexInstream, comments: bool = False, posix: bool = True) -> list[str]: ...
+
+else:
+    @overload
+    def split(s: str | _ShlexInstream, comments: bool = False, posix: bool = True) -> list[str]: ...
+    @overload
+    @deprecated("Passing None for 's' to shlex.split() is deprecated and will raise an error in Python 3.12.")
+    def split(s: None, comments: bool = False, posix: bool = True) -> list[str]: ...
+
+def join(split_command: Iterable[str]) -> str: ...
+def quote(s: str) -> str: ...
+
+# TODO: Make generic over infile once PEP 696 is implemented.
+class shlex:
+    commenters: str
+    wordchars: str
+    whitespace: str
+    escape: str
+    quotes: str
+    escapedquotes: str
+    whitespace_split: bool
+    infile: str | None
+    instream: _ShlexInstream
+    source: str
+    debug: int
+    lineno: int
+    token: str
+    filestack: deque[tuple[str | None, _ShlexInstream, int]]
+    eof: str | None
+    @property
+    def punctuation_chars(self) -> str: ...
+    def __init__(
+        self,
+        instream: str | _ShlexInstream | None = None,
+        infile: str | None = None,
+        posix: bool = False,
+        punctuation_chars: bool | str = False,
+    ) -> None: ...
+    def get_token(self) -> str | None: ...
+    def push_token(self, tok: str) -> None: ...
+    def read_token(self) -> str | None: ...
+    def sourcehook(self, newfile: str) -> tuple[str, TextIOWrapper] | None: ...
+    def push_source(self, newstream: str | _ShlexInstream, newfile: str | None = None) -> None: ...
+    def pop_source(self) -> None: ...
+    def error_leader(self, infile: str | None = None, lineno: int | None = None) -> str: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> str: ...