jaclang 0.7.34__py3-none-any.whl → 0.8.0__py3-none-any.whl

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

@@ -1,146 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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: ...