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

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

@@ -0,0 +1,162 @@
+import _compression
+import sys
+import zlib
+from _typeshed import ReadableBuffer, SizedBuffer, StrOrBytesPath
+from io import FileIO
+from typing import Literal, Protocol, TextIO, overload
+from typing_extensions import TypeAlias
+
+__all__ = ["BadGzipFile", "GzipFile", "open", "compress", "decompress"]
+
+_ReadBinaryMode: TypeAlias = Literal["r", "rb"]
+_WriteBinaryMode: TypeAlias = Literal["a", "ab", "w", "wb", "x", "xb"]
+_OpenTextMode: TypeAlias = Literal["rt", "at", "wt", "xt"]
+
+READ: Literal[1]  # undocumented
+WRITE: Literal[2]  # undocumented
+
+FTEXT: int  # actually Literal[1] # undocumented
+FHCRC: int  # actually Literal[2] # undocumented
+FEXTRA: int  # actually Literal[4] # undocumented
+FNAME: int  # actually Literal[8] # undocumented
+FCOMMENT: int  # actually Literal[16] # undocumented
+
+class _ReadableFileobj(Protocol):
+    def read(self, __n: int) -> bytes: ...
+    def seek(self, __n: int) -> object: ...
+    # The following attributes and methods are optional:
+    # name: str
+    # mode: str
+    # def fileno() -> int: ...
+
+class _WritableFileobj(Protocol):
+    def write(self, __b: bytes) -> object: ...
+    def flush(self) -> object: ...
+    # The following attributes and methods are optional:
+    # name: str
+    # mode: str
+    # def fileno() -> int: ...
+
+@overload
+def open(
+    filename: StrOrBytesPath | _ReadableFileobj,
+    mode: _ReadBinaryMode = "rb",
+    compresslevel: int = 9,
+    encoding: None = None,
+    errors: None = None,
+    newline: None = None,
+) -> GzipFile: ...
+@overload
+def open(
+    filename: StrOrBytesPath | _WritableFileobj,
+    mode: _WriteBinaryMode,
+    compresslevel: int = 9,
+    encoding: None = None,
+    errors: None = None,
+    newline: None = None,
+) -> GzipFile: ...
+@overload
+def open(
+    filename: StrOrBytesPath,
+    mode: _OpenTextMode,
+    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,
+) -> GzipFile | TextIO: ...
+
+class _PaddedFile:
+    file: _ReadableFileobj
+    def __init__(self, f: _ReadableFileobj, prepend: bytes = b"") -> None: ...
+    def read(self, size: int) -> bytes: ...
+    def prepend(self, prepend: bytes = b"") -> None: ...
+    def seek(self, off: int) -> int: ...
+    def seekable(self) -> bool: ...
+
+class BadGzipFile(OSError): ...
+
+class GzipFile(_compression.BaseStream):
+    myfileobj: FileIO | None
+    mode: Literal[1, 2]
+    name: str
+    compress: zlib._Compress
+    fileobj: _ReadableFileobj | _WritableFileobj
+    @overload
+    def __init__(
+        self,
+        filename: StrOrBytesPath | None,
+        mode: _ReadBinaryMode,
+        compresslevel: int = 9,
+        fileobj: _ReadableFileobj | None = None,
+        mtime: float | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        *,
+        mode: _ReadBinaryMode,
+        compresslevel: int = 9,
+        fileobj: _ReadableFileobj | None = None,
+        mtime: float | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        filename: StrOrBytesPath | None,
+        mode: _WriteBinaryMode,
+        compresslevel: int = 9,
+        fileobj: _WritableFileobj | None = None,
+        mtime: float | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        *,
+        mode: _WriteBinaryMode,
+        compresslevel: int = 9,
+        fileobj: _WritableFileobj | None = None,
+        mtime: float | None = None,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        filename: StrOrBytesPath | None = None,
+        mode: str | None = None,
+        compresslevel: int = 9,
+        fileobj: _ReadableFileobj | _WritableFileobj | None = None,
+        mtime: float | None = None,
+    ) -> None: ...
+    if sys.version_info < (3, 12):
+        @property
+        def filename(self) -> str: ...
+
+    @property
+    def mtime(self) -> int | None: ...
+    crc: int
+    def write(self, data: ReadableBuffer) -> int: ...
+    def read(self, size: int | None = -1) -> bytes: ...
+    def read1(self, size: int = -1) -> bytes: ...
+    def peek(self, n: int) -> bytes: ...
+    def close(self) -> None: ...
+    def flush(self, zlib_mode: int = 2) -> None: ...
+    def fileno(self) -> int: ...
+    def rewind(self) -> None: ...
+    def seek(self, offset: int, whence: int = 0) -> int: ...
+    def readline(self, size: int | None = -1) -> bytes: ...
+
+class _GzipReader(_compression.DecompressReader):
+    def __init__(self, fp: _ReadableFileobj) -> None: ...
+
+def compress(
+    data: SizedBuffer, compresslevel: int = 9, *, mtime: float | None = None
+) -> bytes: ...
+def decompress(data: ReadableBuffer) -> bytes: ...

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

