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

jaclang/vendor/mypy/typeshed/stdlib/asyncio/streams.pyi

@@ -0,0 +1,172 @@
+import ssl
+import sys
+from _typeshed import StrPath
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequence
+from typing import Any, SupportsIndex
+from typing_extensions import Self, TypeAlias
+
+from . import events, protocols, transports
+from .base_events import Server
+
+if sys.platform == "win32":
+    __all__ = (
+        "StreamReader",
+        "StreamWriter",
+        "StreamReaderProtocol",
+        "open_connection",
+        "start_server",
+    )
+else:
+    __all__ = (
+        "StreamReader",
+        "StreamWriter",
+        "StreamReaderProtocol",
+        "open_connection",
+        "start_server",
+        "open_unix_connection",
+        "start_unix_server",
+    )
+
+_ClientConnectedCallback: TypeAlias = Callable[
+    [StreamReader, StreamWriter], Awaitable[None] | None
+]
+
+if sys.version_info >= (3, 10):
+    async def open_connection(
+        host: str | None = None,
+        port: int | str | None = None,
+        *,
+        limit: int = 65536,
+        ssl_handshake_timeout: float | None = ...,
+        **kwds: Any,
+    ) -> tuple[StreamReader, StreamWriter]: ...
+    async def start_server(
+        client_connected_cb: _ClientConnectedCallback,
+        host: str | Sequence[str] | None = None,
+        port: int | str | None = None,
+        *,
+        limit: int = 65536,
+        ssl_handshake_timeout: float | None = ...,
+        **kwds: Any,
+    ) -> Server: ...
+
+else:
+    async def open_connection(
+        host: str | None = None,
+        port: int | str | None = None,
+        *,
+        loop: events.AbstractEventLoop | None = None,
+        limit: int = 65536,
+        ssl_handshake_timeout: float | None = ...,
+        **kwds: Any,
+    ) -> tuple[StreamReader, StreamWriter]: ...
+    async def start_server(
+        client_connected_cb: _ClientConnectedCallback,
+        host: str | None = None,
+        port: int | str | None = None,
+        *,
+        loop: events.AbstractEventLoop | None = None,
+        limit: int = 65536,
+        ssl_handshake_timeout: float | None = ...,
+        **kwds: Any,
+    ) -> Server: ...
+
+if sys.platform != "win32":
+    if sys.version_info >= (3, 10):
+        async def open_unix_connection(
+            path: StrPath | None = None, *, limit: int = 65536, **kwds: Any
+        ) -> tuple[StreamReader, StreamWriter]: ...
+        async def start_unix_server(
+            client_connected_cb: _ClientConnectedCallback,
+            path: StrPath | None = None,
+            *,
+            limit: int = 65536,
+            **kwds: Any,
+        ) -> Server: ...
+    else:
+        async def open_unix_connection(
+            path: StrPath | None = None,
+            *,
+            loop: events.AbstractEventLoop | None = None,
+            limit: int = 65536,
+            **kwds: Any,
+        ) -> tuple[StreamReader, StreamWriter]: ...
+        async def start_unix_server(
+            client_connected_cb: _ClientConnectedCallback,
+            path: StrPath | None = None,
+            *,
+            loop: events.AbstractEventLoop | None = None,
+            limit: int = 65536,
+            **kwds: Any,
+        ) -> Server: ...
+
+class FlowControlMixin(protocols.Protocol):
+    def __init__(self, loop: events.AbstractEventLoop | None = None) -> None: ...
+
+class StreamReaderProtocol(FlowControlMixin, protocols.Protocol):
+    def __init__(
+        self,
+        stream_reader: StreamReader,
+        client_connected_cb: _ClientConnectedCallback | None = None,
+        loop: events.AbstractEventLoop | None = None,
+    ) -> None: ...
+    def __del__(self) -> None: ...
+
+class StreamWriter:
+    def __init__(
+        self,
+        transport: transports.WriteTransport,
+        protocol: protocols.BaseProtocol,
+        reader: StreamReader | None,
+        loop: events.AbstractEventLoop,
+    ) -> None: ...
+    @property
+    def transport(self) -> transports.WriteTransport: ...
+    def write(self, data: bytes | bytearray | memoryview) -> None: ...
+    def writelines(self, data: Iterable[bytes | bytearray | memoryview]) -> None: ...
+    def write_eof(self) -> None: ...
+    def can_write_eof(self) -> bool: ...
+    def close(self) -> None: ...
+    def is_closing(self) -> bool: ...
+    async def wait_closed(self) -> None: ...
+    def get_extra_info(self, name: str, default: Any = None) -> Any: ...
+    async def drain(self) -> None: ...
+    if sys.version_info >= (3, 12):
+        async def start_tls(
+            self,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+            ssl_shutdown_timeout: float | None = None,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
+        async def start_tls(
+            self,
+            sslcontext: ssl.SSLContext,
+            *,
+            server_hostname: str | None = None,
+            ssl_handshake_timeout: float | None = None,
+        ) -> None: ...
+    if sys.version_info >= (3, 11):
+        def __del__(self) -> None: ...
+
+class StreamReader(AsyncIterator[bytes]):
+    def __init__(
+        self, limit: int = 65536, loop: events.AbstractEventLoop | None = None
+    ) -> None: ...
+    def exception(self) -> Exception: ...
+    def set_exception(self, exc: Exception) -> None: ...
+    def set_transport(self, transport: transports.BaseTransport) -> None: ...
+    def feed_eof(self) -> None: ...
+    def at_eof(self) -> bool: ...
+    def feed_data(self, data: Iterable[SupportsIndex]) -> None: ...
+    async def readline(self) -> bytes: ...
+    # Can be any buffer that supports len(); consider changing to a Protocol if PEP 688 is accepted
+    async def readuntil(
+        self, separator: bytes | bytearray | memoryview = b"\n"
+    ) -> bytes: ...
+    async def read(self, n: int = -1) -> bytes: ...
+    async def readexactly(self, n: int) -> bytes: ...
+    def __aiter__(self) -> Self: ...
+    async def __anext__(self) -> bytes: ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/subprocess.pyi

@@ -0,0 +1,234 @@
+import subprocess
+import sys
+from _typeshed import StrOrBytesPath
+from asyncio import events, protocols, streams, transports
+from collections.abc import Callable, Collection
+from typing import IO, Any, Literal
+
+__all__ = ("create_subprocess_exec", "create_subprocess_shell")
+
+PIPE: int
+STDOUT: int
+DEVNULL: int
+
+class SubprocessStreamProtocol(streams.FlowControlMixin, protocols.SubprocessProtocol):
+    stdin: streams.StreamWriter | None
+    stdout: streams.StreamReader | None
+    stderr: streams.StreamReader | None
+    def __init__(self, limit: int, loop: events.AbstractEventLoop) -> None: ...
+    def pipe_data_received(self, fd: int, data: bytes | str) -> None: ...
+
+class Process:
+    stdin: streams.StreamWriter | None
+    stdout: streams.StreamReader | None
+    stderr: streams.StreamReader | None
+    pid: int
+    def __init__(
+        self,
+        transport: transports.BaseTransport,
+        protocol: protocols.BaseProtocol,
+        loop: events.AbstractEventLoop,
+    ) -> None: ...
+    @property
+    def returncode(self) -> int | None: ...
+    async def wait(self) -> int: ...
+    def send_signal(self, signal: int) -> None: ...
+    def terminate(self) -> None: ...
+    def kill(self) -> None: ...
+    async def communicate(
+        self, input: bytes | bytearray | memoryview | None = None
+    ) -> tuple[bytes, bytes]: ...
+
+if sys.version_info >= (3, 11):
+    async def create_subprocess_shell(
+        cmd: str | bytes,
+        stdin: int | IO[Any] | None = None,
+        stdout: int | IO[Any] | None = None,
+        stderr: int | IO[Any] | None = None,
+        limit: int = 65536,
+        *,
+        # These parameters are forced to these values by BaseEventLoop.subprocess_shell
+        universal_newlines: Literal[False] = False,
+        shell: Literal[True] = True,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        # These parameters are taken by subprocess.Popen, which this ultimately delegates to
+        executable: StrOrBytesPath | None = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        cwd: StrOrBytesPath | None = None,
+        env: subprocess._ENV | None = None,
+        startupinfo: Any | None = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        group: None | str | int = None,
+        extra_groups: None | Collection[str | int] = None,
+        user: None | str | int = None,
+        umask: int = -1,
+        process_group: int | None = None,
+        pipesize: int = -1,
+    ) -> Process: ...
+    async def create_subprocess_exec(
+        program: StrOrBytesPath,
+        *args: StrOrBytesPath,
+        stdin: int | IO[Any] | None = None,
+        stdout: int | IO[Any] | None = None,
+        stderr: int | IO[Any] | None = None,
+        limit: int = 65536,
+        # These parameters are forced to these values by BaseEventLoop.subprocess_exec
+        universal_newlines: Literal[False] = False,
+        shell: Literal[False] = False,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        # These parameters are taken by subprocess.Popen, which this ultimately delegates to
+        executable: StrOrBytesPath | None = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        cwd: StrOrBytesPath | None = None,
+        env: subprocess._ENV | None = None,
+        startupinfo: Any | None = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        group: None | str | int = None,
+        extra_groups: None | Collection[str | int] = None,
+        user: None | str | int = None,
+        umask: int = -1,
+        process_group: int | None = None,
+        pipesize: int = -1,
+    ) -> Process: ...
+
+elif sys.version_info >= (3, 10):
+    async def create_subprocess_shell(
+        cmd: str | bytes,
+        stdin: int | IO[Any] | None = None,
+        stdout: int | IO[Any] | None = None,
+        stderr: int | IO[Any] | None = None,
+        limit: int = 65536,
+        *,
+        # These parameters are forced to these values by BaseEventLoop.subprocess_shell
+        universal_newlines: Literal[False] = False,
+        shell: Literal[True] = True,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        # These parameters are taken by subprocess.Popen, which this ultimately delegates to
+        executable: StrOrBytesPath | None = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        cwd: StrOrBytesPath | None = None,
+        env: subprocess._ENV | None = None,
+        startupinfo: Any | None = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        group: None | str | int = None,
+        extra_groups: None | Collection[str | int] = None,
+        user: None | str | int = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> Process: ...
+    async def create_subprocess_exec(
+        program: StrOrBytesPath,
+        *args: StrOrBytesPath,
+        stdin: int | IO[Any] | None = None,
+        stdout: int | IO[Any] | None = None,
+        stderr: int | IO[Any] | None = None,
+        limit: int = 65536,
+        # These parameters are forced to these values by BaseEventLoop.subprocess_exec
+        universal_newlines: Literal[False] = False,
+        shell: Literal[False] = False,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        # These parameters are taken by subprocess.Popen, which this ultimately delegates to
+        executable: StrOrBytesPath | None = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        cwd: StrOrBytesPath | None = None,
+        env: subprocess._ENV | None = None,
+        startupinfo: Any | None = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        group: None | str | int = None,
+        extra_groups: None | Collection[str | int] = None,
+        user: None | str | int = None,
+        umask: int = -1,
+        pipesize: int = -1,
+    ) -> Process: ...
+
+else:  # >= 3.9
+    async def create_subprocess_shell(
+        cmd: str | bytes,
+        stdin: int | IO[Any] | None = None,
+        stdout: int | IO[Any] | None = None,
+        stderr: int | IO[Any] | None = None,
+        loop: events.AbstractEventLoop | None = None,
+        limit: int = 65536,
+        *,
+        # These parameters are forced to these values by BaseEventLoop.subprocess_shell
+        universal_newlines: Literal[False] = False,
+        shell: Literal[True] = True,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        # These parameters are taken by subprocess.Popen, which this ultimately delegates to
+        executable: StrOrBytesPath | None = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        cwd: StrOrBytesPath | None = None,
+        env: subprocess._ENV | None = None,
+        startupinfo: Any | None = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        group: None | str | int = None,
+        extra_groups: None | Collection[str | int] = None,
+        user: None | str | int = None,
+        umask: int = -1,
+    ) -> Process: ...
+    async def create_subprocess_exec(
+        program: StrOrBytesPath,
+        *args: StrOrBytesPath,
+        stdin: int | IO[Any] | None = None,
+        stdout: int | IO[Any] | None = None,
+        stderr: int | IO[Any] | None = None,
+        loop: events.AbstractEventLoop | None = None,
+        limit: int = 65536,
+        # These parameters are forced to these values by BaseEventLoop.subprocess_exec
+        universal_newlines: Literal[False] = False,
+        shell: Literal[False] = False,
+        bufsize: Literal[0] = 0,
+        encoding: None = None,
+        errors: None = None,
+        text: Literal[False] | None = None,
+        # These parameters are taken by subprocess.Popen, which this ultimately delegates to
+        executable: StrOrBytesPath | None = None,
+        preexec_fn: Callable[[], Any] | None = None,
+        close_fds: bool = True,
+        cwd: StrOrBytesPath | None = None,
+        env: subprocess._ENV | None = None,
+        startupinfo: Any | None = None,
+        creationflags: int = 0,
+        restore_signals: bool = True,
+        start_new_session: bool = False,
+        pass_fds: Collection[int] = ...,
+        group: None | str | int = None,
+        extra_groups: None | Collection[str | int] = None,
+        user: None | str | int = None,
+        umask: int = -1,
+    ) -> Process: ...

jaclang/vendor/mypy/typeshed/stdlib/asyncio/taskgroups.pyi

@@ -0,0 +1,36 @@
+import sys
+from contextvars import Context
+from types import TracebackType
+from typing import Any, TypeVar
+from typing_extensions import Self
+
+from . import _CoroutineLike
+from .events import AbstractEventLoop
+from .tasks import Task
+
+if sys.version_info >= (3, 12):
+    __all__ = ("TaskGroup",)
+else:
+    __all__ = ["TaskGroup"]
+
+_T = TypeVar("_T")
+
+class TaskGroup:
+    _loop: AbstractEventLoop | None
+    _tasks: set[Task[Any]]
+
+    async def __aenter__(self) -> Self: ...
+    async def __aexit__(
+        self,
+        et: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None: ...
+    def create_task(
+        self,
+        coro: _CoroutineLike[_T],
+        *,
+        name: str | None = None,
+        context: Context | None = None
+    ) -> Task[_T]: ...
+    def _on_task_done(self, task: Task[object]) -> None: ...