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

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

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

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

@@ -0,0 +1,344 @@
+import types
+from _codecs import *
+from _typeshed import ReadableBuffer
+from abc import abstractmethod
+from collections.abc import Callable, Generator, Iterable
+from typing import Any, BinaryIO, Literal, Protocol, TextIO
+from typing_extensions import Self
+
+__all__ = [
+    "register",
+    "lookup",
+    "open",
+    "EncodedFile",
+    "BOM",
+    "BOM_BE",
+    "BOM_LE",
+    "BOM32_BE",
+    "BOM32_LE",
+    "BOM64_BE",
+    "BOM64_LE",
+    "BOM_UTF8",
+    "BOM_UTF16",
+    "BOM_UTF16_LE",
+    "BOM_UTF16_BE",
+    "BOM_UTF32",
+    "BOM_UTF32_LE",
+    "BOM_UTF32_BE",
+    "CodecInfo",
+    "Codec",
+    "IncrementalEncoder",
+    "IncrementalDecoder",
+    "StreamReader",
+    "StreamWriter",
+    "StreamReaderWriter",
+    "StreamRecoder",
+    "getencoder",
+    "getdecoder",
+    "getincrementalencoder",
+    "getincrementaldecoder",
+    "getreader",
+    "getwriter",
+    "encode",
+    "decode",
+    "iterencode",
+    "iterdecode",
+    "strict_errors",
+    "ignore_errors",
+    "replace_errors",
+    "xmlcharrefreplace_errors",
+    "backslashreplace_errors",
+    "namereplace_errors",
+    "register_error",
+    "lookup_error",
+]
+
+BOM32_BE: Literal[b"\xfe\xff"]
+BOM32_LE: Literal[b"\xff\xfe"]
+BOM64_BE: Literal[b"\x00\x00\xfe\xff"]
+BOM64_LE: Literal[b"\xff\xfe\x00\x00"]
+
+class _WritableStream(Protocol):
+    def write(self, __data: bytes) -> object: ...
+    def seek(self, __offset: int, __whence: int) -> object: ...
+    def close(self) -> object: ...
+
+class _ReadableStream(Protocol):
+    def read(self, __size: int = ...) -> bytes: ...
+    def seek(self, __offset: int, __whence: int) -> object: ...
+    def close(self) -> object: ...
+
+class _Stream(_WritableStream, _ReadableStream, Protocol): ...
+
+# TODO: this only satisfies the most common interface, where
+# bytes is the raw form and str is the cooked form.
+# In the long run, both should become template parameters maybe?
+# There *are* bytes->bytes and str->str encodings in the standard library.
+# They were much more common in Python 2 than in Python 3.
+
+class _Encoder(Protocol):
+    def __call__(
+        self, __input: str, __errors: str = ...
+    ) -> tuple[bytes, int]: ...  # signature of Codec().encode
+
+class _Decoder(Protocol):
+    def __call__(
+        self, __input: bytes, __errors: str = ...
+    ) -> tuple[str, int]: ...  # signature of Codec().decode
+
+class _StreamReader(Protocol):
+    def __call__(
+        self, __stream: _ReadableStream, __errors: str = ...
+    ) -> StreamReader: ...
+
+class _StreamWriter(Protocol):
+    def __call__(
+        self, __stream: _WritableStream, __errors: str = ...
+    ) -> StreamWriter: ...
+
+class _IncrementalEncoder(Protocol):
+    def __call__(self, errors: str = ...) -> IncrementalEncoder: ...
+
+class _IncrementalDecoder(Protocol):
+    def __call__(self, errors: str = ...) -> IncrementalDecoder: ...
+
+class CodecInfo(tuple[_Encoder, _Decoder, _StreamReader, _StreamWriter]):
+    _is_text_encoding: bool
+    @property
+    def encode(self) -> _Encoder: ...
+    @property
+    def decode(self) -> _Decoder: ...
+    @property
+    def streamreader(self) -> _StreamReader: ...
+    @property
+    def streamwriter(self) -> _StreamWriter: ...
+    @property
+    def incrementalencoder(self) -> _IncrementalEncoder: ...
+    @property
+    def incrementaldecoder(self) -> _IncrementalDecoder: ...
+    name: str
+    def __new__(
+        cls,
+        encode: _Encoder,
+        decode: _Decoder,
+        streamreader: _StreamReader | None = None,
+        streamwriter: _StreamWriter | None = None,
+        incrementalencoder: _IncrementalEncoder | None = None,
+        incrementaldecoder: _IncrementalDecoder | None = None,
+        name: str | None = None,
+        *,
+        _is_text_encoding: bool | None = None,
+    ) -> Self: ...
+
+def getencoder(encoding: str) -> _Encoder: ...
+def getdecoder(encoding: str) -> _Decoder: ...
+def getincrementalencoder(encoding: str) -> _IncrementalEncoder: ...
+def getincrementaldecoder(encoding: str) -> _IncrementalDecoder: ...
+def getreader(encoding: str) -> _StreamReader: ...
+def getwriter(encoding: str) -> _StreamWriter: ...
+def open(
+    filename: str,
+    mode: str = "r",
+    encoding: str | None = None,
+    errors: str = "strict",
+    buffering: int = -1,
+) -> StreamReaderWriter: ...
+def EncodedFile(
+    file: _Stream,
+    data_encoding: str,
+    file_encoding: str | None = None,
+    errors: str = "strict",
+) -> StreamRecoder: ...
+def iterencode(
+    iterator: Iterable[str], encoding: str, errors: str = "strict"
+) -> Generator[bytes, None, None]: ...
+def iterdecode(
+    iterator: Iterable[bytes], encoding: str, errors: str = "strict"
+) -> Generator[str, None, None]: ...
+
+BOM: Literal[b"\xff\xfe", b"\xfe\xff"]  # depends on `sys.byteorder`
+BOM_BE: Literal[b"\xfe\xff"]
+BOM_LE: Literal[b"\xff\xfe"]
+BOM_UTF8: Literal[b"\xef\xbb\xbf"]
+BOM_UTF16: Literal[b"\xff\xfe", b"\xfe\xff"]  # depends on `sys.byteorder`
+BOM_UTF16_BE: Literal[b"\xfe\xff"]
+BOM_UTF16_LE: Literal[b"\xff\xfe"]
+BOM_UTF32: Literal[
+    b"\xff\xfe\x00\x00", b"\x00\x00\xfe\xff"
+]  # depends on `sys.byteorder`
+BOM_UTF32_BE: Literal[b"\x00\x00\xfe\xff"]
+BOM_UTF32_LE: Literal[b"\xff\xfe\x00\x00"]
+
+def strict_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
+def replace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
+def ignore_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
+def xmlcharrefreplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
+def backslashreplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
+def namereplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
+
+class Codec:
+    # These are sort of @abstractmethod but sort of not.
+    # The StreamReader and StreamWriter subclasses only implement one.
+    def encode(self, input: str, errors: str = "strict") -> tuple[bytes, int]: ...
+    def decode(self, input: bytes, errors: str = "strict") -> tuple[str, int]: ...
+
+class IncrementalEncoder:
+    errors: str
+    def __init__(self, errors: str = "strict") -> None: ...
+    @abstractmethod
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+    def reset(self) -> None: ...
+    # documentation says int but str is needed for the subclass.
+    def getstate(self) -> int | str: ...
+    def setstate(self, state: int | str) -> None: ...
+
+class IncrementalDecoder:
+    errors: str
+    def __init__(self, errors: str = "strict") -> None: ...
+    @abstractmethod
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+    def reset(self) -> None: ...
+    def getstate(self) -> tuple[bytes, int]: ...
+    def setstate(self, state: tuple[bytes, int]) -> None: ...
+
+# These are not documented but used in encodings/*.py implementations.
+class BufferedIncrementalEncoder(IncrementalEncoder):
+    buffer: str
+    def __init__(self, errors: str = "strict") -> None: ...
+    @abstractmethod
+    def _buffer_encode(
+        self, input: str, errors: str, final: bool
+    ) -> tuple[bytes, int]: ...
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class BufferedIncrementalDecoder(IncrementalDecoder):
+    buffer: bytes
+    def __init__(self, errors: str = "strict") -> None: ...
+    @abstractmethod
+    def _buffer_decode(
+        self, input: ReadableBuffer, errors: str, final: bool
+    ) -> tuple[str, int]: ...
+    def decode(self, input: ReadableBuffer, final: bool = False) -> str: ...
+
+# TODO: it is not possible to specify the requirement that all other
+# attributes and methods are passed-through from the stream.
+class StreamWriter(Codec):
+    stream: _WritableStream
+    errors: str
+    def __init__(self, stream: _WritableStream, errors: str = "strict") -> None: ...
+    def write(self, object: str) -> None: ...
+    def writelines(self, list: Iterable[str]) -> None: ...
+    def reset(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        type: type[BaseException] | None,
+        value: BaseException | None,
+        tb: types.TracebackType | None,
+    ) -> None: ...
+    def __getattr__(
+        self, name: str, getattr: Callable[[Any, str], Any] = ...
+    ) -> Any: ...
+
+class StreamReader(Codec):
+    stream: _ReadableStream
+    errors: str
+    def __init__(self, stream: _ReadableStream, errors: str = "strict") -> None: ...
+    def read(self, size: int = -1, chars: int = -1, firstline: bool = False) -> str: ...
+    def readline(self, size: int | None = None, keepends: bool = True) -> str: ...
+    def readlines(
+        self, sizehint: int | None = None, keepends: bool = True
+    ) -> list[str]: ...
+    def reset(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        type: type[BaseException] | None,
+        value: BaseException | None,
+        tb: types.TracebackType | None,
+    ) -> None: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> str: ...
+    def __getattr__(
+        self, name: str, getattr: Callable[[Any, str], Any] = ...
+    ) -> Any: ...
+
+# Doesn't actually inherit from TextIO, but wraps a BinaryIO to provide text reading and writing
+# and delegates attributes to the underlying binary stream with __getattr__.
+class StreamReaderWriter(TextIO):
+    stream: _Stream
+    def __init__(
+        self,
+        stream: _Stream,
+        Reader: _StreamReader,
+        Writer: _StreamWriter,
+        errors: str = "strict",
+    ) -> None: ...
+    def read(self, size: int = -1) -> str: ...
+    def readline(self, size: int | None = None) -> str: ...
+    def readlines(self, sizehint: int | None = None) -> list[str]: ...
+    def __next__(self) -> str: ...
+    def __iter__(self) -> Self: ...
+    def write(self, data: str) -> None: ...  # type: ignore[override]
+    def writelines(self, list: Iterable[str]) -> None: ...
+    def reset(self) -> None: ...
+    def seek(self, offset: int, whence: int = 0) -> None: ...  # type: ignore[override]
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        type: type[BaseException] | None,
+        value: BaseException | None,
+        tb: types.TracebackType | None,
+    ) -> None: ...
+    def __getattr__(self, name: str) -> Any: ...
+    # These methods don't actually exist directly, but they are needed to satisfy the TextIO
+    # interface. At runtime, they are delegated through __getattr__.
+    def close(self) -> None: ...
+    def fileno(self) -> int: ...
+    def flush(self) -> None: ...
+    def isatty(self) -> bool: ...
+    def readable(self) -> bool: ...
+    def truncate(self, size: int | None = ...) -> int: ...
+    def seekable(self) -> bool: ...
+    def tell(self) -> int: ...
+    def writable(self) -> bool: ...
+
+class StreamRecoder(BinaryIO):
+    def __init__(
+        self,
+        stream: _Stream,
+        encode: _Encoder,
+        decode: _Decoder,
+        Reader: _StreamReader,
+        Writer: _StreamWriter,
+        errors: str = "strict",
+    ) -> None: ...
+    def read(self, size: int = -1) -> bytes: ...
+    def readline(self, size: int | None = None) -> bytes: ...
+    def readlines(self, sizehint: int | None = None) -> list[bytes]: ...
+    def __next__(self) -> bytes: ...
+    def __iter__(self) -> Self: ...
+    # Base class accepts more types than just bytes
+    def write(self, data: bytes) -> None: ...  # type: ignore[override]
+    def writelines(self, list: Iterable[bytes]) -> None: ...  # type: ignore[override]
+    def reset(self) -> None: ...
+    def __getattr__(self, name: str) -> Any: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        type: type[BaseException] | None,
+        value: BaseException | None,
+        tb: types.TracebackType | None,
+    ) -> None: ...
+    def seek(self, offset: int, whence: int = 0) -> None: ...  # type: ignore[override]
+    # These methods don't actually exist directly, but they are needed to satisfy the BinaryIO
+    # interface. At runtime, they are delegated through __getattr__.
+    def close(self) -> None: ...
+    def fileno(self) -> int: ...
+    def flush(self) -> None: ...
+    def isatty(self) -> bool: ...
+    def readable(self) -> bool: ...
+    def truncate(self, size: int | None = ...) -> int: ...
+    def seekable(self) -> bool: ...
+    def tell(self) -> int: ...
+    def writable(self) -> bool: ...

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

@@ -0,0 +1,17 @@
+from types import CodeType
+
+__all__ = ["compile_command", "Compile", "CommandCompiler"]
+
+def compile_command(
+    source: str, filename: str = "<input>", symbol: str = "single"
+) -> CodeType | None: ...
+
+class Compile:
+    flags: int
+    def __call__(self, source: str, filename: str, symbol: str) -> CodeType: ...
+
+class CommandCompiler:
+    compiler: Compile
+    def __call__(
+        self, source: str, filename: str = "<input>", symbol: str = "single"
+    ) -> CodeType | None: ...