@@ -0,0 +1,191 @@
+import sys
+from _typeshed import ReadableBuffer
+from collections.abc import Callable, Set as AbstractSet
+from typing import Protocol, final
+from typing_extensions import Self
+
+if sys.version_info >= (3, 11):
+    __all__ = (
+        "md5",
+        "sha1",
+        "sha224",
+        "sha256",
+        "sha384",
+        "sha512",
+        "blake2b",
+        "blake2s",
+        "sha3_224",
+        "sha3_256",
+        "sha3_384",
+        "sha3_512",
+        "shake_128",
+        "shake_256",
+        "new",
+        "algorithms_guaranteed",
+        "algorithms_available",
+        "pbkdf2_hmac",
+        "file_digest",
+    )
+else:
+    __all__ = (
+        "md5",
+        "sha1",
+        "sha224",
+        "sha256",
+        "sha384",
+        "sha512",
+        "blake2b",
+        "blake2s",
+        "sha3_224",
+        "sha3_256",
+        "sha3_384",
+        "sha3_512",
+        "shake_128",
+        "shake_256",
+        "new",
+        "algorithms_guaranteed",
+        "algorithms_available",
+        "pbkdf2_hmac",
+    )
+
+class _Hash:
+    @property
+    def digest_size(self) -> int: ...
+    @property
+    def block_size(self) -> int: ...
+    @property
+    def name(self) -> str: ...
+    def __init__(self, data: ReadableBuffer = ...) -> None: ...
+    def copy(self) -> Self: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def update(self, __data: ReadableBuffer) -> None: ...
+
+if sys.version_info >= (3, 9):
+    def new(
+        name: str, data: ReadableBuffer = b"", *, usedforsecurity: bool = ...
+    ) -> _Hash: ...
+    def md5(string: ReadableBuffer = b"", *, usedforsecurity: bool = True) -> _Hash: ...
+    def sha1(
+        string: ReadableBuffer = b"", *, usedforsecurity: bool = True
+    ) -> _Hash: ...
+    def sha224(
+        string: ReadableBuffer = b"", *, usedforsecurity: bool = True
+    ) -> _Hash: ...
+    def sha256(
+        string: ReadableBuffer = b"", *, usedforsecurity: bool = True
+    ) -> _Hash: ...
+    def sha384(
+        string: ReadableBuffer = b"", *, usedforsecurity: bool = True
+    ) -> _Hash: ...
+    def sha512(
+        string: ReadableBuffer = b"", *, usedforsecurity: bool = True
+    ) -> _Hash: ...
+
+else:
+    def new(name: str, data: ReadableBuffer = b"") -> _Hash: ...
+    def md5(string: ReadableBuffer = b"") -> _Hash: ...
+    def sha1(string: ReadableBuffer = b"") -> _Hash: ...
+    def sha224(string: ReadableBuffer = b"") -> _Hash: ...
+    def sha256(string: ReadableBuffer = b"") -> _Hash: ...
+    def sha384(string: ReadableBuffer = b"") -> _Hash: ...
+    def sha512(string: ReadableBuffer = b"") -> _Hash: ...
+
+algorithms_guaranteed: AbstractSet[str]
+algorithms_available: AbstractSet[str]
+
+def pbkdf2_hmac(
+    hash_name: str,
+    password: ReadableBuffer,
+    salt: ReadableBuffer,
+    iterations: int,
+    dklen: int | None = None,
+) -> bytes: ...
+
+class _VarLenHash:
+    digest_size: int
+    block_size: int
+    name: str
+    def __init__(self, data: ReadableBuffer = ...) -> None: ...
+    def copy(self) -> _VarLenHash: ...
+    def digest(self, __length: int) -> bytes: ...
+    def hexdigest(self, __length: int) -> str: ...
+    def update(self, __data: ReadableBuffer) -> None: ...
+
+sha3_224 = _Hash
+sha3_256 = _Hash
+sha3_384 = _Hash
+sha3_512 = _Hash
+shake_128 = _VarLenHash
+shake_256 = _VarLenHash
+
+def scrypt(
+    password: ReadableBuffer,
+    *,
+    salt: ReadableBuffer,
+    n: int,
+    r: int,
+    p: int,
+    maxmem: int = 0,
+    dklen: int = 64,
+) -> bytes: ...
+@final
+class _BlakeHash(_Hash):
+    MAX_DIGEST_SIZE: int
+    MAX_KEY_SIZE: int
+    PERSON_SIZE: int
+    SALT_SIZE: int
+
+    if sys.version_info >= (3, 9):
+        def __init__(
+            self,
+            __data: ReadableBuffer = ...,
+            *,
+            digest_size: int = ...,
+            key: ReadableBuffer = ...,
+            salt: ReadableBuffer = ...,
+            person: ReadableBuffer = ...,
+            fanout: int = ...,
+            depth: int = ...,
+            leaf_size: int = ...,
+            node_offset: int = ...,
+            node_depth: int = ...,
+            inner_size: int = ...,
+            last_node: bool = ...,
+            usedforsecurity: bool = ...,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            __data: ReadableBuffer = ...,
+            *,
+            digest_size: int = ...,
+            key: ReadableBuffer = ...,
+            salt: ReadableBuffer = ...,
+            person: ReadableBuffer = ...,
+            fanout: int = ...,
+            depth: int = ...,
+            leaf_size: int = ...,
+            node_offset: int = ...,
+            node_depth: int = ...,
+            inner_size: int = ...,
+            last_node: bool = ...,
+        ) -> None: ...
+
+blake2b = _BlakeHash
+blake2s = _BlakeHash
+
+if sys.version_info >= (3, 11):
+    class _BytesIOLike(Protocol):
+        def getbuffer(self) -> ReadableBuffer: ...
+
+    class _FileDigestFileObj(Protocol):
+        def readinto(self, __buf: bytearray) -> int: ...
+        def readable(self) -> bool: ...
+
+    def file_digest(
+        __fileobj: _BytesIOLike | _FileDigestFileObj,
+        __digest: str | Callable[[], _Hash],
+        *,
+        _bufsize: int = 262144,
+    ) -> _Hash: ...

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

