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

jaclang/vendor/mypy/typeshed/stdlib/email/quoprimime.pyi

@@ -0,0 +1,30 @@
+from collections.abc import Iterable
+
+__all__ = [
+    "body_decode",
+    "body_encode",
+    "body_length",
+    "decode",
+    "decodestring",
+    "header_decode",
+    "header_encode",
+    "header_length",
+    "quote",
+    "unquote",
+]
+
+def header_check(octet: int) -> bool: ...
+def body_check(octet: int) -> bool: ...
+def header_length(bytearray: Iterable[int]) -> int: ...
+def body_length(bytearray: Iterable[int]) -> int: ...
+def unquote(s: str | bytes | bytearray) -> str: ...
+def quote(c: str | bytes | bytearray) -> str: ...
+def header_encode(
+    header_bytes: bytes | bytearray, charset: str = "iso-8859-1"
+) -> str: ...
+def body_encode(body: str, maxlinelen: int = 76, eol: str = "\n") -> str: ...
+def decode(encoded: str, eol: str = "\n") -> str: ...
+def header_decode(s: str) -> str: ...
+
+body_decode = decode
+decodestring = decode

jaclang/vendor/mypy/typeshed/stdlib/email/utils.pyi

@@ -0,0 +1,84 @@
+import datetime
+import sys
+from _typeshed import Unused
+from email import _ParamType
+from email.charset import Charset
+from typing import overload
+from typing_extensions import TypeAlias
+
+__all__ = [
+    "collapse_rfc2231_value",
+    "decode_params",
+    "decode_rfc2231",
+    "encode_rfc2231",
+    "formataddr",
+    "formatdate",
+    "format_datetime",
+    "getaddresses",
+    "make_msgid",
+    "mktime_tz",
+    "parseaddr",
+    "parsedate",
+    "parsedate_tz",
+    "parsedate_to_datetime",
+    "unquote",
+]
+
+_PDTZ: TypeAlias = tuple[int, int, int, int, int, int, int, int, int, int | None]
+
+def quote(str: str) -> str: ...
+def unquote(str: str) -> str: ...
+def parseaddr(addr: str | None) -> tuple[str, str]: ...
+def formataddr(
+    pair: tuple[str | None, str], charset: str | Charset = "utf-8"
+) -> str: ...
+def getaddresses(fieldvalues: list[str]) -> list[tuple[str, str]]: ...
+@overload
+def parsedate(data: None) -> None: ...
+@overload
+def parsedate(
+    data: str,
+) -> tuple[int, int, int, int, int, int, int, int, int] | None: ...
+@overload
+def parsedate_tz(data: None) -> None: ...
+@overload
+def parsedate_tz(data: str) -> _PDTZ | None: ...
+
+if sys.version_info >= (3, 10):
+    @overload
+    def parsedate_to_datetime(data: None) -> None: ...
+    @overload
+    def parsedate_to_datetime(data: str) -> datetime.datetime: ...
+
+else:
+    def parsedate_to_datetime(data: str) -> datetime.datetime: ...
+
+def mktime_tz(data: _PDTZ) -> int: ...
+def formatdate(
+    timeval: float | None = None, localtime: bool = False, usegmt: bool = False
+) -> str: ...
+def format_datetime(dt: datetime.datetime, usegmt: bool = False) -> str: ...
+
+if sys.version_info >= (3, 12):
+    def localtime(
+        dt: datetime.datetime | None = None, isdst: Unused = None
+    ) -> datetime.datetime: ...
+
+else:
+    def localtime(
+        dt: datetime.datetime | None = None, isdst: int = -1
+    ) -> datetime.datetime: ...
+
+def make_msgid(idstring: str | None = None, domain: str | None = None) -> str: ...
+def decode_rfc2231(
+    s: str,
+) -> tuple[
+    str | None, str | None, str
+]: ...  # May return list[str]. See issue #10431 for details.
+def encode_rfc2231(
+    s: str, charset: str | None = None, language: str | None = None
+) -> str: ...
+def collapse_rfc2231_value(
+    value: _ParamType, errors: str = "replace", fallback_charset: str = "us-ascii"
+) -> str: ...
+def decode_params(params: list[tuple[str, str]]) -> list[tuple[str, _ParamType]]: ...

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

