@ajksunkang-aios/kgraph-linux-x64 0.1.2 → 0.1.3

package/lib/site-packages/trio/_highlevel_ssl_helpers.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import ssl
+from typing import TYPE_CHECKING, NoReturn, TypeVar
+
+import trio
+
+from ._highlevel_open_tcp_stream import DEFAULT_DELAY
+
+T = TypeVar("T")
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from ._highlevel_socket import SocketStream
+
+
+# It might have been nice to take a ssl_protocols= argument here to set up
+# NPN/ALPN, but to do this we have to mutate the context object, which is OK
+# if it's one we created, but not OK if it's one that was passed in... and
+# the one major protocol using NPN/ALPN is HTTP/2, which mandates that you use
+# a specially configured SSLContext anyway! I also thought maybe we could copy
+# the given SSLContext and then mutate the copy, but it's no good as SSLContext
+# objects can't be copied: https://bugs.python.org/issue33023.
+# So... let's punt on that for now. Hopefully we'll be getting a new Python
+# TLS API soon and can revisit this then.
+async def open_ssl_over_tcp_stream(
+    host: str | bytes,
+    port: int,
+    *,
+    https_compatible: bool = False,
+    ssl_context: ssl.SSLContext | None = None,
+    happy_eyeballs_delay: float | None = DEFAULT_DELAY,
+) -> trio.SSLStream[SocketStream]:
+    """Make a TLS-encrypted Connection to the given host and port over TCP.
+
+    This is a convenience wrapper that calls :func:`open_tcp_stream` and
+    wraps the result in an :class:`~trio.SSLStream`.
+
+    This function does not perform the TLS handshake; you can do it
+    manually by calling :meth:`~trio.SSLStream.do_handshake`, or else
+    it will be performed automatically the first time you send or receive
+    data.
+
+    Args:
+      host (bytes or str): The host to connect to. We require the server
+          to have a TLS certificate valid for this hostname.
+      port (int): The port to connect to.
+      https_compatible (bool): Set this to True if you're connecting to a web
+          server. See :class:`~trio.SSLStream` for details. Default:
+          False.
+      ssl_context (:class:`~ssl.SSLContext` or None): The SSL context to
+          use. If None (the default), :func:`ssl.create_default_context`
+          will be called to create a context.
+      happy_eyeballs_delay (float): See :func:`open_tcp_stream`.
+
+    Returns:
+      trio.SSLStream: the encrypted connection to the server.
+
+    """
+    tcp_stream = await trio.open_tcp_stream(
+        host,
+        port,
+        happy_eyeballs_delay=happy_eyeballs_delay,
+    )
+    if ssl_context is None:
+        ssl_context = ssl.create_default_context()
+
+        if hasattr(ssl, "OP_IGNORE_UNEXPECTED_EOF"):
+            ssl_context.options &= ~ssl.OP_IGNORE_UNEXPECTED_EOF
+
+    return trio.SSLStream(
+        tcp_stream,
+        ssl_context,
+        server_hostname=host,
+        https_compatible=https_compatible,
+    )
+
+
+async def open_ssl_over_tcp_listeners(
+    port: int,
+    ssl_context: ssl.SSLContext,
+    *,
+    host: str | bytes | None = None,
+    https_compatible: bool = False,
+    backlog: int | None = None,
+) -> list[trio.SSLListener[SocketStream]]:
+    """Start listening for SSL/TLS-encrypted TCP connections to the given port.
+
+    Args:
+      port (int): The port to listen on. See :func:`open_tcp_listeners`.
+      ssl_context (~ssl.SSLContext): The SSL context to use for all incoming
+          connections.
+      host (str, bytes, or None): The address to bind to; use ``None`` to bind
+          to the wildcard address. See :func:`open_tcp_listeners`.
+      https_compatible (bool): See :class:`~trio.SSLStream` for details.
+      backlog (int or None): See :func:`open_tcp_listeners` for details.
+
+    """
+    tcp_listeners = await trio.open_tcp_listeners(port, host=host, backlog=backlog)
+    ssl_listeners = [
+        trio.SSLListener(tcp_listener, ssl_context, https_compatible=https_compatible)
+        for tcp_listener in tcp_listeners
+    ]
+    return ssl_listeners
+
+
+async def serve_ssl_over_tcp(
+    handler: Callable[[trio.SSLStream[SocketStream]], Awaitable[object]],
+    port: int,
+    ssl_context: ssl.SSLContext,
+    *,
+    host: str | bytes | None = None,
+    https_compatible: bool = False,
+    backlog: int | None = None,
+    handler_nursery: trio.Nursery | None = None,
+    task_status: trio.TaskStatus[
+        list[trio.SSLListener[SocketStream]]
+    ] = trio.TASK_STATUS_IGNORED,
+) -> NoReturn:
+    """Listen for incoming TCP connections, and for each one start a task
+    running ``handler(stream)``.
+
+    This is a thin convenience wrapper around
+    :func:`open_ssl_over_tcp_listeners` and :func:`serve_listeners` – see them
+    for full details.
+
+    .. warning::
+
+       If ``handler`` raises an exception, then this function doesn't do
+       anything special to catch it – so by default the exception will
+       propagate out and crash your server. If you don't want this, then catch
+       exceptions inside your ``handler``, or use a ``handler_nursery`` object
+       that responds to exceptions in some other way.
+
+    When used with ``nursery.start`` you get back the newly opened listeners.
+    See the documentation for :func:`serve_tcp` for an example where this is
+    useful.
+
+    Args:
+      handler: The handler to start for each incoming connection. Passed to
+          :func:`serve_listeners`.
+
+      port (int): The port to listen on. Use 0 to let the kernel pick
+          an open port. Ultimately passed to :func:`open_tcp_listeners`.
+
+      ssl_context (~ssl.SSLContext): The SSL context to use for all incoming
+          connections. Passed to :func:`open_ssl_over_tcp_listeners`.
+
+      host (str, bytes, or None): The address to bind to; use ``None`` to bind
+          to the wildcard address. Ultimately passed to
+          :func:`open_tcp_listeners`.
+
+      https_compatible (bool): Set this to True if you want to use
+          "HTTPS-style" TLS. See :class:`~trio.SSLStream` for details.
+
+      backlog (int or None): See :class:`~trio.SSLStream` for details.
+
+      handler_nursery: The nursery to start handlers in, or None to use an
+          internal nursery. Passed to :func:`serve_listeners`.
+
+      task_status: This function can be used with ``nursery.start``.
+
+    Returns:
+      This function only returns when cancelled.
+
+    """
+    listeners = await trio.open_ssl_over_tcp_listeners(
+        port,
+        ssl_context,
+        host=host,
+        https_compatible=https_compatible,
+        backlog=backlog,
+    )
+    await trio.serve_listeners(
+        handler,
+        listeners,
+        handler_nursery=handler_nursery,
+        task_status=task_status,
+    )

