jaclang 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/vendor/mypy/typeshed/stdlib/termios.pyi

@@ -0,0 +1,273 @@
+import sys
+from _typeshed import FileDescriptorLike
+from typing import Any
+from typing_extensions import TypeAlias
+
+# Must be a list of length 7, containing 6 ints and a list of NCCS 1-character bytes or ints.
+_Attr: TypeAlias = (
+    list[int | list[bytes | int]] | list[int | list[bytes]] | list[int | list[int]]
+)
+# Same as _Attr for return types; we use Any to avoid a union.
+_AttrReturn: TypeAlias = list[Any]
+
+if sys.platform != "win32":
+    B0: int
+    B1000000: int
+    B110: int
+    B115200: int
+    B1152000: int
+    B1200: int
+    B134: int
+    B150: int
+    B1500000: int
+    B1800: int
+    B19200: int
+    B200: int
+    B2000000: int
+    B230400: int
+    B2400: int
+    B2500000: int
+    B300: int
+    B3000000: int
+    B3500000: int
+    B38400: int
+    B4000000: int
+    B460800: int
+    B4800: int
+    B50: int
+    B500000: int
+    B57600: int
+    B576000: int
+    B600: int
+    B75: int
+    B921600: int
+    B9600: int
+    BRKINT: int
+    BS0: int
+    BS1: int
+    BSDLY: int
+    CBAUD: int
+    CBAUDEX: int
+    CDEL: int
+    CDSUSP: int
+    CEOF: int
+    CEOL: int
+    CEOL2: int
+    CEOT: int
+    CERASE: int
+    CESC: int
+    CFLUSH: int
+    CIBAUD: int
+    CINTR: int
+    CKILL: int
+    CLNEXT: int
+    CLOCAL: int
+    CNUL: int
+    COMMON: int
+    CQUIT: int
+    CR0: int
+    CR1: int
+    CR2: int
+    CR3: int
+    CRDLY: int
+    CREAD: int
+    CRPRNT: int
+    CRTSCTS: int
+    CS5: int
+    CS6: int
+    CS7: int
+    CS8: int
+    CSIZE: int
+    CSTART: int
+    CSTOP: int
+    CSTOPB: int
+    CSUSP: int
+    CSWTCH: int
+    CWERASE: int
+    ECHO: int
+    ECHOCTL: int
+    ECHOE: int
+    ECHOK: int
+    ECHOKE: int
+    ECHONL: int
+    ECHOPRT: int
+    EXTA: int
+    EXTB: int
+    FF0: int
+    FF1: int
+    FFDLY: int
+    FIOASYNC: int
+    FIOCLEX: int
+    FIONBIO: int
+    FIONCLEX: int
+    FIONREAD: int
+    FLUSHO: int
+    HUPCL: int
+    IBSHIFT: int
+    ICANON: int
+    ICRNL: int
+    IEXTEN: int
+    IGNBRK: int
+    IGNCR: int
+    IGNPAR: int
+    IMAXBEL: int
+    INIT_C_CC: int
+    INLCR: int
+    INPCK: int
+    IOCSIZE_MASK: int
+    IOCSIZE_SHIFT: int
+    ISIG: int
+    ISTRIP: int
+    IUCLC: int
+    IXANY: int
+    IXOFF: int
+    IXON: int
+    N_MOUSE: int
+    N_PPP: int
+    N_SLIP: int
+    N_STRIP: int
+    N_TTY: int
+    NCC: int
+    NCCS: int
+    NL0: int
+    NL1: int
+    NLDLY: int
+    NOFLSH: int
+    NSWTCH: int
+    OCRNL: int
+    OFDEL: int
+    OFILL: int
+    OLCUC: int
+    ONLCR: int
+    ONLRET: int
+    ONOCR: int
+    OPOST: int
+    PARENB: int
+    PARMRK: int
+    PARODD: int
+    PENDIN: int
+    TAB0: int
+    TAB1: int
+    TAB2: int
+    TAB3: int
+    TABDLY: int
+    TCFLSH: int
+    TCGETA: int
+    TCGETS: int
+    TCIFLUSH: int
+    TCIOFF: int
+    TCIOFLUSH: int
+    TCION: int
+    TCOFLUSH: int
+    TCOOFF: int
+    TCOON: int
+    TCSADRAIN: int
+    TCSAFLUSH: int
+    TCSANOW: int
+    TCSASOFT: int
+    TCSBRK: int
+    TCSBRKP: int
+    TCSETA: int
+    TCSETAF: int
+    TCSETAW: int
+    TCSETS: int
+    TCSETSF: int
+    TCSETSW: int
+    TCXONC: int
+    TIOCCONS: int
+    TIOCEXCL: int
+    TIOCGETD: int
+    TIOCGICOUNT: int
+    TIOCGLCKTRMIOS: int
+    TIOCGPGRP: int
+    TIOCGSERIAL: int
+    TIOCGSIZE: int
+    TIOCGSOFTCAR: int
+    TIOCGWINSZ: int
+    TIOCINQ: int
+    TIOCLINUX: int
+    TIOCM_CAR: int
+    TIOCM_CD: int
+    TIOCM_CTS: int
+    TIOCM_DSR: int
+    TIOCM_DTR: int
+    TIOCM_LE: int
+    TIOCM_RI: int
+    TIOCM_RNG: int
+    TIOCM_RTS: int
+    TIOCM_SR: int
+    TIOCM_ST: int
+    TIOCMBIC: int
+    TIOCMBIS: int
+    TIOCMGET: int
+    TIOCMIWAIT: int
+    TIOCMSET: int
+    TIOCNOTTY: int
+    TIOCNXCL: int
+    TIOCOUTQ: int
+    TIOCPKT_DATA: int
+    TIOCPKT_DOSTOP: int
+    TIOCPKT_FLUSHREAD: int
+    TIOCPKT_FLUSHWRITE: int
+    TIOCPKT_NOSTOP: int
+    TIOCPKT_START: int
+    TIOCPKT_STOP: int
+    TIOCPKT: int
+    TIOCSCTTY: int
+    TIOCSER_TEMT: int
+    TIOCSERCONFIG: int
+    TIOCSERGETLSR: int
+    TIOCSERGETMULTI: int
+    TIOCSERGSTRUCT: int
+    TIOCSERGWILD: int
+    TIOCSERSETMULTI: int
+    TIOCSERSWILD: int
+    TIOCSETD: int
+    TIOCSLCKTRMIOS: int
+    TIOCSPGRP: int
+    TIOCSSERIAL: int
+    TIOCSSIZE: int
+    TIOCSSOFTCAR: int
+    TIOCSTI: int
+    TIOCSWINSZ: int
+    TIOCTTYGSTRUCT: int
+    TOSTOP: int
+    VDISCARD: int
+    VEOF: int
+    VEOL: int
+    VEOL2: int
+    VERASE: int
+    VINTR: int
+    VKILL: int
+    VLNEXT: int
+    VMIN: int
+    VQUIT: int
+    VREPRINT: int
+    VSTART: int
+    VSTOP: int
+    VSUSP: int
+    VSWTC: int
+    VSWTCH: int
+    VT0: int
+    VT1: int
+    VTDLY: int
+    VTIME: int
+    VWERASE: int
+    XCASE: int
+    XTABS: int
+
+    def tcgetattr(__fd: FileDescriptorLike) -> _AttrReturn: ...
+    def tcsetattr(
+        __fd: FileDescriptorLike, __when: int, __attributes: _Attr
+    ) -> None: ...
+    def tcsendbreak(__fd: FileDescriptorLike, __duration: int) -> None: ...
+    def tcdrain(__fd: FileDescriptorLike) -> None: ...
+    def tcflush(__fd: FileDescriptorLike, __queue: int) -> None: ...
+    def tcflow(__fd: FileDescriptorLike, __action: int) -> None: ...
+    if sys.version_info >= (3, 11):
+        def tcgetwinsize(__fd: FileDescriptorLike) -> tuple[int, int]: ...
+        def tcsetwinsize(
+            __fd: FileDescriptorLike, __winsize: tuple[int, int]
+        ) -> None: ...
+
+    class error(Exception): ...