@@ -0,0 +1,36 @@
+from _heapq import *
+from _typeshed import SupportsRichComparison
+from collections.abc import Callable, Iterable
+from typing import Any, Final, TypeVar
+
+__all__ = [
+    "heappush",
+    "heappop",
+    "heapify",
+    "heapreplace",
+    "merge",
+    "nlargest",
+    "nsmallest",
+    "heappushpop",
+]
+
+_S = TypeVar("_S")
+
+__about__: Final[str]
+
+def merge(
+    *iterables: Iterable[_S],
+    key: Callable[[_S], SupportsRichComparison] | None = None,
+    reverse: bool = False
+) -> Iterable[_S]: ...
+def nlargest(
+    n: int,
+    iterable: Iterable[_S],
+    key: Callable[[_S], SupportsRichComparison] | None = None,
+) -> list[_S]: ...
+def nsmallest(
+    n: int,
+    iterable: Iterable[_S],
+    key: Callable[[_S], SupportsRichComparison] | None = None,
+) -> list[_S]: ...
+def _heapify_max(__heap: list[Any]) -> None: ...  # undocumented

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

@@ -0,0 +1,45 @@
+from _typeshed import ReadableBuffer, SizedBuffer
+from collections.abc import Callable
+from types import ModuleType
+from typing import Any, AnyStr, overload
+from typing_extensions import TypeAlias
+
+# TODO more precise type for object of hashlib
+_Hash: TypeAlias = Any
+_DigestMod: TypeAlias = str | Callable[[], _Hash] | ModuleType
+
+trans_5C: bytes
+trans_36: bytes
+
+digest_size: None
+
+# In reality digestmod has a default value, but the function always throws an error
+# if the argument is not given, so we pretend it is a required argument.
+@overload
+def new(
+    key: bytes | bytearray, msg: ReadableBuffer | None, digestmod: _DigestMod
+) -> HMAC: ...
+@overload
+def new(key: bytes | bytearray, *, digestmod: _DigestMod) -> HMAC: ...
+
+class HMAC:
+    digest_size: int
+    block_size: int
+    @property
+    def name(self) -> str: ...
+    def __init__(
+        self,
+        key: bytes | bytearray,
+        msg: ReadableBuffer | None = None,
+        digestmod: _DigestMod = "",
+    ) -> None: ...
+    def update(self, msg: ReadableBuffer) -> None: ...
+    def digest(self) -> bytes: ...
+    def hexdigest(self) -> str: ...
+    def copy(self) -> HMAC: ...
+
+@overload
+def compare_digest(__a: ReadableBuffer, __b: ReadableBuffer) -> bool: ...
+@overload
+def compare_digest(__a: AnyStr, __b: AnyStr) -> bool: ...
+def digest(key: SizedBuffer, msg: ReadableBuffer, digest: _DigestMod) -> bytes: ...

