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

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

@@ -0,0 +1,274 @@
+import abc
+import sys
+from _typeshed import FileDescriptorOrPath, Unused
+from abc import abstractmethod
+from collections.abc import (
+    AsyncGenerator,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Generator,
+    Iterator,
+)
+from types import TracebackType
+from typing import IO, Any, Generic, Protocol, TypeVar, overload, runtime_checkable
+from typing_extensions import ParamSpec, Self, TypeAlias
+
+__all__ = [
+    "contextmanager",
+    "closing",
+    "AbstractContextManager",
+    "ContextDecorator",
+    "ExitStack",
+    "redirect_stdout",
+    "redirect_stderr",
+    "suppress",
+    "AbstractAsyncContextManager",
+    "AsyncExitStack",
+    "asynccontextmanager",
+    "nullcontext",
+]
+
+if sys.version_info >= (3, 10):
+    __all__ += ["aclosing"]
+
+if sys.version_info >= (3, 11):
+    __all__ += ["chdir"]
+
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
+_T_io = TypeVar("_T_io", bound=IO[str] | None)
+_F = TypeVar("_F", bound=Callable[..., Any])
+_P = ParamSpec("_P")
+
+_ExitFunc: TypeAlias = Callable[
+    [type[BaseException] | None, BaseException | None, TracebackType | None],
+    bool | None,
+]
+_CM_EF = TypeVar("_CM_EF", bound=AbstractContextManager[Any] | _ExitFunc)
+
+@runtime_checkable
+class AbstractContextManager(Protocol[_T_co]):
+    def __enter__(self) -> _T_co: ...
+    @abstractmethod
+    def __exit__(
+        self,
+        __exc_type: type[BaseException] | None,
+        __exc_value: BaseException | None,
+        __traceback: TracebackType | None,
+    ) -> bool | None: ...
+
+@runtime_checkable
+class AbstractAsyncContextManager(Protocol[_T_co]):
+    async def __aenter__(self) -> _T_co: ...
+    @abstractmethod
+    async def __aexit__(
+        self,
+        __exc_type: type[BaseException] | None,
+        __exc_value: BaseException | None,
+        __traceback: TracebackType | None,
+    ) -> bool | None: ...
+
+class ContextDecorator:
+    def __call__(self, func: _F) -> _F: ...
+
+class _GeneratorContextManager(AbstractContextManager[_T_co], ContextDecorator):
+    # __init__ and all instance attributes are actually inherited from _GeneratorContextManagerBase
+    # _GeneratorContextManagerBase is more trouble than it's worth to include in the stub; see #6676
+    def __init__(
+        self,
+        func: Callable[..., Iterator[_T_co]],
+        args: tuple[Any, ...],
+        kwds: dict[str, Any],
+    ) -> None: ...
+    gen: Generator[_T_co, Any, Any]
+    func: Callable[..., Generator[_T_co, Any, Any]]
+    args: tuple[Any, ...]
+    kwds: dict[str, Any]
+    if sys.version_info >= (3, 9):
+        def __exit__(
+            self,
+            typ: type[BaseException] | None,
+            value: BaseException | None,
+            traceback: TracebackType | None,
+        ) -> bool | None: ...
+    else:
+        def __exit__(
+            self,
+            type: type[BaseException] | None,
+            value: BaseException | None,
+            traceback: TracebackType | None,
+        ) -> bool | None: ...
+
+def contextmanager(
+    func: Callable[_P, Iterator[_T_co]]
+) -> Callable[_P, _GeneratorContextManager[_T_co]]: ...
+
+if sys.version_info >= (3, 10):
+    _AF = TypeVar("_AF", bound=Callable[..., Awaitable[Any]])
+
+    class AsyncContextDecorator:
+        def __call__(self, func: _AF) -> _AF: ...
+
+    class _AsyncGeneratorContextManager(
+        AbstractAsyncContextManager[_T_co], AsyncContextDecorator
+    ):
+        # __init__ and these attributes are actually defined in the base class _GeneratorContextManagerBase,
+        # which is more trouble than it's worth to include in the stub (see #6676)
+        def __init__(
+            self,
+            func: Callable[..., AsyncIterator[_T_co]],
+            args: tuple[Any, ...],
+            kwds: dict[str, Any],
+        ) -> None: ...
+        gen: AsyncGenerator[_T_co, Any]
+        func: Callable[..., AsyncGenerator[_T_co, Any]]
+        args: tuple[Any, ...]
+        kwds: dict[str, Any]
+        async def __aexit__(
+            self,
+            typ: type[BaseException] | None,
+            value: BaseException | None,
+            traceback: TracebackType | None,
+        ) -> bool | None: ...
+
+else:
+    class _AsyncGeneratorContextManager(AbstractAsyncContextManager[_T_co]):
+        def __init__(
+            self,
+            func: Callable[..., AsyncIterator[_T_co]],
+            args: tuple[Any, ...],
+            kwds: dict[str, Any],
+        ) -> None: ...
+        gen: AsyncGenerator[_T_co, Any]
+        func: Callable[..., AsyncGenerator[_T_co, Any]]
+        args: tuple[Any, ...]
+        kwds: dict[str, Any]
+        async def __aexit__(
+            self,
+            typ: type[BaseException] | None,
+            value: BaseException | None,
+            traceback: TracebackType | None,
+        ) -> bool | None: ...
+
+def asynccontextmanager(
+    func: Callable[_P, AsyncIterator[_T_co]]
+) -> Callable[_P, _AsyncGeneratorContextManager[_T_co]]: ...
+
+class _SupportsClose(Protocol):
+    def close(self) -> object: ...
+
+_SupportsCloseT = TypeVar("_SupportsCloseT", bound=_SupportsClose)
+
+class closing(AbstractContextManager[_SupportsCloseT]):
+    def __init__(self, thing: _SupportsCloseT) -> None: ...
+    def __exit__(self, *exc_info: Unused) -> None: ...
+
+if sys.version_info >= (3, 10):
+    class _SupportsAclose(Protocol):
+        def aclose(self) -> Awaitable[object]: ...
+
+    _SupportsAcloseT = TypeVar("_SupportsAcloseT", bound=_SupportsAclose)
+
+    class aclosing(AbstractAsyncContextManager[_SupportsAcloseT]):
+        def __init__(self, thing: _SupportsAcloseT) -> None: ...
+        async def __aexit__(self, *exc_info: Unused) -> None: ...
+
+class suppress(AbstractContextManager[None]):
+    def __init__(self, *exceptions: type[BaseException]) -> None: ...
+    def __exit__(
+        self,
+        exctype: type[BaseException] | None,
+        excinst: BaseException | None,
+        exctb: TracebackType | None,
+    ) -> bool: ...
+
+class _RedirectStream(AbstractContextManager[_T_io]):
+    def __init__(self, new_target: _T_io) -> None: ...
+    def __exit__(
+        self,
+        exctype: type[BaseException] | None,
+        excinst: BaseException | None,
+        exctb: TracebackType | None,
+    ) -> None: ...
+
+class redirect_stdout(_RedirectStream[_T_io]): ...
+class redirect_stderr(_RedirectStream[_T_io]): ...
+
+# In reality this is a subclass of `AbstractContextManager`;
+# see #7961 for why we don't do that in the stub
+class ExitStack(metaclass=abc.ABCMeta):
+    def enter_context(self, cm: AbstractContextManager[_T]) -> _T: ...
+    def push(self, exit: _CM_EF) -> _CM_EF: ...
+    def callback(
+        self, __callback: Callable[_P, _T], *args: _P.args, **kwds: _P.kwargs
+    ) -> Callable[_P, _T]: ...
+    def pop_all(self) -> Self: ...
+    def close(self) -> None: ...
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self,
+        __exc_type: type[BaseException] | None,
+        __exc_value: BaseException | None,
+        __traceback: TracebackType | None,
+    ) -> bool: ...
+
+_ExitCoroFunc: TypeAlias = Callable[
+    [type[BaseException] | None, BaseException | None, TracebackType | None],
+    Awaitable[bool | None],
+]
+_ACM_EF = TypeVar("_ACM_EF", bound=AbstractAsyncContextManager[Any] | _ExitCoroFunc)
+
+# In reality this is a subclass of `AbstractAsyncContextManager`;
+# see #7961 for why we don't do that in the stub
+class AsyncExitStack(metaclass=abc.ABCMeta):
+    def enter_context(self, cm: AbstractContextManager[_T]) -> _T: ...
+    async def enter_async_context(self, cm: AbstractAsyncContextManager[_T]) -> _T: ...
+    def push(self, exit: _CM_EF) -> _CM_EF: ...
+    def push_async_exit(self, exit: _ACM_EF) -> _ACM_EF: ...
+    def callback(
+        self, __callback: Callable[_P, _T], *args: _P.args, **kwds: _P.kwargs
+    ) -> Callable[_P, _T]: ...
+    def push_async_callback(
+        self, __callback: Callable[_P, Awaitable[_T]], *args: _P.args, **kwds: _P.kwargs
+    ) -> Callable[_P, Awaitable[_T]]: ...
+    def pop_all(self) -> Self: ...
+    async def aclose(self) -> None: ...
+    async def __aenter__(self) -> Self: ...
+    async def __aexit__(
+        self,
+        __exc_type: type[BaseException] | None,
+        __exc_value: BaseException | None,
+        __traceback: TracebackType | None,
+    ) -> bool: ...
+
+if sys.version_info >= (3, 10):
+    class nullcontext(AbstractContextManager[_T], AbstractAsyncContextManager[_T]):
+        enter_result: _T
+        @overload
+        def __init__(self: nullcontext[None], enter_result: None = None) -> None: ...
+        @overload
+        def __init__(self: nullcontext[_T], enter_result: _T) -> None: ...
+        def __enter__(self) -> _T: ...
+        def __exit__(self, *exctype: Unused) -> None: ...
+        async def __aenter__(self) -> _T: ...
+        async def __aexit__(self, *exctype: Unused) -> None: ...
+
+else:
+    class nullcontext(AbstractContextManager[_T]):
+        enter_result: _T
+        @overload
+        def __init__(self: nullcontext[None], enter_result: None = None) -> None: ...
+        @overload
+        def __init__(self: nullcontext[_T], enter_result: _T) -> None: ...
+        def __enter__(self) -> _T: ...
+        def __exit__(self, *exctype: Unused) -> None: ...
+
+if sys.version_info >= (3, 11):
+    _T_fd_or_any_path = TypeVar("_T_fd_or_any_path", bound=FileDescriptorOrPath)
+
+    class chdir(AbstractContextManager[None], Generic[_T_fd_or_any_path]):
+        path: _T_fd_or_any_path
+        def __init__(self, path: _T_fd_or_any_path) -> None: ...
+        def __enter__(self) -> None: ...
+        def __exit__(self, *excinfo: Unused) -> None: ...

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