@@ -0,0 +1,10 @@
+from _typeshed import Incomplete
+from codecs import CodecInfo
+
+class CodecRegistryError(LookupError, SystemError): ...
+
+def normalize_encoding(encoding: str | bytes) -> str: ...
+def search_function(encoding: str) -> CodecInfo | None: ...
+
+# Needed for submodules
+def __getattr__(name: str) -> Incomplete: ...

jaclang/vendor/mypy/typeshed/stdlib/encodings/utf_8.pyi

@@ -0,0 +1,25 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    @staticmethod
+    def _buffer_decode(
+        __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+    ) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    @staticmethod
+    def encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    @staticmethod
+    def decode(
+        __data: ReadableBuffer, __errors: str | None = None, __final: bool = False
+    ) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...
+def encode(__str: str, __errors: str | None = None) -> tuple[bytes, int]: ...
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...

jaclang/vendor/mypy/typeshed/stdlib/encodings/utf_8_sig.pyi

@@ -0,0 +1,28 @@
+import codecs
+from _typeshed import ReadableBuffer
+
+class IncrementalEncoder(codecs.IncrementalEncoder):
+    def __init__(self, errors: str = "strict") -> None: ...
+    def encode(self, input: str, final: bool = False) -> bytes: ...
+    def getstate(self) -> int: ...
+    def setstate(self, state: int) -> None: ...  # type: ignore[override]
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    def __init__(self, errors: str = "strict") -> None: ...
+    def _buffer_decode(
+        self, input: ReadableBuffer, errors: str | None, final: bool
+    ) -> tuple[str, int]: ...
+
+class StreamWriter(codecs.StreamWriter):
+    def encode(
+        self, input: str, errors: str | None = "strict"
+    ) -> tuple[bytes, int]: ...
+
+class StreamReader(codecs.StreamReader):
+    def decode(
+        self, input: ReadableBuffer, errors: str | None = "strict"
+    ) -> tuple[str, int]: ...
+
+def getregentry() -> codecs.CodecInfo: ...
+def encode(input: str, errors: str | None = "strict") -> tuple[bytes, int]: ...
+def decode(input: ReadableBuffer, errors: str | None = "strict") -> tuple[str, int]: ...

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

@@ -0,0 +1,12 @@
+__all__ = ["version", "bootstrap"]
+
+def version() -> str: ...
+def bootstrap(
+    *,
+    root: str | None = None,
+    upgrade: bool = False,
+    user: bool = False,
+    altinstall: bool = False,
+    default_pip: bool = False,
+    verbosity: int = 0,
+) -> None: ...

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