jaclang/vendor/mypy/typeshed/stdlib/html/__init__.pyi

@@ -0,0 +1,6 @@
+from typing import AnyStr
+
+__all__ = ["escape", "unescape"]
+
+def escape(s: AnyStr, quote: bool = True) -> AnyStr: ...
+def unescape(s: AnyStr) -> AnyStr: ...

jaclang/vendor/mypy/typeshed/stdlib/html/entities.pyi

@@ -0,0 +1,6 @@
+__all__ = ["html5", "name2codepoint", "codepoint2name", "entitydefs"]
+
+name2codepoint: dict[str, int]
+html5: dict[str, str]
+codepoint2name: dict[int, str]
+entitydefs: dict[str, str]

jaclang/vendor/mypy/typeshed/stdlib/html/parser.pyi

@@ -0,0 +1,40 @@
+from _markupbase import ParserBase
+from re import Pattern
+
+__all__ = ["HTMLParser"]
+
+class HTMLParser(ParserBase):
+    def __init__(self, *, convert_charrefs: bool = True) -> None: ...
+    def feed(self, data: str) -> None: ...
+    def close(self) -> None: ...
+    def get_starttag_text(self) -> str | None: ...
+    def handle_starttag(
+        self, tag: str, attrs: list[tuple[str, str | None]]
+    ) -> None: ...
+    def handle_endtag(self, tag: str) -> None: ...
+    def handle_startendtag(
+        self, tag: str, attrs: list[tuple[str, str | None]]
+    ) -> None: ...
+    def handle_data(self, data: str) -> None: ...
+    def handle_entityref(self, name: str) -> None: ...
+    def handle_charref(self, name: str) -> None: ...
+    def handle_comment(self, data: str) -> None: ...
+    def handle_decl(self, decl: str) -> None: ...
+    def handle_pi(self, data: str) -> None: ...
+    CDATA_CONTENT_ELEMENTS: tuple[str, ...]
+    def check_for_whole_start_tag(self, i: int) -> int: ...  # undocumented
+    def clear_cdata_mode(self) -> None: ...  # undocumented
+    def goahead(self, end: bool) -> None: ...  # undocumented
+    def parse_bogus_comment(
+        self, i: int, report: bool = ...
+    ) -> int: ...  # undocumented
+    def parse_endtag(self, i: int) -> int: ...  # undocumented
+    def parse_html_declaration(self, i: int) -> int: ...  # undocumented
+    def parse_pi(self, i: int) -> int: ...  # undocumented
+    def parse_starttag(self, i: int) -> int: ...  # undocumented
+    def set_cdata_mode(self, elem: str) -> None: ...  # undocumented
+    rawdata: str  # undocumented
+    cdata_elem: str | None  # undocumented
+    convert_charrefs: bool  # undocumented
+    interesting: Pattern[str]  # undocumented
+    lasttag: str  # undocumented