package/lib/site-packages/trio/_path.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+from functools import partial, update_wrapper
+from inspect import cleandoc
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    BinaryIO,
+    ClassVar,
+    Concatenate,
+    Literal,
+    TypeVar,
+    overload,
+)
+
+from trio._file_io import AsyncIOWrapper, wrap_file
+from trio._util import final
+from trio.to_thread import run_sync
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable, Iterable
+    from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
+
+    from _typeshed import (
+        OpenBinaryMode,
+        OpenBinaryModeReading,
+        OpenBinaryModeUpdating,
+        OpenBinaryModeWriting,
+        OpenTextMode,
+    )
+    from typing_extensions import ParamSpec, Self
+
+    P = ParamSpec("P")
+
+    PathT = TypeVar("PathT", bound="Path")
+    T = TypeVar("T")
+
+
+def _wraps_async(  # type: ignore[explicit-any]
+    wrapped: Callable[..., object],
+) -> Callable[[Callable[P, T]], Callable[P, Awaitable[T]]]:
+    def decorator(fn: Callable[P, T]) -> Callable[P, Awaitable[T]]:
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            return await run_sync(partial(fn, *args, **kwargs))
+
+        update_wrapper(wrapper, wrapped)
+        if wrapped.__doc__:
+            module = wrapped.__module__
+            # these are exported specially from CPython's intersphinx inventory
+            module = module.replace("pathlib._local", "pathlib")
+            module = module.replace("pathlib._abc", "pathlib")
+
+            name = wrapped.__qualname__
+            name = name.replace(
+                "PathBase", "Path"
+            )  # I'm not sure why this is necessary
+
+            wrapper.__doc__ = (
+                f"Like :meth:`~{module}.{name}`, but async.\n"
+                f"\n"
+                f"{cleandoc(wrapped.__doc__)}\n"
+            )
+        return wrapper
+
+    return decorator
+
+
+def _wrap_method(
+    fn: Callable[Concatenate[pathlib.Path, P], T],
+) -> Callable[Concatenate[Path, P], Awaitable[T]]:
+    @_wraps_async(fn)
+    def wrapper(self: Path, /, *args: P.args, **kwargs: P.kwargs) -> T:
+        return fn(self._wrapped_cls(self), *args, **kwargs)
+
+    return wrapper
+
+
+def _wrap_method_path(
+    fn: Callable[Concatenate[pathlib.Path, P], pathlib.Path],
+) -> Callable[Concatenate[PathT, P], Awaitable[PathT]]:
+    @_wraps_async(fn)
+    def wrapper(self: PathT, /, *args: P.args, **kwargs: P.kwargs) -> PathT:
+        return self.__class__(fn(self._wrapped_cls(self), *args, **kwargs))
+
+    return wrapper
+
+
+def _wrap_method_path_iterable(
+    fn: Callable[Concatenate[pathlib.Path, P], Iterable[pathlib.Path]],
+) -> Callable[Concatenate[PathT, P], Awaitable[Iterable[PathT]]]:
+    @_wraps_async(fn)
+    def wrapper(self: PathT, /, *args: P.args, **kwargs: P.kwargs) -> Iterable[PathT]:
+        return map(self.__class__, [*fn(self._wrapped_cls(self), *args, **kwargs)])
+
+    if wrapper.__doc__:
+        wrapper.__doc__ += (
+            f"\n"
+            f"This is an async method that returns a synchronous iterator, so you\n"
+            f"use it like:\n"
+            f"\n"
+            f".. code:: python\n"
+            f"\n"
+            f"    for subpath in await mypath.{fn.__name__}():\n"
+            f"        ...\n"
+            f"\n"
+            f".. note::\n"
+            f"\n"
+            f"    The iterator is loaded into memory immediately during the initial\n"
+            f"    call (see `issue #501\n"
+            f"    <https://github.com/python-trio/trio/issues/501>`__ for discussion).\n"
+        )
+    return wrapper
+
+
+class Path(pathlib.PurePath):
+    """An async :class:`pathlib.Path` that executes blocking methods in :meth:`trio.to_thread.run_sync`.
+
+    Instantiating :class:`Path` returns a concrete platform-specific subclass, one of :class:`PosixPath` or
+    :class:`WindowsPath`.
+    """
+
+    __slots__ = ()
+
+    _wrapped_cls: ClassVar[type[pathlib.Path]]
+
+    def __new__(cls, *args: str | os.PathLike[str]) -> Self:
+        if cls is Path:
+            cls = WindowsPath if os.name == "nt" else PosixPath  # type: ignore[assignment]
+        return super().__new__(cls, *args)
+
+    @classmethod
+    @_wraps_async(pathlib.Path.cwd)
+    def cwd(cls) -> Self:
+        return cls(pathlib.Path.cwd())
+
+    @classmethod
+    @_wraps_async(pathlib.Path.home)
+    def home(cls) -> Self:
+        return cls(pathlib.Path.home())
+
+    @overload
+    async def open(
+        self,
+        mode: OpenTextMode = "r",
+        buffering: int = -1,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+    ) -> AsyncIOWrapper[TextIOWrapper]: ...
+
+    @overload
+    async def open(
+        self,
+        mode: OpenBinaryMode,
+        buffering: Literal[0],
+        encoding: None = None,
+        errors: None = None,
+        newline: None = None,
+    ) -> AsyncIOWrapper[FileIO]: ...
+
+    @overload
+    async def open(
+        self,
+        mode: OpenBinaryModeUpdating,
+        buffering: Literal[-1, 1] = -1,
+        encoding: None = None,
+        errors: None = None,
+        newline: None = None,
+    ) -> AsyncIOWrapper[BufferedRandom]: ...
+
+    @overload
+    async def open(
+        self,
+        mode: OpenBinaryModeWriting,
+        buffering: Literal[-1, 1] = -1,
+        encoding: None = None,
+        errors: None = None,
+        newline: None = None,
+    ) -> AsyncIOWrapper[BufferedWriter]: ...
+
+    @overload
+    async def open(
+        self,
+        mode: OpenBinaryModeReading,
+        buffering: Literal[-1, 1] = -1,
+        encoding: None = None,
+        errors: None = None,
+        newline: None = None,
+    ) -> AsyncIOWrapper[BufferedReader]: ...
+
+    @overload
+    async def open(
+        self,
+        mode: OpenBinaryMode,
+        buffering: int = -1,
+        encoding: None = None,
+        errors: None = None,
+        newline: None = None,
+    ) -> AsyncIOWrapper[BinaryIO]: ...
+
+    @overload
+    async def open(  # type: ignore[explicit-any]  # Any usage matches builtins.open().
+        self,
+        mode: str,
+        buffering: int = -1,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+    ) -> AsyncIOWrapper[IO[Any]]: ...
+
+    @_wraps_async(pathlib.Path.open)
+    def open(self, *args: Any, **kwargs: Any) -> AsyncIOWrapper[IO[Any]]:  # type: ignore[misc, explicit-any]  # Overload return mismatch.
+        return wrap_file(self._wrapped_cls(self).open(*args, **kwargs))
+
+    def __repr__(self) -> str:
+        return f"trio.Path({str(self)!r})"
+
+    stat = _wrap_method(pathlib.Path.stat)
+    chmod = _wrap_method(pathlib.Path.chmod)
+    exists = _wrap_method(pathlib.Path.exists)
+    glob = _wrap_method_path_iterable(pathlib.Path.glob)
+    rglob = _wrap_method_path_iterable(pathlib.Path.rglob)
+    is_dir = _wrap_method(pathlib.Path.is_dir)
+    is_file = _wrap_method(pathlib.Path.is_file)
+    is_symlink = _wrap_method(pathlib.Path.is_symlink)
+    is_socket = _wrap_method(pathlib.Path.is_socket)
+    is_fifo = _wrap_method(pathlib.Path.is_fifo)
+    is_block_device = _wrap_method(pathlib.Path.is_block_device)
+    is_char_device = _wrap_method(pathlib.Path.is_char_device)
+    if sys.version_info >= (3, 12):
+        is_junction = _wrap_method(pathlib.Path.is_junction)
+    iterdir = _wrap_method_path_iterable(pathlib.Path.iterdir)
+    lchmod = _wrap_method(pathlib.Path.lchmod)
+    lstat = _wrap_method(pathlib.Path.lstat)
+    mkdir = _wrap_method(pathlib.Path.mkdir)
+    if sys.platform != "win32":
+        owner = _wrap_method(pathlib.Path.owner)
+        group = _wrap_method(pathlib.Path.group)
+    if sys.platform != "win32" or sys.version_info >= (3, 12):
+        is_mount = _wrap_method(pathlib.Path.is_mount)
+    readlink = _wrap_method_path(pathlib.Path.readlink)
+    rename = _wrap_method_path(pathlib.Path.rename)
+    replace = _wrap_method_path(pathlib.Path.replace)
+    resolve = _wrap_method_path(pathlib.Path.resolve)
+    rmdir = _wrap_method(pathlib.Path.rmdir)
+    symlink_to = _wrap_method(pathlib.Path.symlink_to)
+    hardlink_to = _wrap_method(pathlib.Path.hardlink_to)
+    touch = _wrap_method(pathlib.Path.touch)
+    unlink = _wrap_method(pathlib.Path.unlink)
+    absolute = _wrap_method_path(pathlib.Path.absolute)
+    expanduser = _wrap_method_path(pathlib.Path.expanduser)
+    read_bytes = _wrap_method(pathlib.Path.read_bytes)
+    read_text = _wrap_method(pathlib.Path.read_text)
+    samefile = _wrap_method(pathlib.Path.samefile)
+    write_bytes = _wrap_method(pathlib.Path.write_bytes)
+    write_text = _wrap_method(pathlib.Path.write_text)
+    if sys.version_info < (3, 12):
+        link_to = _wrap_method(pathlib.Path.link_to)
+    if sys.version_info >= (3, 13):
+        full_match = _wrap_method(pathlib.Path.full_match)
+
+    def as_uri(self) -> str:
+        return pathlib.Path.as_uri(self)
+
+
+if Path.relative_to.__doc__:  # pragma: no branch
+    Path.relative_to.__doc__ = Path.relative_to.__doc__.replace(" `..` ", " ``..`` ")
+
+
+@final
+class PosixPath(Path, pathlib.PurePosixPath):
+    """An async :class:`pathlib.PosixPath` that executes blocking methods in :meth:`trio.to_thread.run_sync`."""
+
+    __slots__ = ()
+
+    _wrapped_cls: ClassVar[type[pathlib.Path]] = pathlib.PosixPath
+
+
+@final
+class WindowsPath(Path, pathlib.PureWindowsPath):
+    """An async :class:`pathlib.WindowsPath` that executes blocking methods in :meth:`trio.to_thread.run_sync`."""
+
+    __slots__ = ()
+
+    _wrapped_cls: ClassVar[type[pathlib.Path]] = pathlib.WindowsPath