@@ -0,0 +1,67 @@
+import sys
+from collections.abc import Callable, Iterator, Mapping
+from typing import Any, ClassVar, Generic, TypeVar, final, overload
+from typing_extensions import ParamSpec
+
+if sys.version_info >= (3, 9):
+    from types import GenericAlias
+
+__all__ = ("Context", "ContextVar", "Token", "copy_context")
+
+_T = TypeVar("_T")
+_D = TypeVar("_D")
+_P = ParamSpec("_P")
+
+@final
+class ContextVar(Generic[_T]):
+    @overload
+    def __init__(self, name: str) -> None: ...
+    @overload
+    def __init__(self, name: str, *, default: _T) -> None: ...
+    def __hash__(self) -> int: ...
+    @property
+    def name(self) -> str: ...
+    @overload
+    def get(self) -> _T: ...
+    @overload
+    def get(self, __default: _T) -> _T: ...
+    @overload
+    def get(self, __default: _D) -> _D | _T: ...
+    def set(self, __value: _T) -> Token[_T]: ...
+    def reset(self, __token: Token[_T]) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+@final
+class Token(Generic[_T]):
+    @property
+    def var(self) -> ContextVar[_T]: ...
+    @property
+    def old_value(
+        self,
+    ) -> Any: ...  # returns either _T or MISSING, but that's hard to express
+    MISSING: ClassVar[object]
+    if sys.version_info >= (3, 9):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+def copy_context() -> Context: ...
+
+# It doesn't make sense to make this generic, because for most Contexts each ContextVar will have
+# a different value.
+@final
+class Context(Mapping[ContextVar[Any], Any]):
+    def __init__(self) -> None: ...
+    @overload
+    def get(self, __key: ContextVar[_T], __default: None = None) -> _T | None: ...
+    @overload
+    def get(self, __key: ContextVar[_T], __default: _T) -> _T: ...
+    @overload
+    def get(self, __key: ContextVar[_T], __default: _D) -> _T | _D: ...
+    def run(
+        self, callable: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs
+    ) -> _T: ...
+    def copy(self) -> Context: ...
+    def __getitem__(self, __key: ContextVar[_T]) -> _T: ...
+    def __iter__(self) -> Iterator[ContextVar[Any]]: ...
+    def __len__(self) -> int: ...
+    def __eq__(self, __value: object) -> bool: ...

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