@@ -0,0 +1,347 @@
+import _typeshed
+import sys
+import types
+from _typeshed import SupportsKeysAndGetItem, Unused
+from builtins import property as _builtins_property
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from typing import Any, Generic, Literal, TypeVar, overload
+from typing_extensions import Self, TypeAlias
+
+__all__ = ["EnumMeta", "Enum", "IntEnum", "Flag", "IntFlag", "auto", "unique"]
+
+if sys.version_info >= (3, 11):
+    __all__ += [
+        "CONFORM",
+        "CONTINUOUS",
+        "EJECT",
+        "EnumCheck",
+        "EnumType",
+        "FlagBoundary",
+        "KEEP",
+        "NAMED_FLAGS",
+        "ReprEnum",
+        "STRICT",
+        "StrEnum",
+        "UNIQUE",
+        "global_enum",
+        "global_enum_repr",
+        "global_flag_repr",
+        "global_str",
+        "member",
+        "nonmember",
+        "property",
+        "verify",
+    ]
+
+if sys.version_info >= (3, 11):
+    __all__ += ["pickle_by_enum_name", "pickle_by_global_name"]
+
+_EnumMemberT = TypeVar("_EnumMemberT")
+_EnumerationT = TypeVar("_EnumerationT", bound=type[Enum])
+
+# The following all work:
+# >>> from enum import Enum
+# >>> from string import ascii_lowercase
+# >>> Enum('Foo', names='RED YELLOW GREEN')
+# <enum 'Foo'>
+# >>> Enum('Foo', names=[('RED', 1), ('YELLOW, 2)])
+# <enum 'Foo'>
+# >>> Enum('Foo', names=((x for x in (ascii_lowercase[i], i)) for i in range(5)))
+# <enum 'Foo'>
+# >>> Enum('Foo', names={'RED': 1, 'YELLOW': 2})
+# <enum 'Foo'>
+_EnumNames: TypeAlias = (
+    str | Iterable[str] | Iterable[Iterable[str | Any]] | Mapping[str, Any]
+)
+
+if sys.version_info >= (3, 11):
+    class nonmember(Generic[_EnumMemberT]):
+        value: _EnumMemberT
+        def __init__(self, value: _EnumMemberT) -> None: ...
+
+    class member(Generic[_EnumMemberT]):
+        value: _EnumMemberT
+        def __init__(self, value: _EnumMemberT) -> None: ...
+
+class _EnumDict(dict[str, Any]):
+    def __init__(self) -> None: ...
+    def __setitem__(self, key: str, value: Any) -> None: ...
+    if sys.version_info >= (3, 11):
+        # See comment above `typing.MutableMapping.update`
+        # for why overloads are preferable to a Union here
+        #
+        # Unlike with MutableMapping.update(), the first argument is required,
+        # hence the type: ignore
+        @overload  # type: ignore[override]
+        def update(
+            self, members: SupportsKeysAndGetItem[str, Any], **more_members: Any
+        ) -> None: ...
+        @overload
+        def update(
+            self, members: Iterable[tuple[str, Any]], **more_members: Any
+        ) -> None: ...
+
+# Structurally: Iterable[T], Reversible[T], Container[T] where T is the enum itself
+class EnumMeta(type):
+    if sys.version_info >= (3, 11):
+        def __new__(
+            metacls: type[_typeshed.Self],
+            cls: str,
+            bases: tuple[type, ...],
+            classdict: _EnumDict,
+            *,
+            boundary: FlagBoundary | None = None,
+            _simple: bool = False,
+            **kwds: Any,
+        ) -> _typeshed.Self: ...
+    elif sys.version_info >= (3, 9):
+        def __new__(
+            metacls: type[_typeshed.Self],
+            cls: str,
+            bases: tuple[type, ...],
+            classdict: _EnumDict,
+            **kwds: Any,
+        ) -> _typeshed.Self: ...
+    else:
+        def __new__(
+            metacls: type[_typeshed.Self],
+            cls: str,
+            bases: tuple[type, ...],
+            classdict: _EnumDict,
+        ) -> _typeshed.Self: ...
+
+    if sys.version_info >= (3, 9):
+        @classmethod
+        def __prepare__(metacls, cls: str, bases: tuple[type, ...], **kwds: Any) -> _EnumDict: ...  # type: ignore[override]
+    else:
+        @classmethod
+        def __prepare__(metacls, cls: str, bases: tuple[type, ...]) -> _EnumDict: ...  # type: ignore[override]
+
+    def __iter__(self: type[_EnumMemberT]) -> Iterator[_EnumMemberT]: ...
+    def __reversed__(self: type[_EnumMemberT]) -> Iterator[_EnumMemberT]: ...
+    if sys.version_info >= (3, 12):
+        def __contains__(self: type[Any], value: object) -> bool: ...
+    elif sys.version_info >= (3, 11):
+        def __contains__(self: type[Any], member: object) -> bool: ...
+    elif sys.version_info >= (3, 10):
+        def __contains__(self: type[Any], obj: object) -> bool: ...
+    else:
+        def __contains__(self: type[Any], member: object) -> bool: ...
+
+    def __getitem__(self: type[_EnumMemberT], name: str) -> _EnumMemberT: ...
+    @_builtins_property
+    def __members__(
+        self: type[_EnumMemberT],
+    ) -> types.MappingProxyType[str, _EnumMemberT]: ...
+    def __len__(self) -> int: ...
+    def __bool__(self) -> Literal[True]: ...
+    def __dir__(self) -> list[str]: ...
+
+    # Overload 1: Value lookup on an already existing enum class (simple case)
+    @overload
+    def __call__(
+        cls: type[_EnumMemberT], value: Any, names: None = None
+    ) -> _EnumMemberT: ...
+
+    # Overload 2: Functional API for constructing new enum classes.
+    if sys.version_info >= (3, 11):
+        @overload
+        def __call__(
+            cls,
+            value: str,
+            names: _EnumNames,
+            *,
+            module: str | None = None,
+            qualname: str | None = None,
+            type: type | None = None,
+            start: int = 1,
+            boundary: FlagBoundary | None = None,
+        ) -> type[Enum]: ...
+    else:
+        @overload
+        def __call__(
+            cls,
+            value: str,
+            names: _EnumNames,
+            *,
+            module: str | None = None,
+            qualname: str | None = None,
+            type: type | None = None,
+            start: int = 1,
+        ) -> type[Enum]: ...
+
+    # Overload 3 (py312+ only): Value lookup on an already existing enum class (complex case)
+    #
+    # >>> class Foo(enum.Enum):
+    # ...     X = 1, 2, 3
+    # >>> Foo(1, 2, 3)
+    # <Foo.X: (1, 2, 3)>
+    #
+    if sys.version_info >= (3, 12):
+        @overload
+        def __call__(
+            cls: type[_EnumMemberT], value: Any, *values: Any
+        ) -> _EnumMemberT: ...
+
+    _member_names_: list[str]  # undocumented
+    _member_map_: dict[str, Enum]  # undocumented
+    _value2member_map_: dict[Any, Enum]  # undocumented
+
+if sys.version_info >= (3, 11):
+    # In 3.11 `EnumMeta` metaclass is renamed to `EnumType`, but old name also exists.
+    EnumType = EnumMeta
+
+    class property(types.DynamicClassAttribute):
+        def __set_name__(self, ownerclass: type[Enum], name: str) -> None: ...
+        name: str
+        clsname: str
+        member: Enum | None
+
+    _magic_enum_attr = property
+else:
+    _magic_enum_attr = types.DynamicClassAttribute
+
+class Enum(metaclass=EnumMeta):
+    @_magic_enum_attr
+    def name(self) -> str: ...
+    @_magic_enum_attr
+    def value(self) -> Any: ...
+    _name_: str
+    _value_: Any
+    _ignore_: str | list[str]
+    _order_: str
+    __order__: str
+    @classmethod
+    def _missing_(cls, value: object) -> Any: ...
+    @staticmethod
+    def _generate_next_value_(
+        name: str, start: int, count: int, last_values: list[Any]
+    ) -> Any: ...
+    # It's not true that `__new__` will accept any argument type,
+    # so ideally we'd use `Any` to indicate that the argument type is inexpressible.
+    # However, using `Any` causes too many false-positives for those using mypy's `--disallow-any-expr`
+    # (see #7752, #2539, mypy/#5788),
+    # and in practice using `object` here has the same effect as using `Any`.
+    def __new__(cls, value: object) -> Self: ...
+    def __dir__(self) -> list[str]: ...
+    def __hash__(self) -> int: ...
+    def __format__(self, format_spec: str) -> str: ...
+    def __reduce_ex__(self, proto: Unused) -> tuple[Any, ...]: ...
+    if sys.version_info >= (3, 11):
+        def __copy__(self) -> Self: ...
+        def __deepcopy__(self, memo: Any) -> Self: ...
+    if sys.version_info >= (3, 12):
+        @classmethod
+        def __signature__(cls) -> str: ...
+
+if sys.version_info >= (3, 11):
+    class ReprEnum(Enum): ...
+
+if sys.version_info >= (3, 11):
+    _IntEnumBase = ReprEnum
+else:
+    _IntEnumBase = Enum
+
+class IntEnum(int, _IntEnumBase):
+    _value_: int
+    @_magic_enum_attr
+    def value(self) -> int: ...
+    def __new__(cls, value: int) -> Self: ...
+
+def unique(enumeration: _EnumerationT) -> _EnumerationT: ...
+
+_auto_null: Any
+
+class Flag(Enum):
+    _name_: str | None  # type: ignore[assignment]
+    _value_: int
+    @_magic_enum_attr
+    def name(self) -> str | None: ...  # type: ignore[override]
+    @_magic_enum_attr
+    def value(self) -> int: ...
+    def __contains__(self, other: Self) -> bool: ...
+    def __bool__(self) -> bool: ...
+    def __or__(self, other: Self) -> Self: ...
+    def __and__(self, other: Self) -> Self: ...
+    def __xor__(self, other: Self) -> Self: ...
+    def __invert__(self) -> Self: ...
+    if sys.version_info >= (3, 11):
+        def __iter__(self) -> Iterator[Self]: ...
+        def __len__(self) -> int: ...
+        __ror__ = __or__
+        __rand__ = __and__
+        __rxor__ = __xor__
+
+if sys.version_info >= (3, 11):
+    class StrEnum(str, ReprEnum):
+        def __new__(cls, value: str) -> Self: ...
+        _value_: str
+        @_magic_enum_attr
+        def value(self) -> str: ...
+        @staticmethod
+        def _generate_next_value_(
+            name: str, start: int, count: int, last_values: list[str]
+        ) -> str: ...
+
+    class EnumCheck(StrEnum):
+        CONTINUOUS: str
+        NAMED_FLAGS: str
+        UNIQUE: str
+
+    CONTINUOUS = EnumCheck.CONTINUOUS
+    NAMED_FLAGS = EnumCheck.NAMED_FLAGS
+    UNIQUE = EnumCheck.UNIQUE
+
+    class verify:
+        def __init__(self, *checks: EnumCheck) -> None: ...
+        def __call__(self, enumeration: _EnumerationT) -> _EnumerationT: ...
+
+    class FlagBoundary(StrEnum):
+        STRICT: str
+        CONFORM: str
+        EJECT: str
+        KEEP: str
+
+    STRICT = FlagBoundary.STRICT
+    CONFORM = FlagBoundary.CONFORM
+    EJECT = FlagBoundary.EJECT
+    KEEP = FlagBoundary.KEEP
+
+    def global_str(self: Enum) -> str: ...
+    def global_enum(cls: _EnumerationT, update_str: bool = False) -> _EnumerationT: ...
+    def global_enum_repr(self: Enum) -> str: ...
+    def global_flag_repr(self: Flag) -> str: ...
+
+if sys.version_info >= (3, 11):
+    # The body of the class is the same, but the base classes are different.
+    class IntFlag(int, ReprEnum, Flag, boundary=KEEP):  # type: ignore[misc]  # complaints about incompatible bases
+        def __new__(cls, value: int) -> Self: ...
+        def __or__(self, other: int) -> Self: ...
+        def __and__(self, other: int) -> Self: ...
+        def __xor__(self, other: int) -> Self: ...
+        __ror__ = __or__
+        __rand__ = __and__
+        __rxor__ = __xor__
+
+else:
+    class IntFlag(int, Flag):  # type: ignore[misc]  # complaints about incompatible bases
+        def __new__(cls, value: int) -> Self: ...
+        def __or__(self, other: int) -> Self: ...
+        def __and__(self, other: int) -> Self: ...
+        def __xor__(self, other: int) -> Self: ...
+        __ror__ = __or__
+        __rand__ = __and__
+        __rxor__ = __xor__
+
+# subclassing IntFlag so it picks up all implemented base functions, best modeling behavior of enum.auto()
+class auto(IntFlag):
+    _value_: Any
+    @_magic_enum_attr
+    def value(self) -> Any: ...
+    def __new__(cls) -> Self: ...
+
+if sys.version_info >= (3, 11):
+    def pickle_by_global_name(self: Enum, proto: int) -> str: ...
+    def pickle_by_enum_name(
+        self: _EnumMemberT, proto: int
+    ) -> tuple[Callable[..., Any], tuple[type[_EnumMemberT], str]]: ...