jaclang/vendor/mypy/typeshed/stdlib/textwrap.pyi

@@ -0,0 +1,107 @@
+from collections.abc import Callable
+from re import Pattern
+
+__all__ = ["TextWrapper", "wrap", "fill", "dedent", "indent", "shorten"]
+
+class TextWrapper:
+    width: int
+    initial_indent: str
+    subsequent_indent: str
+    expand_tabs: bool
+    replace_whitespace: bool
+    fix_sentence_endings: bool
+    drop_whitespace: bool
+    break_long_words: bool
+    break_on_hyphens: bool
+    tabsize: int
+    max_lines: int | None
+    placeholder: str
+
+    # Attributes not present in documentation
+    sentence_end_re: Pattern[str]
+    wordsep_re: Pattern[str]
+    wordsep_simple_re: Pattern[str]
+    whitespace_trans: str
+    unicode_whitespace_trans: dict[int, int]
+    uspace: int
+    x: str  # leaked loop variable
+    def __init__(
+        self,
+        width: int = 70,
+        initial_indent: str = "",
+        subsequent_indent: str = "",
+        expand_tabs: bool = True,
+        replace_whitespace: bool = True,
+        fix_sentence_endings: bool = False,
+        break_long_words: bool = True,
+        drop_whitespace: bool = True,
+        break_on_hyphens: bool = True,
+        tabsize: int = 8,
+        *,
+        max_lines: int | None = None,
+        placeholder: str = " [...]",
+    ) -> None: ...
+    # Private methods *are* part of the documented API for subclasses.
+    def _munge_whitespace(self, text: str) -> str: ...
+    def _split(self, text: str) -> list[str]: ...
+    def _fix_sentence_endings(self, chunks: list[str]) -> None: ...
+    def _handle_long_word(
+        self, reversed_chunks: list[str], cur_line: list[str], cur_len: int, width: int
+    ) -> None: ...
+    def _wrap_chunks(self, chunks: list[str]) -> list[str]: ...
+    def _split_chunks(self, text: str) -> list[str]: ...
+    def wrap(self, text: str) -> list[str]: ...
+    def fill(self, text: str) -> str: ...
+
+def wrap(
+    text: str,
+    width: int = 70,
+    *,
+    initial_indent: str = "",
+    subsequent_indent: str = "",
+    expand_tabs: bool = True,
+    tabsize: int = 8,
+    replace_whitespace: bool = True,
+    fix_sentence_endings: bool = False,
+    break_long_words: bool = True,
+    break_on_hyphens: bool = True,
+    drop_whitespace: bool = True,
+    max_lines: int | None = None,
+    placeholder: str = " [...]",
+) -> list[str]: ...
+def fill(
+    text: str,
+    width: int = 70,
+    *,
+    initial_indent: str = "",
+    subsequent_indent: str = "",
+    expand_tabs: bool = True,
+    tabsize: int = 8,
+    replace_whitespace: bool = True,
+    fix_sentence_endings: bool = False,
+    break_long_words: bool = True,
+    break_on_hyphens: bool = True,
+    drop_whitespace: bool = True,
+    max_lines: int | None = None,
+    placeholder: str = " [...]",
+) -> str: ...
+def shorten(
+    text: str,
+    width: int,
+    *,
+    initial_indent: str = "",
+    subsequent_indent: str = "",
+    expand_tabs: bool = True,
+    tabsize: int = 8,
+    replace_whitespace: bool = True,
+    fix_sentence_endings: bool = False,
+    break_long_words: bool = True,
+    break_on_hyphens: bool = True,
+    drop_whitespace: bool = True,
+    # Omit `max_lines: int = None`, it is forced to 1 here.
+    placeholder: str = " [...]",
+) -> str: ...
+def dedent(text: str) -> str: ...
+def indent(
+    text: str, prefix: str, predicate: Callable[[str], bool] | None = None
+) -> str: ...