@@ -0,0 +1,16 @@
+from typing import Any, TypeVar
+
+__all__ = ["Error", "copy", "deepcopy"]
+
+_T = TypeVar("_T")
+
+# None in CPython but non-None in Jython
+PyStringMap: Any
+
+# Note: memo and _nil are internal kwargs.
+def deepcopy(x: _T, memo: dict[int, Any] | None = None, _nil: Any = []) -> _T: ...
+def copy(x: _T) -> _T: ...
+
+class Error(Exception): ...
+
+error = Error

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

@@ -0,0 +1,32 @@
+from collections.abc import Callable, Hashable
+from typing import Any, SupportsInt, TypeVar
+from typing_extensions import TypeAlias
+
+_T = TypeVar("_T")
+_Reduce: TypeAlias = (
+    tuple[Callable[..., _T], tuple[Any, ...]]
+    | tuple[Callable[..., _T], tuple[Any, ...], Any | None]
+)
+
+__all__ = [
+    "pickle",
+    "constructor",
+    "add_extension",
+    "remove_extension",
+    "clear_extension_cache",
+]
+
+def pickle(
+    ob_type: type[_T],
+    pickle_function: Callable[[_T], str | _Reduce[_T]],
+    constructor_ob: Callable[[_Reduce[_T]], _T] | None = None,
+) -> None: ...
+def constructor(object: Callable[[_Reduce[_T]], _T]) -> None: ...
+def add_extension(module: Hashable, name: Hashable, code: SupportsInt) -> None: ...
+def remove_extension(module: Hashable, name: Hashable, code: int) -> None: ...
+def clear_extension_cache() -> None: ...
+
+_DispatchTableType: TypeAlias = dict[
+    type, Callable[[Any], str | _Reduce[Any]]
+]  # imported by multiprocessing.reduction
+dispatch_table: _DispatchTableType  # undocumented

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