package/lib/site-packages/trio/_repl.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import ast
+import contextlib
+import inspect
+import sys
+import warnings
+from code import InteractiveConsole
+from types import CodeType, FrameType, FunctionType
+from typing import TYPE_CHECKING
+
+import outcome
+
+import trio
+import trio.lowlevel
+from trio._util import final
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+
+class SuppressDecorator(contextlib.ContextDecorator, contextlib.suppress):
+    pass
+
+
+@SuppressDecorator(KeyboardInterrupt)
+@trio.lowlevel.disable_ki_protection
+def terminal_newline() -> None:  # TODO: test this line
+    import fcntl
+    import termios
+
+    # Fake up a newline char as if user had typed it at the terminal
+    try:
+        fcntl.ioctl(sys.stdin, termios.TIOCSTI, b"\n")  # type: ignore[attr-defined, unused-ignore]
+    except OSError as e:
+        print(f"\nPress enter! Newline injection failed: {e}", end="", flush=True)
+
+
+@final
+class TrioInteractiveConsole(InteractiveConsole):
+    def __init__(self, repl_locals: dict[str, object] | None = None) -> None:
+        super().__init__(locals=repl_locals)
+        self.token: trio.lowlevel.TrioToken | None = None
+        self.compile.compiler.flags |= ast.PyCF_ALLOW_TOP_LEVEL_AWAIT
+        self.interrupted = False
+
+    def runcode(self, code: CodeType) -> None:
+        func = FunctionType(code, self.locals)
+        if inspect.iscoroutinefunction(func):
+            result = trio.from_thread.run(outcome.acapture, func)
+        else:
+            result = trio.from_thread.run_sync(outcome.capture, func)
+        if isinstance(result, outcome.Error):
+            # If it is SystemExit, quit the repl. Otherwise, print the traceback.
+            # If there is a SystemExit inside a BaseExceptionGroup, it probably isn't
+            # the user trying to quit the repl, but rather an error in the code. So, we
+            # don't try to inspect groups for SystemExit. Instead, we just print and
+            # return to the REPL.
+            if isinstance(result.error, SystemExit):
+                raise result.error
+            else:
+                # Inline our own version of self.showtraceback that can use
+                # outcome.Error.error directly to print clean tracebacks.
+                # This also means overriding self.showtraceback does nothing.
+                sys.last_type, sys.last_value = type(result.error), result.error
+                sys.last_traceback = result.error.__traceback__
+                # see https://docs.python.org/3/library/sys.html#sys.last_exc
+                if sys.version_info >= (3, 12):
+                    sys.last_exc = result.error
+
+                # We always use sys.excepthook, unlike other implementations.
+                # This means that overriding self.write also does nothing to tbs.
+                sys.excepthook(sys.last_type, sys.last_value, sys.last_traceback)
+        # clear any residual KI
+        trio.from_thread.run(trio.lowlevel.checkpoint_if_cancelled)
+        # trio.from_thread.check_cancelled() has too long of a memory
+
+    if sys.platform == "win32":  # TODO: test this line
+
+        def raw_input(self, prompt: str = "") -> str:
+            try:
+                return input(prompt)
+            except EOFError:
+                # check if trio has a pending KI
+                trio.from_thread.run(trio.lowlevel.checkpoint_if_cancelled)
+                raise
+
+    else:
+
+        def raw_input(self, prompt: str = "") -> str:
+            from signal import SIGINT, signal
+
+            assert not self.interrupted
+
+            def install_handler() -> (
+                Callable[[int, FrameType | None], None] | int | None
+            ):
+                def handler(
+                    sig: int, frame: FrameType | None
+                ) -> None:  # TODO: test this line
+                    self.interrupted = True
+                    token.run_sync_soon(terminal_newline, idempotent=True)
+
+                token = trio.lowlevel.current_trio_token()
+
+                return signal(SIGINT, handler)
+
+            prev_handler = trio.from_thread.run_sync(install_handler)
+            try:
+                return input(prompt)
+            finally:
+                trio.from_thread.run_sync(signal, SIGINT, prev_handler)
+                if self.interrupted:  # TODO: test this line
+                    raise KeyboardInterrupt
+
+        def write(self, output: str) -> None:
+            if self.interrupted:  # TODO: test this line
+                assert output == "\nKeyboardInterrupt\n"
+                sys.stderr.write(output[1:])
+                self.interrupted = False
+            else:
+                sys.stderr.write(output)
+
+
+async def run_repl(console: TrioInteractiveConsole) -> None:
+    banner = (
+        f"trio REPL {sys.version} on {sys.platform}\n"
+        f'Use "await" directly instead of "trio.run()".\n'
+        f'Type "help", "copyright", "credits" or "license" '
+        f"for more information.\n"
+        f'{getattr(sys, "ps1", ">>> ")}import trio'
+    )
+    try:
+        await trio.to_thread.run_sync(console.interact, banner)
+    finally:
+        warnings.filterwarnings(
+            "ignore",
+            message=r"^coroutine .* was never awaited$",
+            category=RuntimeWarning,
+        )
+
+
+def main(original_locals: dict[str, object]) -> None:
+    with contextlib.suppress(ImportError):
+        import readline  # noqa: F401
+
+    repl_locals: dict[str, object] = {"trio": trio}
+    for key in {
+        "__name__",
+        "__package__",
+        "__loader__",
+        "__spec__",
+        "__builtins__",
+        "__file__",
+    }:
+        repl_locals[key] = original_locals[key]
+
+    console = TrioInteractiveConsole(repl_locals)
+    trio.run(run_repl, console)