jaclang/vendor/mypy/typeshed/stdlib/http/__init__.pyi

@@ -0,0 +1,105 @@
+import sys
+from enum import IntEnum
+from typing import Literal
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+
+if sys.version_info >= (3, 11):
+    __all__ = ["HTTPStatus", "HTTPMethod"]
+else:
+    __all__ = ["HTTPStatus"]
+
+class HTTPStatus(IntEnum):
+    @property
+    def phrase(self) -> str: ...
+    @property
+    def description(self) -> str: ...
+    CONTINUE: int
+    SWITCHING_PROTOCOLS: int
+    PROCESSING: int
+    OK: int
+    CREATED: int
+    ACCEPTED: int
+    NON_AUTHORITATIVE_INFORMATION: int
+    NO_CONTENT: int
+    RESET_CONTENT: int
+    PARTIAL_CONTENT: int
+    MULTI_STATUS: int
+    ALREADY_REPORTED: int
+    IM_USED: int
+    MULTIPLE_CHOICES: int
+    MOVED_PERMANENTLY: int
+    FOUND: int
+    SEE_OTHER: int
+    NOT_MODIFIED: int
+    USE_PROXY: int
+    TEMPORARY_REDIRECT: int
+    PERMANENT_REDIRECT: int
+    BAD_REQUEST: int
+    UNAUTHORIZED: int
+    PAYMENT_REQUIRED: int
+    FORBIDDEN: int
+    NOT_FOUND: int
+    METHOD_NOT_ALLOWED: int
+    NOT_ACCEPTABLE: int
+    PROXY_AUTHENTICATION_REQUIRED: int
+    REQUEST_TIMEOUT: int
+    CONFLICT: int
+    GONE: int
+    LENGTH_REQUIRED: int
+    PRECONDITION_FAILED: int
+    REQUEST_ENTITY_TOO_LARGE: int
+    REQUEST_URI_TOO_LONG: int
+    UNSUPPORTED_MEDIA_TYPE: int
+    REQUESTED_RANGE_NOT_SATISFIABLE: int
+    EXPECTATION_FAILED: int
+    UNPROCESSABLE_ENTITY: int
+    LOCKED: int
+    FAILED_DEPENDENCY: int
+    UPGRADE_REQUIRED: int
+    PRECONDITION_REQUIRED: int
+    TOO_MANY_REQUESTS: int
+    REQUEST_HEADER_FIELDS_TOO_LARGE: int
+    INTERNAL_SERVER_ERROR: int
+    NOT_IMPLEMENTED: int
+    BAD_GATEWAY: int
+    SERVICE_UNAVAILABLE: int
+    GATEWAY_TIMEOUT: int
+    HTTP_VERSION_NOT_SUPPORTED: int
+    VARIANT_ALSO_NEGOTIATES: int
+    INSUFFICIENT_STORAGE: int
+    LOOP_DETECTED: int
+    NOT_EXTENDED: int
+    NETWORK_AUTHENTICATION_REQUIRED: int
+    MISDIRECTED_REQUEST: int
+    UNAVAILABLE_FOR_LEGAL_REASONS: int
+    if sys.version_info >= (3, 9):
+        EARLY_HINTS: Literal[103]
+        IM_A_TEAPOT: Literal[418]
+        TOO_EARLY: Literal[425]
+    if sys.version_info >= (3, 12):
+        @property
+        def is_informational(self) -> bool: ...
+        @property
+        def is_success(self) -> bool: ...
+        @property
+        def is_redirection(self) -> bool: ...
+        @property
+        def is_client_error(self) -> bool: ...
+        @property
+        def is_server_error(self) -> bool: ...
+
+if sys.version_info >= (3, 11):
+    class HTTPMethod(StrEnum):
+        @property
+        def description(self) -> str: ...
+        CONNECT: str
+        DELETE: str
+        GET: str
+        HEAD: str
+        OPTIONS: str
+        PATCH: str
+        POST: str
+        PUT: str
+        TRACE: str