jaclang/vendor/mypy/typeshed/stdlib/this.pyi

@@ -0,0 +1,2 @@
+s: str
+d: dict[str, str]

jaclang/vendor/mypy/typeshed/stdlib/threading.pyi

@@ -0,0 +1,212 @@
+import _thread
+import sys
+from _thread import _excepthook, _ExceptHookArgs, get_native_id as get_native_id
+from _typeshed import ProfileFunction, TraceFunction
+from collections.abc import Callable, Iterable, Mapping
+from types import TracebackType
+from typing import Any, TypeVar, final
+
+_T = TypeVar("_T")
+
+__all__ = [
+    "get_ident",
+    "active_count",
+    "Condition",
+    "current_thread",
+    "enumerate",
+    "main_thread",
+    "TIMEOUT_MAX",
+    "Event",
+    "Lock",
+    "RLock",
+    "Semaphore",
+    "BoundedSemaphore",
+    "Thread",
+    "Barrier",
+    "BrokenBarrierError",
+    "Timer",
+    "ThreadError",
+    "ExceptHookArgs",
+    "setprofile",
+    "settrace",
+    "local",
+    "stack_size",
+    "excepthook",
+    "get_native_id",
+]
+
+if sys.version_info >= (3, 10):
+    __all__ += ["getprofile", "gettrace"]
+
+if sys.version_info >= (3, 12):
+    __all__ += ["setprofile_all_threads", "settrace_all_threads"]
+
+_profile_hook: ProfileFunction | None
+
+def active_count() -> int: ...
+def activeCount() -> int: ...  # deprecated alias for active_count()
+def current_thread() -> Thread: ...
+def currentThread() -> Thread: ...  # deprecated alias for current_thread()
+def get_ident() -> int: ...
+def enumerate() -> list[Thread]: ...
+def main_thread() -> Thread: ...
+def settrace(func: TraceFunction) -> None: ...
+def setprofile(func: ProfileFunction | None) -> None: ...
+
+if sys.version_info >= (3, 12):
+    def setprofile_all_threads(func: ProfileFunction | None) -> None: ...
+    def settrace_all_threads(func: TraceFunction) -> None: ...
+
+if sys.version_info >= (3, 10):
+    def gettrace() -> TraceFunction | None: ...
+    def getprofile() -> ProfileFunction | None: ...
+
+def stack_size(size: int = ...) -> int: ...
+
+TIMEOUT_MAX: float
+
+ThreadError = _thread.error
+local = _thread._local
+
+class Thread:
+    name: str
+    @property
+    def ident(self) -> int | None: ...
+    daemon: bool
+    def __init__(
+        self,
+        group: None = None,
+        target: Callable[..., object] | None = None,
+        name: str | None = None,
+        args: Iterable[Any] = (),
+        kwargs: Mapping[str, Any] | None = None,
+        *,
+        daemon: bool | None = None,
+    ) -> None: ...
+    def start(self) -> None: ...
+    def run(self) -> None: ...
+    def join(self, timeout: float | None = None) -> None: ...
+    @property
+    def native_id(self) -> int | None: ...  # only available on some platforms
+    def is_alive(self) -> bool: ...
+    if sys.version_info < (3, 9):
+        def isAlive(self) -> bool: ...
+    # the following methods are all deprecated
+    def getName(self) -> str: ...
+    def setName(self, name: str) -> None: ...
+    def isDaemon(self) -> bool: ...
+    def setDaemon(self, daemonic: bool) -> None: ...
+
+class _DummyThread(Thread):
+    def __init__(self) -> None: ...
+
+@final
+class Lock:
+    def __enter__(self) -> bool: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None: ...
+    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
+    def release(self) -> None: ...
+    def locked(self) -> bool: ...
+
+@final
+class _RLock:
+    def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
+    def release(self) -> None: ...
+    __enter__ = acquire
+    def __exit__(
+        self,
+        t: type[BaseException] | None,
+        v: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None: ...
+
+RLock = _RLock
+
+class Condition:
+    def __init__(self, lock: Lock | _RLock | None = None) -> None: ...
+    def __enter__(self) -> bool: ...
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None: ...
+    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
+    def release(self) -> None: ...
+    def wait(self, timeout: float | None = None) -> bool: ...
+    def wait_for(
+        self, predicate: Callable[[], _T], timeout: float | None = None
+    ) -> _T: ...
+    def notify(self, n: int = 1) -> None: ...
+    def notify_all(self) -> None: ...
+    def notifyAll(self) -> None: ...  # deprecated alias for notify_all()
+
+class Semaphore:
+    _value: int
+    def __init__(self, value: int = 1) -> None: ...
+    def __exit__(
+        self,
+        t: type[BaseException] | None,
+        v: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None: ...
+    def acquire(self, blocking: bool = True, timeout: float | None = None) -> bool: ...
+    def __enter__(
+        self, blocking: bool = True, timeout: float | None = None
+    ) -> bool: ...
+    if sys.version_info >= (3, 9):
+        def release(self, n: int = 1) -> None: ...
+    else:
+        def release(self) -> None: ...
+
+class BoundedSemaphore(Semaphore): ...
+
+class Event:
+    def is_set(self) -> bool: ...
+    def isSet(self) -> bool: ...  # deprecated alias for is_set()
+    def set(self) -> None: ...
+    def clear(self) -> None: ...
+    def wait(self, timeout: float | None = None) -> bool: ...
+
+excepthook = _excepthook
+ExceptHookArgs = _ExceptHookArgs
+
+class Timer(Thread):
+    args: Iterable[Any]  # undocumented
+    finished: Event  # undocumented
+    function: Callable[..., Any]  # undocumented
+    interval: float  # undocumented
+    kwargs: Mapping[str, Any]  # undocumented
+
+    def __init__(
+        self,
+        interval: float,
+        function: Callable[..., object],
+        args: Iterable[Any] | None = None,
+        kwargs: Mapping[str, Any] | None = None,
+    ) -> None: ...
+    def cancel(self) -> None: ...
+
+class Barrier:
+    @property
+    def parties(self) -> int: ...
+    @property
+    def n_waiting(self) -> int: ...
+    @property
+    def broken(self) -> bool: ...
+    def __init__(
+        self,
+        parties: int,
+        action: Callable[[], None] | None = None,
+        timeout: float | None = None,
+    ) -> None: ...
+    def wait(self, timeout: float | None = None) -> int: ...
+    def reset(self) -> None: ...
+    def abort(self) -> None: ...
+
+class BrokenBarrierError(RuntimeError): ...

jaclang/vendor/mypy/typeshed/stdlib/time.pyi

@@ -0,0 +1,122 @@
+import sys
+from _typeshed import structseq
+from typing import Any, Final, Literal, Protocol, final
+from typing_extensions import TypeAlias
+
+_TimeTuple: TypeAlias = tuple[int, int, int, int, int, int, int, int, int]
+
+altzone: int
+daylight: int
+timezone: int
+tzname: tuple[str, str]
+
+if sys.platform == "linux":
+    CLOCK_BOOTTIME: int
+if sys.platform != "linux" and sys.platform != "win32" and sys.platform != "darwin":
+    CLOCK_PROF: int  # FreeBSD, NetBSD, OpenBSD
+    CLOCK_UPTIME: int  # FreeBSD, OpenBSD
+
+if sys.platform != "win32":
+    CLOCK_MONOTONIC: int
+    CLOCK_MONOTONIC_RAW: int
+    CLOCK_PROCESS_CPUTIME_ID: int
+    CLOCK_REALTIME: int
+    CLOCK_THREAD_CPUTIME_ID: int
+    if sys.platform != "linux" and sys.platform != "darwin":
+        CLOCK_HIGHRES: int  # Solaris only
+
+if sys.platform == "darwin":
+    CLOCK_UPTIME_RAW: int
+
+if sys.version_info >= (3, 9) and sys.platform == "linux":
+    CLOCK_TAI: 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):
+    if sys.version_info >= (3, 10):
+        __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: float | None = None, /) -> str: ...
+def gmtime(seconds: float | None = None, /) -> struct_time: ...
+def localtime(seconds: float | None = None, /) -> struct_time: ...
+def mktime(time_tuple: _TimeTuple | struct_time, /) -> float: ...
+def sleep(seconds: float, /) -> 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
+
+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(clock_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: ...