@@ -0,0 +1,12 @@
+import sys
+
+if sys.platform != "win32":
+    class _Method: ...
+    METHOD_CRYPT: _Method
+    METHOD_MD5: _Method
+    METHOD_SHA256: _Method
+    METHOD_SHA512: _Method
+    METHOD_BLOWFISH: _Method
+    methods: list[_Method]
+    def mksalt(method: _Method | None = None, *, rounds: int | None = None) -> str: ...
+    def crypt(word: str, salt: str | _Method | None = None) -> str: ...

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

@@ -0,0 +1,147 @@
+import sys
+
+# actually csv.Dialect is a different class to _csv.Dialect at runtime, but for typing purposes, they're identical
+from _csv import (
+    QUOTE_ALL as QUOTE_ALL,
+    QUOTE_MINIMAL as QUOTE_MINIMAL,
+    QUOTE_NONE as QUOTE_NONE,
+    QUOTE_NONNUMERIC as QUOTE_NONNUMERIC,
+    Dialect as Dialect,
+    Error as Error,
+    __version__ as __version__,
+    _DialectLike,
+    _QuotingType,
+    _reader,
+    _writer,
+    field_size_limit as field_size_limit,
+    get_dialect as get_dialect,
+    list_dialects as list_dialects,
+    reader as reader,
+    register_dialect as register_dialect,
+    unregister_dialect as unregister_dialect,
+    writer as writer,
+)
+
+if sys.version_info >= (3, 12):
+    from _csv import QUOTE_NOTNULL as QUOTE_NOTNULL, QUOTE_STRINGS as QUOTE_STRINGS
+
+from _typeshed import SupportsWrite
+from collections.abc import Collection, Iterable, Iterator, Mapping, Sequence
+from typing import Any, Generic, Literal, TypeVar, overload
+from typing_extensions import Self
+
+if sys.version_info >= (3, 12):
+    from types import GenericAlias
+
+__all__ = [
+    "QUOTE_MINIMAL",
+    "QUOTE_ALL",
+    "QUOTE_NONNUMERIC",
+    "QUOTE_NONE",
+    "Error",
+    "Dialect",
+    "__doc__",
+    "excel",
+    "excel_tab",
+    "field_size_limit",
+    "reader",
+    "writer",
+    "register_dialect",
+    "get_dialect",
+    "list_dialects",
+    "Sniffer",
+    "unregister_dialect",
+    "__version__",
+    "DictReader",
+    "DictWriter",
+    "unix_dialect",
+]
+if sys.version_info >= (3, 12):
+    __all__ += ["QUOTE_STRINGS", "QUOTE_NOTNULL"]
+
+_T = TypeVar("_T")
+
+class excel(Dialect): ...
+class excel_tab(excel): ...
+class unix_dialect(Dialect): ...
+
+class DictReader(Iterator[dict[_T | Any, str | Any]], Generic[_T]):
+    fieldnames: Sequence[_T] | None
+    restkey: _T | None
+    restval: str | Any | None
+    reader: _reader
+    dialect: _DialectLike
+    line_num: int
+    @overload
+    def __init__(
+        self,
+        f: Iterable[str],
+        fieldnames: Sequence[_T],
+        restkey: _T | None = None,
+        restval: str | Any | None = None,
+        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,
+    ) -> None: ...
+    @overload
+    def __init__(
+        self: DictReader[str],
+        f: Iterable[str],
+        fieldnames: Sequence[str] | None = None,
+        restkey: str | None = None,
+        restval: str | None = None,
+        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,
+    ) -> None: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> dict[_T | Any, str | Any]: ...
+    if sys.version_info >= (3, 12):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+class DictWriter(Generic[_T]):
+    fieldnames: Collection[_T]
+    restval: Any | None
+    extrasaction: Literal["raise", "ignore"]
+    writer: _writer
+    def __init__(
+        self,
+        f: SupportsWrite[str],
+        fieldnames: Collection[_T],
+        restval: Any | None = "",
+        extrasaction: Literal["raise", "ignore"] = "raise",
+        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,
+    ) -> None: ...
+    def writeheader(self) -> Any: ...
+    def writerow(self, rowdict: Mapping[_T, Any]) -> Any: ...
+    def writerows(self, rowdicts: Iterable[Mapping[_T, Any]]) -> None: ...
+    if sys.version_info >= (3, 12):
+        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+
+class Sniffer:
+    preferred: list[str]
+    def sniff(self, sample: str, delimiters: str | None = None) -> type[Dialect]: ...
+    def has_header(self, sample: str) -> bool: ...