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

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

@@ -0,0 +1,146 @@
+import _compression
+import sys
+from _compression import BaseStream
+from _typeshed import ReadableBuffer, StrOrBytesPath, WriteableBuffer
+from collections.abc import Iterable
+from typing import IO, Any, Literal, Protocol, SupportsIndex, TextIO, final, overload
+from typing_extensions import Self, TypeAlias
+
+__all__ = ["BZ2File", "BZ2Compressor", "BZ2Decompressor", "open", "compress", "decompress"]
+
+# The following attributes and methods are optional:
+# def fileno(self) -> int: ...
+# def close(self) -> object: ...
+class _ReadableFileobj(_compression._Reader, Protocol): ...
+
+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,
+) -> TextIO: ...
+@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,
+) -> TextIO: ...
+@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,
+) -> TextIO: ...
+@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 | TextIO: ...
+
+class BZ2File(BaseStream, IO[bytes]):
+    def __enter__(self) -> Self: ...
+    if sys.version_info >= (3, 9):
+        @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: ...
+    else:
+        @overload
+        def __init__(
+            self, filename: _WritableFileobj, mode: _WriteBinaryMode, buffering: Any | None = None, compresslevel: int = 9
+        ) -> None: ...
+        @overload
+        def __init__(
+            self, filename: _ReadableFileobj, mode: _ReadBinaryMode = "r", buffering: Any | None = None, compresslevel: int = 9
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            filename: StrOrBytesPath,
+            mode: _ReadBinaryMode | _WriteBinaryMode = "r",
+            buffering: Any | None = None,
+            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 seek(self, offset: int, whence: int = 0) -> int: ...
+    def write(self, data: ReadableBuffer) -> int: ...
+    def writelines(self, seq: Iterable[ReadableBuffer]) -> None: ...
+
+@final
+class BZ2Compressor:
+    def __init__(self, compresslevel: int = ...) -> None: ...
+    def compress(self, data: ReadableBuffer, /) -> bytes: ...
+    def flush(self) -> bytes: ...
+
+@final
+class BZ2Decompressor:
+    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes: ...
+    @property
+    def eof(self) -> bool: ...
+    @property
+    def needs_input(self) -> bool: ...
+    @property
+    def unused_data(self) -> bytes: ...

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

@@ -0,0 +1,31 @@
+import _lsprof
+from _typeshed import StrOrBytesPath, Unused
+from collections.abc import Callable
+from types import CodeType
+from typing import Any, TypeVar
+from typing_extensions import ParamSpec, Self, TypeAlias
+
+__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: dict[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: dict[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: ...
+
+def label(code: str | CodeType) -> _Label: ...  # undocumented

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

@@ -0,0 +1,208 @@
+import datetime
+import enum
+import sys
+from _typeshed import Unused
+from collections.abc import Iterable, Sequence
+from time import struct_time
+from typing import ClassVar, Literal
+from typing_extensions import TypeAlias
+
+__all__ = [
+    "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, 10):
+    __all__ += ["FRIDAY", "MONDAY", "SATURDAY", "SUNDAY", "THURSDAY", "TUESDAY", "WEDNESDAY"]
+if sys.version_info >= (3, 12):
+    __all__ += [
+        "Day",
+        "Month",
+        "JANUARY",
+        "FEBRUARY",
+        "MARCH",
+        "APRIL",
+        "MAY",
+        "JUNE",
+        "JULY",
+        "AUGUST",
+        "SEPTEMBER",
+        "OCTOBER",
+        "NOVEMBER",
+        "DECEMBER",
+    ]
+
+_LocaleType: TypeAlias = tuple[str | None, str | None]
+
+class IllegalMonthError(ValueError):
+    def __init__(self, month: int) -> None: ...
+
+class IllegalWeekdayError(ValueError):
+    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) -> Iterable[int]: ...
+    def itermonthdates(self, year: int, month: int) -> Iterable[datetime.date]: ...
+    def itermonthdays2(self, year: int, month: int) -> Iterable[tuple[int, int]]: ...
+    def itermonthdays(self, year: int, month: int) -> Iterable[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[int]]: ...
+    def yeardays2calendar(self, year: int, width: int = 3) -> list[list[tuple[int, int]]]: ...
+    def yeardayscalendar(self, year: int, width: int = 3) -> list[list[int]]: ...
+    def itermonthdays3(self, year: int, month: int) -> Iterable[tuple[int, int, int]]: ...
+    def itermonthdays4(self, year: int, month: int) -> Iterable[tuple[int, int, int, int]]: ...
+
+class TextCalendar(Calendar):
+    def prweek(self, theweek: int, width: int) -> None: ...
+    def formatday(self, day: int, weekday: int, width: int) -> str: ...
+    def formatweek(self, theweek: 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: ...
+    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: int, colwidth: int = 20, spacing: int = 6) -> str: ...
+def timegm(tuple: tuple[int, ...] | struct_time) -> int: ...
+
+# Data attributes
+day_name: Sequence[str]
+day_abbr: Sequence[str]
+month_name: Sequence[str]
+month_abbr: Sequence[str]
+
+if sys.version_info >= (3, 12):
+    class Month(enum.IntEnum):
+        JANUARY: Literal[1]
+        FEBRUARY: Literal[2]
+        MARCH: Literal[3]
+        APRIL: Literal[4]
+        MAY: Literal[5]
+        JUNE: Literal[6]
+        JULY: Literal[7]
+        AUGUST: Literal[8]
+        SEPTEMBER: Literal[9]
+        OCTOBER: Literal[10]
+        NOVEMBER: Literal[11]
+        DECEMBER: Literal[12]
+
+    JANUARY = Month.JANUARY
+    FEBRUARY = Month.FEBRUARY
+    MARCH = Month.MARCH
+    APRIL = Month.APRIL
+    MAY = Month.MAY
+    JUNE = Month.JUNE
+    JULY = Month.JULY
+    AUGUST = Month.AUGUST
+    SEPTEMBER = Month.SEPTEMBER
+    OCTOBER = Month.OCTOBER
+    NOVEMBER = Month.NOVEMBER
+    DECEMBER = Month.DECEMBER
+
+    class Day(enum.IntEnum):
+        MONDAY: Literal[0]
+        TUESDAY: Literal[1]
+        WEDNESDAY: Literal[2]
+        THURSDAY: Literal[3]
+        FRIDAY: Literal[4]
+        SATURDAY: Literal[5]
+        SUNDAY: Literal[6]
+
+    MONDAY = Day.MONDAY
+    TUESDAY = Day.TUESDAY
+    WEDNESDAY = Day.WEDNESDAY
+    THURSDAY = Day.THURSDAY
+    FRIDAY = Day.FRIDAY
+    SATURDAY = Day.SATURDAY
+    SUNDAY = Day.SUNDAY
+else:
+    MONDAY: Literal[0]
+    TUESDAY: Literal[1]
+    WEDNESDAY: Literal[2]
+    THURSDAY: Literal[3]
+    FRIDAY: Literal[4]
+    SATURDAY: Literal[5]
+    SUNDAY: Literal[6]
+
+EPOCH: Literal[1970]

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

@@ -0,0 +1,118 @@
+from _typeshed import 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
+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] = ...,
+    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]]: ...
+
+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 = ...) -> None: ...
+def print_environ(environ: _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: SupportsGetItem[str, str] = ...,
+        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: ...

jaclang/vendor/mypy/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: ...

jaclang/vendor/mypy/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: ...

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

@@ -0,0 +1,36 @@
+from typing import SupportsComplex, SupportsFloat, SupportsIndex
+from typing_extensions import TypeAlias
+
+e: float
+pi: float
+inf: float
+infj: complex
+nan: float
+nanj: complex
+tau: float
+
+_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(x: _C, base: _C = ..., /) -> complex: ...
+def log10(z: _C, /) -> complex: ...
+def phase(z: _C, /) -> float: ...
+def polar(z: _C, /) -> tuple[float, float]: ...
+def rect(r: float, phi: float, /) -> 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: ...

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

@@ -0,0 +1,45 @@
+from collections.abc import Callable
+from typing import IO, Any, Literal
+
+__all__ = ["Cmd"]
+
+PROMPT: Literal["(Cmd) "]
+IDENTCHARS: str  # 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: ...

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

@@ -0,0 +1,33 @@
+from codeop import CommandCompiler
+from collections.abc import Callable, Mapping
+from types import CodeType
+from typing import Any
+
+__all__ = ["InteractiveInterpreter", "InteractiveConsole", "interact", "compile_command"]
+
+class InteractiveInterpreter:
+    locals: Mapping[str, Any]  # undocumented
+    compile: CommandCompiler  # undocumented
+    def __init__(self, locals: Mapping[str, Any] | None = None) -> None: ...
+    def runsource(self, source: str, filename: str = "<input>", symbol: str = "single") -> bool: ...
+    def runcode(self, code: CodeType) -> None: ...
+    def showsyntaxerror(self, filename: str | None = None) -> None: ...
+    def showtraceback(self) -> None: ...
+    def write(self, data: str) -> None: ...
+
+class InteractiveConsole(InteractiveInterpreter):
+    buffer: list[str]  # undocumented
+    filename: str  # undocumented
+    def __init__(self, locals: Mapping[str, Any] | None = None, filename: str = "<console>") -> None: ...
+    def interact(self, banner: str | None = None, exitmsg: str | None = None) -> None: ...
+    def push(self, line: str) -> bool: ...
+    def resetbuffer(self) -> None: ...
+    def raw_input(self, prompt: str = "") -> str: ...
+
+def interact(
+    banner: str | None = None,
+    readfunc: Callable[[str], str] | None = None,
+    local: Mapping[str, Any] | None = None,
+    exitmsg: str | None = None,
+) -> None: ...
+def compile_command(source: str, filename: str = "<input>", symbol: str = "single") -> CodeType | None: ...