layermap 0.1.0

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

@@ -0,0 +1,117 @@
+import sys
+from _typeshed import structseq
+from typing import Any, Final, Literal, Protocol, SupportsFloat, SupportsIndex, TypeAlias, final, type_check_only
+
+_TimeTuple: TypeAlias = tuple[int, int, int, int, int, int, int, int, int]
+
+if sys.version_info >= (3, 15):
+    # anticipate on https://github.com/python/cpython/pull/139224
+    _SupportsFloatOrIndex: TypeAlias = SupportsFloat | SupportsIndex
+else:
+    # before, time functions only accept (subclass of) float, *not* SupportsFloat
+    _SupportsFloatOrIndex: TypeAlias = float | SupportsIndex
+
+altzone: int
+daylight: int
+timezone: int
+tzname: tuple[str, str]
+
+if sys.platform == "linux":
+    CLOCK_BOOTTIME: Final[int]
+if sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin":
+    CLOCK_PROF: Final[int]  # FreeBSD, NetBSD, OpenBSD
+    CLOCK_UPTIME: Final[int]  # FreeBSD, OpenBSD
+
+if sys.platform != "win32":
+    CLOCK_MONOTONIC: Final[int]
+    CLOCK_MONOTONIC_RAW: Final[int]
+    CLOCK_PROCESS_CPUTIME_ID: Final[int]
+    CLOCK_REALTIME: Final[int]
+    CLOCK_THREAD_CPUTIME_ID: Final[int]
+    if sys.platform != "linux" and sys.platform != "darwin":
+        CLOCK_HIGHRES: Final[int]  # Solaris only
+
+if sys.platform == "darwin":
+    CLOCK_UPTIME_RAW: Final[int]
+    if sys.version_info >= (3, 13):
+        CLOCK_UPTIME_RAW_APPROX: Final[int]
+        CLOCK_MONOTONIC_RAW_APPROX: Final[int]
+
+if sys.platform == "linux":
+    CLOCK_TAI: Final[int]
+
+# Constructor takes an iterable of any type, of length between 9 and 11 elements.
+# However, it always *behaves* like a tuple of 9 elements,
+# even if an iterable with length >9 is passed.
+# https://github.com/python/typeshed/pull/6560#discussion_r767162532
+@final
+class struct_time(structseq[Any | int], _TimeTuple):
+    __match_args__: Final = ("tm_year", "tm_mon", "tm_mday", "tm_hour", "tm_min", "tm_sec", "tm_wday", "tm_yday", "tm_isdst")
+
+    @property
+    def tm_year(self) -> int: ...
+    @property
+    def tm_mon(self) -> int: ...
+    @property
+    def tm_mday(self) -> int: ...
+    @property
+    def tm_hour(self) -> int: ...
+    @property
+    def tm_min(self) -> int: ...
+    @property
+    def tm_sec(self) -> int: ...
+    @property
+    def tm_wday(self) -> int: ...
+    @property
+    def tm_yday(self) -> int: ...
+    @property
+    def tm_isdst(self) -> int: ...
+    # These final two properties only exist if a 10- or 11-item sequence was passed to the constructor.
+    @property
+    def tm_zone(self) -> str: ...
+    @property
+    def tm_gmtoff(self) -> int: ...
+
+def asctime(time_tuple: _TimeTuple | struct_time = ..., /) -> str: ...
+def ctime(seconds: _SupportsFloatOrIndex | None = None, /) -> str: ...
+def gmtime(seconds: _SupportsFloatOrIndex | None = None, /) -> struct_time: ...
+def localtime(seconds: _SupportsFloatOrIndex | None = None, /) -> struct_time: ...
+def mktime(time_tuple: _TimeTuple | struct_time, /) -> float: ...
+def sleep(seconds: _SupportsFloatOrIndex, /) -> None: ...
+def strftime(format: str, time_tuple: _TimeTuple | struct_time = ..., /) -> str: ...
+def strptime(data_string: str, format: str = "%a %b %d %H:%M:%S %Y", /) -> struct_time: ...
+def time() -> float: ...
+
+if sys.platform != "win32":
+    def tzset() -> None: ...  # Unix only
+
+@type_check_only
+class _ClockInfo(Protocol):
+    adjustable: bool
+    implementation: str
+    monotonic: bool
+    resolution: float
+
+def get_clock_info(name: Literal["monotonic", "perf_counter", "process_time", "time", "thread_time"], /) -> _ClockInfo: ...
+def monotonic() -> float: ...
+def perf_counter() -> float: ...
+def process_time() -> float: ...
+
+if sys.platform != "win32":
+    def clock_getres(clk_id: int, /) -> float: ...  # Unix only
+    def clock_gettime(clk_id: int, /) -> float: ...  # Unix only
+    def clock_settime(clk_id: int, time: float, /) -> None: ...  # Unix only
+
+if sys.platform != "win32":
+    def clock_gettime_ns(clk_id: int, /) -> int: ...
+    def clock_settime_ns(clock_id: int, time: int, /) -> int: ...
+
+if sys.platform == "linux":
+    def pthread_getcpuclockid(thread_id: int, /) -> int: ...
+
+def monotonic_ns() -> int: ...
+def perf_counter_ns() -> int: ...
+def process_time_ns() -> int: ...
+def time_ns() -> int: ...
+def thread_time() -> float: ...
+def thread_time_ns() -> int: ...

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

@@ -0,0 +1,46 @@
+import sys
+import time
+from collections.abc import Callable, Sequence
+from typing import IO, Any, TypeAlias
+
+__all__ = ["Timer", "timeit", "repeat", "default_timer"]
+
+_Timer: TypeAlias = Callable[[], float]
+_Stmt: TypeAlias = str | Callable[[], object]
+
+default_timer: _Timer
+
+class Timer:
+    def __init__(
+        self,
+        stmt: _Stmt = "pass",
+        setup: _Stmt = "pass",
+        timer: _Timer = time.perf_counter,
+        globals: dict[str, Any] | None = None,
+    ) -> None: ...
+    def print_exc(self, file: IO[str] | None = None) -> None: ...
+    def timeit(self, number: int = 1000000) -> float: ...
+    def repeat(self, repeat: int = 5, number: int = 1000000) -> list[float]: ...
+    if sys.version_info >= (3, 15):
+        def autorange(
+            self, callback: Callable[[int, float], object] | None = None, target_time: float = 0.2
+        ) -> tuple[int, float]: ...
+    else:
+        def autorange(self, callback: Callable[[int, float], object] | None = None) -> tuple[int, float]: ...
+
+def timeit(
+    stmt: _Stmt = "pass",
+    setup: _Stmt = "pass",
+    timer: _Timer = time.perf_counter,
+    number: int = 1000000,
+    globals: dict[str, Any] | None = None,
+) -> float: ...
+def repeat(
+    stmt: _Stmt = "pass",
+    setup: _Stmt = "pass",
+    timer: _Timer = time.perf_counter,
+    repeat: int = 5,
+    number: int = 1000000,
+    globals: dict[str, Any] | None = None,
+) -> list[float]: ...
+def main(args: Sequence[str] | None = None, *, _wrap_timer: Callable[[_Timer], _Timer] | None = None) -> None: ...