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

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

@@ -0,0 +1,106 @@
+import sys
+from _typeshed import SupportsLenAndGetItem, SupportsRichComparisonT
+from collections.abc import Callable, MutableSequence
+from typing import TypeVar, overload
+
+_T = TypeVar("_T")
+
+if sys.version_info >= (3, 10):
+    @overload
+    def bisect_left(
+        a: SupportsLenAndGetItem[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: None = None,
+    ) -> int: ...
+    @overload
+    def bisect_left(
+        a: SupportsLenAndGetItem[_T],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: Callable[[_T], SupportsRichComparisonT],
+    ) -> int: ...
+    @overload
+    def bisect_right(
+        a: SupportsLenAndGetItem[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: None = None,
+    ) -> int: ...
+    @overload
+    def bisect_right(
+        a: SupportsLenAndGetItem[_T],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: Callable[[_T], SupportsRichComparisonT],
+    ) -> int: ...
+    @overload
+    def insort_left(
+        a: MutableSequence[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: None = None,
+    ) -> None: ...
+    @overload
+    def insort_left(
+        a: MutableSequence[_T],
+        x: _T,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: Callable[[_T], SupportsRichComparisonT],
+    ) -> None: ...
+    @overload
+    def insort_right(
+        a: MutableSequence[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: None = None,
+    ) -> None: ...
+    @overload
+    def insort_right(
+        a: MutableSequence[_T],
+        x: _T,
+        lo: int = 0,
+        hi: int | None = None,
+        *,
+        key: Callable[[_T], SupportsRichComparisonT],
+    ) -> None: ...
+
+else:
+    def bisect_left(
+        a: SupportsLenAndGetItem[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+    ) -> int: ...
+    def bisect_right(
+        a: SupportsLenAndGetItem[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+    ) -> int: ...
+    def insort_left(
+        a: MutableSequence[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+    ) -> None: ...
+    def insort_right(
+        a: MutableSequence[SupportsRichComparisonT],
+        x: SupportsRichComparisonT,
+        lo: int = 0,
+        hi: int | None = None,
+    ) -> None: ...

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

@@ -0,0 +1 @@
+def getpreferredencoding(do_setlocale: bool = True) -> str: ...

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

@@ -0,0 +1,198 @@
+import codecs
+import sys
+from _typeshed import ReadableBuffer
+from collections.abc import Callable
+from typing import Literal, overload
+from typing_extensions import TypeAlias
+
+# This type is not exposed; it is defined in unicodeobject.c
+class _EncodingMap:
+    def size(self) -> int: ...
+
+_CharMap: TypeAlias = dict[int, int] | _EncodingMap
+_Handler: TypeAlias = Callable[[UnicodeError], tuple[str | bytes, int]]
+_SearchFunction: TypeAlias = Callable[[str], codecs.CodecInfo | None]
+
+def register(__search_function: _SearchFunction) -> None: ...
+
+if sys.version_info >= (3, 10):
+    def unregister(__search_function: _SearchFunction) -> None: ...
+
+def register_error(__errors: str, __handler: _Handler) -> None: ...
+def lookup_error(__name: str) -> _Handler: ...
+
+# The type ignore on `encode` and `decode` is to avoid issues with overlapping overloads, for more details, see #300
+# https://docs.python.org/3/library/codecs.html#binary-transforms
+_BytesToBytesEncoding: TypeAlias = Literal[
+    "base64",
+    "base_64",
+    "base64_codec",
+    "bz2",
+    "bz2_codec",
+    "hex",
+    "hex_codec",
+    "quopri",
+    "quotedprintable",
+    "quoted_printable",
+    "quopri_codec",
+    "uu",
+    "uu_codec",
+    "zip",
+    "zlib",
+    "zlib_codec",
+]
+# https://docs.python.org/3/library/codecs.html#text-transforms
+_StrToStrEncoding: TypeAlias = Literal["rot13", "rot_13"]
+
+@overload
+def encode(
+    obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = "strict"
+) -> bytes: ...
+@overload
+def encode(obj: str, encoding: _StrToStrEncoding, errors: str = "strict") -> str: ...  # type: ignore[overload-overlap]
+@overload
+def encode(obj: str, encoding: str = "utf-8", errors: str = "strict") -> bytes: ...
+@overload
+def decode(obj: ReadableBuffer, encoding: _BytesToBytesEncoding, errors: str = "strict") -> bytes: ...  # type: ignore[overload-overlap]
+@overload
+def decode(obj: str, encoding: _StrToStrEncoding, errors: str = "strict") -> str: ...
+
+# these are documented as text encodings but in practice they also accept str as input
+@overload
+def decode(
+    obj: str,
+    encoding: Literal[
+        "unicode_escape", "unicode-escape", "raw_unicode_escape", "raw-unicode-escape"
+    ],
+    errors: str = "strict",
+) -> str: ...
+
+# hex is officially documented as a bytes to bytes encoding, but it appears to also work with str
+@overload
+def decode(
+    obj: str, encoding: Literal["hex", "hex_codec"], errors: str = "strict"
+) -> bytes: ...
+@overload
+def decode(
+    obj: ReadableBuffer, encoding: str = "utf-8", errors: str = "strict"
+) -> str: ...
+def lookup(__encoding: str) -> codecs.CodecInfo: ...
+def charmap_build(__map: str) -> _CharMap: ...
+def ascii_decode(
+    __data: ReadableBuffer, __errors: str | None = None
+) -> tuple[str, int]: ...
+def ascii_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+def charmap_decode(
+    __data: ReadableBuffer,
+    __errors: str | None = None,
+    __mapping: _CharMap | None = None,
+) -> tuple[str, int]: ...
+def charmap_encode(
+    __str: str, __errors: str | None = None, __mapping: _CharMap | None = None
+) -> tuple[bytes, int]: ...
+def escape_decode(
+    __data: str | ReadableBuffer, __errors: str | None = None
+) -> tuple[str, int]: ...
+def escape_encode(__data: bytes, __errors: str | None = None) -> tuple[bytes, int]: ...
+def latin_1_decode(
+    __data: ReadableBuffer, __errors: str | None = None
+) -> tuple[str, int]: ...
+def latin_1_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+
+if sys.version_info >= (3, 9):
+    def raw_unicode_escape_decode(
+        __data: str | ReadableBuffer, __errors: str | None = None, __final: bool = True
+    ) -> tuple[str, int]: ...
+
+else:
+    def raw_unicode_escape_decode(
+        __data: str | ReadableBuffer, __errors: str | None = None
+    ) -> tuple[str, int]: ...
+
+def raw_unicode_escape_encode(
+    __str: str, __errors: str | None = None
+) -> tuple[bytes, int]: ...
+def readbuffer_encode(
+    __data: str | ReadableBuffer, __errors: str | None = None
+) -> tuple[bytes, int]: ...
+
+if sys.version_info >= (3, 9):
+    def unicode_escape_decode(
+        __data: str | ReadableBuffer, __errors: str | None = None, __final: bool = True
+    ) -> tuple[str, int]: ...
+
+else:
+    def unicode_escape_decode(
+        __data: str | ReadableBuffer, __errors: str | None = None
+    ) -> tuple[str, int]: ...
+
+def unicode_escape_encode(
+    __str: str, __errors: str | None = None
+) -> tuple[bytes, int]: ...
+def utf_16_be_decode(
+    __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+) -> tuple[str, int]: ...
+def utf_16_be_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+def utf_16_decode(
+    __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+) -> tuple[str, int]: ...
+def utf_16_encode(
+    __str: str, __errors: str | None = None, __byteorder: int = 0
+) -> tuple[bytes, int]: ...
+def utf_16_ex_decode(
+    __data: ReadableBuffer,
+    __errors: str | None = None,
+    __byteorder: int = 0,
+    __final: bool = False,
+) -> tuple[str, int, int]: ...
+def utf_16_le_decode(
+    __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+) -> tuple[str, int]: ...
+def utf_16_le_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+def utf_32_be_decode(
+    __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+) -> tuple[str, int]: ...
+def utf_32_be_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+def utf_32_decode(
+    __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+) -> tuple[str, int]: ...
+def utf_32_encode(
+    __str: str, __errors: str | None = None, __byteorder: int = 0
+) -> tuple[bytes, int]: ...
+def utf_32_ex_decode(
+    __data: ReadableBuffer,
+    __errors: str | None = None,
+    __byteorder: int = 0,
+    __final: bool = False,
+) -> tuple[str, int, int]: ...
+def utf_32_le_decode(
+    __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+) -> tuple[str, int]: ...
+def utf_32_le_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+def utf_7_decode(
+    __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+) -> tuple[str, int]: ...
+def utf_7_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+def utf_8_decode(
+    __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+) -> tuple[str, int]: ...
+def utf_8_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+
+if sys.platform == "win32":
+    def mbcs_decode(
+        __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+    ) -> tuple[str, int]: ...
+    def mbcs_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+    def code_page_decode(
+        __codepage: int,
+        __data: ReadableBuffer,
+        __errors: str | None = None,
+        __final: bool = False,
+    ) -> tuple[str, int]: ...
+    def code_page_encode(
+        __code_page: int, __str: str, __errors: str | None = None
+    ) -> tuple[bytes, int]: ...
+    def oem_decode(
+        __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+    ) -> tuple[str, int]: ...
+    def oem_encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...

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

@@ -0,0 +1,94 @@
+import sys
+from abc import abstractmethod
+from types import MappingProxyType
+from typing import (  # noqa: Y022,Y038,Y057
+    AbstractSet as Set,
+    AsyncGenerator as AsyncGenerator,
+    AsyncIterable as AsyncIterable,
+    AsyncIterator as AsyncIterator,
+    Awaitable as Awaitable,
+    ByteString as ByteString,
+    Callable as Callable,
+    Collection as Collection,
+    Container as Container,
+    Coroutine as Coroutine,
+    Generator as Generator,
+    Generic,
+    Hashable as Hashable,
+    ItemsView as ItemsView,
+    Iterable as Iterable,
+    Iterator as Iterator,
+    KeysView as KeysView,
+    Mapping as Mapping,
+    MappingView as MappingView,
+    MutableMapping as MutableMapping,
+    MutableSequence as MutableSequence,
+    MutableSet as MutableSet,
+    Protocol,
+    Reversible as Reversible,
+    Sequence as Sequence,
+    Sized as Sized,
+    TypeVar,
+    ValuesView as ValuesView,
+    final,
+    runtime_checkable,
+)
+
+__all__ = [
+    "Awaitable",
+    "Coroutine",
+    "AsyncIterable",
+    "AsyncIterator",
+    "AsyncGenerator",
+    "Hashable",
+    "Iterable",
+    "Iterator",
+    "Generator",
+    "Reversible",
+    "Sized",
+    "Container",
+    "Callable",
+    "Collection",
+    "Set",
+    "MutableSet",
+    "Mapping",
+    "MutableMapping",
+    "MappingView",
+    "KeysView",
+    "ItemsView",
+    "ValuesView",
+    "Sequence",
+    "MutableSequence",
+    "ByteString",
+]
+if sys.version_info >= (3, 12):
+    __all__ += ["Buffer"]
+
+_KT_co = TypeVar("_KT_co", covariant=True)  # Key type covariant containers.
+_VT_co = TypeVar("_VT_co", covariant=True)  # Value type covariant containers.
+
+@final
+class dict_keys(KeysView[_KT_co], Generic[_KT_co, _VT_co]):  # undocumented
+    def __eq__(self, __value: object) -> bool: ...
+    if sys.version_info >= (3, 10):
+        @property
+        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
+
+@final
+class dict_values(ValuesView[_VT_co], Generic[_KT_co, _VT_co]):  # undocumented
+    if sys.version_info >= (3, 10):
+        @property
+        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
+
+@final
+class dict_items(ItemsView[_KT_co, _VT_co]):  # undocumented
+    def __eq__(self, __value: object) -> bool: ...
+    if sys.version_info >= (3, 10):
+        @property
+        def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
+
+if sys.version_info >= (3, 12):
+    @runtime_checkable
+    class Buffer(Protocol):
+        @abstractmethod
+        def __buffer__(self, __flags: int) -> memoryview: ...

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

@@ -0,0 +1,8 @@
+IMPORT_MAPPING: dict[str, str]
+NAME_MAPPING: dict[tuple[str, str], tuple[str, str]]
+PYTHON2_EXCEPTIONS: tuple[str, ...]
+MULTIPROCESSING_EXCEPTIONS: tuple[str, ...]
+REVERSE_IMPORT_MAPPING: dict[str, str]
+REVERSE_NAME_MAPPING: dict[tuple[str, str], tuple[str, str]]
+PYTHON3_OSERROR_EXCEPTIONS: tuple[str, ...]
+PYTHON3_IMPORTERROR_EXCEPTIONS: tuple[str, ...]

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

@@ -0,0 +1,25 @@
+from _typeshed import WriteableBuffer
+from collections.abc import Callable
+from io import DEFAULT_BUFFER_SIZE, BufferedIOBase, RawIOBase
+from typing import Any, Protocol
+
+BUFFER_SIZE = DEFAULT_BUFFER_SIZE
+
+class _Reader(Protocol):
+    def read(self, __n: int) -> bytes: ...
+    def seekable(self) -> bool: ...
+    def seek(self, __n: int) -> Any: ...
+
+class BaseStream(BufferedIOBase): ...
+
+class DecompressReader(RawIOBase):
+    def __init__(
+        self,
+        fp: _Reader,
+        decomp_factory: Callable[..., object],
+        trailing_error: type[Exception] | tuple[type[Exception], ...] = (),
+        **decomp_args: Any,
+    ) -> None: ...
+    def readinto(self, b: WriteableBuffer) -> int: ...
+    def read(self, size: int = -1) -> bytes: ...
+    def seek(self, offset: int, whence: int = 0) -> int: ...

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

@@ -0,0 +1,90 @@
+import sys
+from _typeshed import SupportsWrite
+from collections.abc import Iterable, Iterator
+from typing import Any, Final, Literal
+from typing_extensions import TypeAlias
+
+__version__: Final[str]
+
+QUOTE_ALL: Literal[1]
+QUOTE_MINIMAL: Literal[0]
+QUOTE_NONE: Literal[3]
+QUOTE_NONNUMERIC: Literal[2]
+if sys.version_info >= (3, 12):
+    QUOTE_STRINGS: Literal[4]
+    QUOTE_NOTNULL: Literal[5]
+
+# Ideally this would be `QUOTE_ALL | QUOTE_MINIMAL | QUOTE_NONE | QUOTE_NONNUMERIC`
+# However, using literals in situations like these can cause false-positives (see #7258)
+_QuotingType: TypeAlias = int
+
+class Error(Exception): ...
+
+class Dialect:
+    delimiter: str
+    quotechar: str | None
+    escapechar: str | None
+    doublequote: bool
+    skipinitialspace: bool
+    lineterminator: str
+    quoting: _QuotingType
+    strict: bool
+    def __init__(self) -> None: ...
+
+_DialectLike: TypeAlias = str | Dialect | type[Dialect]
+
+class _reader(Iterator[list[str]]):
+    @property
+    def dialect(self) -> Dialect: ...
+    line_num: int
+    def __next__(self) -> list[str]: ...
+
+class _writer:
+    @property
+    def dialect(self) -> Dialect: ...
+    def writerow(self, row: Iterable[Any]) -> Any: ...
+    def writerows(self, rows: Iterable[Iterable[Any]]) -> None: ...
+
+def writer(
+    csvfile: SupportsWrite[str],
+    dialect: _DialectLike = "excel",
+    *,
+    delimiter: str = ",",
+    quotechar: str | None = '"',
+    escapechar: str | None = None,
+    doublequote: bool = True,
+    skipinitialspace: bool = False,
+    lineterminator: str = "\r\n",
+    quoting: _QuotingType = 0,
+    strict: bool = False,
+) -> _writer: ...
+def reader(
+    csvfile: Iterable[str],
+    dialect: _DialectLike = "excel",
+    *,
+    delimiter: str = ",",
+    quotechar: str | None = '"',
+    escapechar: str | None = None,
+    doublequote: bool = True,
+    skipinitialspace: bool = False,
+    lineterminator: str = "\r\n",
+    quoting: _QuotingType = 0,
+    strict: bool = False,
+) -> _reader: ...
+def register_dialect(
+    name: str,
+    dialect: type[Dialect] = ...,
+    *,
+    delimiter: str = ",",
+    quotechar: str | None = '"',
+    escapechar: str | None = None,
+    doublequote: bool = True,
+    skipinitialspace: bool = False,
+    lineterminator: str = "\r\n",
+    quoting: _QuotingType = 0,
+    strict: bool = False,
+) -> None: ...
+def unregister_dialect(name: str) -> None: ...
+def get_dialect(name: str) -> Dialect: ...
+def list_dialects() -> list[str]: ...
+def field_size_limit(new_limit: int = ...) -> int: ...