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

package/lib/site-packages/trio/_core/_generated_instrumentation.py

@@ -0,0 +1,50 @@
+# ***********************************************************
+# ******* WARNING: AUTOGENERATED! ALL EDITS WILL BE LOST ******
+# *************************************************************
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ._ki import enable_ki_protection
+from ._run import GLOBAL_RUN_CONTEXT
+
+if TYPE_CHECKING:
+    from ._instrumentation import Instrument
+
+__all__ = ["add_instrument", "remove_instrument"]
+
+
+@enable_ki_protection
+def add_instrument(instrument: Instrument) -> None:
+    """Start instrumenting the current run loop with the given instrument.
+
+    Args:
+      instrument (trio.abc.Instrument): The instrument to activate.
+
+    If ``instrument`` is already active, does nothing.
+
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.instruments.add_instrument(instrument)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def remove_instrument(instrument: Instrument) -> None:
+    """Stop instrumenting the current run loop with the given instrument.
+
+    Args:
+      instrument (trio.abc.Instrument): The instrument to de-activate.
+
+    Raises:
+      KeyError: if the instrument is not currently active. This could
+          occur either because you never added it, or because you added it
+          and then it raised an unhandled exception and was automatically
+          deactivated.
+
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.instruments.remove_instrument(instrument)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None

package/lib/site-packages/trio/_core/_generated_io_epoll.py

@@ -0,0 +1,98 @@
+# ***********************************************************
+# ******* WARNING: AUTOGENERATED! ALL EDITS WILL BE LOST ******
+# *************************************************************
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from ._ki import enable_ki_protection
+from ._run import GLOBAL_RUN_CONTEXT
+
+if TYPE_CHECKING:
+    from .._file_io import _HasFileNo
+
+assert not TYPE_CHECKING or sys.platform == "linux"
+
+
+__all__ = ["notify_closing", "wait_readable", "wait_writable"]
+
+
+@enable_ki_protection
+async def wait_readable(fd: int | _HasFileNo) -> None:
+    """Block until the kernel reports that the given object is readable.
+
+    On Unix systems, ``fd`` must either be an integer file descriptor,
+    or else an object with a ``.fileno()`` method which returns an
+    integer file descriptor. Any kind of file descriptor can be passed,
+    though the exact semantics will depend on your kernel. For example,
+    this probably won't do anything useful for on-disk files.
+
+    On Windows systems, ``fd`` must either be an integer ``SOCKET``
+    handle, or else an object with a ``.fileno()`` method which returns
+    an integer ``SOCKET`` handle. File descriptors aren't supported,
+    and neither are handles that refer to anything besides a
+    ``SOCKET``.
+
+    :raises trio.BusyResourceError:
+        if another task is already waiting for the given socket to
+        become readable.
+    :raises trio.ClosedResourceError:
+        if another task calls :func:`notify_closing` while this
+        function is still working.
+    """
+    try:
+        return await GLOBAL_RUN_CONTEXT.runner.io_manager.wait_readable(fd)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+async def wait_writable(fd: int | _HasFileNo) -> None:
+    """Block until the kernel reports that the given object is writable.
+
+    See `wait_readable` for the definition of ``fd``.
+
+    :raises trio.BusyResourceError:
+        if another task is already waiting for the given socket to
+        become writable.
+    :raises trio.ClosedResourceError:
+        if another task calls :func:`notify_closing` while this
+        function is still working.
+    """
+    try:
+        return await GLOBAL_RUN_CONTEXT.runner.io_manager.wait_writable(fd)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def notify_closing(fd: int | _HasFileNo) -> None:
+    """Notify waiters of the given object that it will be closed.
+
+    Call this before closing a file descriptor (on Unix) or socket (on
+    Windows). This will cause any `wait_readable` or `wait_writable`
+    calls on the given object to immediately wake up and raise
+    `~trio.ClosedResourceError`.
+
+    This doesn't actually close the object – you still have to do that
+    yourself afterwards. Also, you want to be careful to make sure no
+    new tasks start waiting on the object in between when you call this
+    and when it's actually closed. So to close something properly, you
+    usually want to do these steps in order:
+
+    1. Explicitly mark the object as closed, so that any new attempts
+       to use it will abort before they start.
+    2. Call `notify_closing` to wake up any already-existing users.
+    3. Actually close the object.
+
+    It's also possible to do them in a different order if that's more
+    convenient, *but only if* you make sure not to have any checkpoints in
+    between the steps. This way they all happen in a single atomic
+    step, so other tasks won't be able to tell what order they happened
+    in anyway.
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.io_manager.notify_closing(fd)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None

package/lib/site-packages/trio/_core/_generated_io_kqueue.py

@@ -0,0 +1,153 @@
+# ***********************************************************
+# ******* WARNING: AUTOGENERATED! ALL EDITS WILL BE LOST ******
+# *************************************************************
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from ._ki import enable_ki_protection
+from ._run import GLOBAL_RUN_CONTEXT
+
+if TYPE_CHECKING:
+    import select
+    from collections.abc import Callable
+    from contextlib import AbstractContextManager
+
+    from .. import _core
+    from .._file_io import _HasFileNo
+    from ._traps import Abort, RaiseCancelT
+
+assert not TYPE_CHECKING or sys.platform == "darwin"
+
+
+__all__ = [
+    "current_kqueue",
+    "monitor_kevent",
+    "notify_closing",
+    "wait_kevent",
+    "wait_readable",
+    "wait_writable",
+]
+
+
+@enable_ki_protection
+def current_kqueue() -> select.kqueue:
+    """TODO: these are implemented, but are currently more of a sketch than
+    anything real. See `#26
+    <https://github.com/python-trio/trio/issues/26>`__.
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.io_manager.current_kqueue()
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def monitor_kevent(
+    ident: int, filter: int
+) -> AbstractContextManager[_core.UnboundedQueue[select.kevent]]:
+    """TODO: these are implemented, but are currently more of a sketch than
+    anything real. See `#26
+    <https://github.com/python-trio/trio/issues/26>`__.
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.io_manager.monitor_kevent(ident, filter)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+async def wait_kevent(
+    ident: int, filter: int, abort_func: Callable[[RaiseCancelT], Abort]
+) -> Abort:
+    """TODO: these are implemented, but are currently more of a sketch than
+    anything real. See `#26
+    <https://github.com/python-trio/trio/issues/26>`__.
+    """
+    try:
+        return await GLOBAL_RUN_CONTEXT.runner.io_manager.wait_kevent(
+            ident, filter, abort_func
+        )
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+async def wait_readable(fd: int | _HasFileNo) -> None:
+    """Block until the kernel reports that the given object is readable.
+
+    On Unix systems, ``fd`` must either be an integer file descriptor,
+    or else an object with a ``.fileno()`` method which returns an
+    integer file descriptor. Any kind of file descriptor can be passed,
+    though the exact semantics will depend on your kernel. For example,
+    this probably won't do anything useful for on-disk files.
+
+    On Windows systems, ``fd`` must either be an integer ``SOCKET``
+    handle, or else an object with a ``.fileno()`` method which returns
+    an integer ``SOCKET`` handle. File descriptors aren't supported,
+    and neither are handles that refer to anything besides a
+    ``SOCKET``.
+
+    :raises trio.BusyResourceError:
+        if another task is already waiting for the given socket to
+        become readable.
+    :raises trio.ClosedResourceError:
+        if another task calls :func:`notify_closing` while this
+        function is still working.
+    """
+    try:
+        return await GLOBAL_RUN_CONTEXT.runner.io_manager.wait_readable(fd)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+async def wait_writable(fd: int | _HasFileNo) -> None:
+    """Block until the kernel reports that the given object is writable.
+
+    See `wait_readable` for the definition of ``fd``.
+
+    :raises trio.BusyResourceError:
+        if another task is already waiting for the given socket to
+        become writable.
+    :raises trio.ClosedResourceError:
+        if another task calls :func:`notify_closing` while this
+        function is still working.
+    """
+    try:
+        return await GLOBAL_RUN_CONTEXT.runner.io_manager.wait_writable(fd)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def notify_closing(fd: int | _HasFileNo) -> None:
+    """Notify waiters of the given object that it will be closed.
+
+    Call this before closing a file descriptor (on Unix) or socket (on
+    Windows). This will cause any `wait_readable` or `wait_writable`
+    calls on the given object to immediately wake up and raise
+    `~trio.ClosedResourceError`.
+
+    This doesn't actually close the object – you still have to do that
+    yourself afterwards. Also, you want to be careful to make sure no
+    new tasks start waiting on the object in between when you call this
+    and when it's actually closed. So to close something properly, you
+    usually want to do these steps in order:
+
+    1. Explicitly mark the object as closed, so that any new attempts
+       to use it will abort before they start.
+    2. Call `notify_closing` to wake up any already-existing users.
+    3. Actually close the object.
+
+    It's also possible to do them in a different order if that's more
+    convenient, *but only if* you make sure not to have any checkpoints in
+    between the steps. This way they all happen in a single atomic
+    step, so other tasks won't be able to tell what order they happened
+    in anyway.
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.io_manager.notify_closing(fd)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None

package/lib/site-packages/trio/_core/_generated_io_windows.py

@@ -0,0 +1,204 @@
+# ***********************************************************
+# ******* WARNING: AUTOGENERATED! ALL EDITS WILL BE LOST ******
+# *************************************************************
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING
+
+from ._ki import enable_ki_protection
+from ._run import GLOBAL_RUN_CONTEXT
+
+if TYPE_CHECKING:
+    from contextlib import AbstractContextManager
+
+    from typing_extensions import Buffer
+
+    from .._file_io import _HasFileNo
+    from ._unbounded_queue import UnboundedQueue
+    from ._windows_cffi import CData, Handle
+
+assert not TYPE_CHECKING or sys.platform == "win32"
+
+
+__all__ = [
+    "current_iocp",
+    "monitor_completion_key",
+    "notify_closing",
+    "readinto_overlapped",
+    "register_with_iocp",
+    "wait_overlapped",
+    "wait_readable",
+    "wait_writable",
+    "write_overlapped",
+]
+
+
+@enable_ki_protection
+async def wait_readable(sock: _HasFileNo | int) -> None:
+    """Block until the kernel reports that the given object is readable.
+
+    On Unix systems, ``sock`` must either be an integer file descriptor,
+    or else an object with a ``.fileno()`` method which returns an
+    integer file descriptor. Any kind of file descriptor can be passed,
+    though the exact semantics will depend on your kernel. For example,
+    this probably won't do anything useful for on-disk files.
+
+    On Windows systems, ``sock`` must either be an integer ``SOCKET``
+    handle, or else an object with a ``.fileno()`` method which returns
+    an integer ``SOCKET`` handle. File descriptors aren't supported,
+    and neither are handles that refer to anything besides a
+    ``SOCKET``.
+
+    :raises trio.BusyResourceError:
+        if another task is already waiting for the given socket to
+        become readable.
+    :raises trio.ClosedResourceError:
+        if another task calls :func:`notify_closing` while this
+        function is still working.
+    """
+    try:
+        return await GLOBAL_RUN_CONTEXT.runner.io_manager.wait_readable(sock)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+async def wait_writable(sock: _HasFileNo | int) -> None:
+    """Block until the kernel reports that the given object is writable.
+
+    See `wait_readable` for the definition of ``sock``.
+
+    :raises trio.BusyResourceError:
+        if another task is already waiting for the given socket to
+        become writable.
+    :raises trio.ClosedResourceError:
+        if another task calls :func:`notify_closing` while this
+        function is still working.
+    """
+    try:
+        return await GLOBAL_RUN_CONTEXT.runner.io_manager.wait_writable(sock)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def notify_closing(handle: Handle | int | _HasFileNo) -> None:
+    """Notify waiters of the given object that it will be closed.
+
+    Call this before closing a file descriptor (on Unix) or socket (on
+    Windows). This will cause any `wait_readable` or `wait_writable`
+    calls on the given object to immediately wake up and raise
+    `~trio.ClosedResourceError`.
+
+    This doesn't actually close the object – you still have to do that
+    yourself afterwards. Also, you want to be careful to make sure no
+    new tasks start waiting on the object in between when you call this
+    and when it's actually closed. So to close something properly, you
+    usually want to do these steps in order:
+
+    1. Explicitly mark the object as closed, so that any new attempts
+       to use it will abort before they start.
+    2. Call `notify_closing` to wake up any already-existing users.
+    3. Actually close the object.
+
+    It's also possible to do them in a different order if that's more
+    convenient, *but only if* you make sure not to have any checkpoints in
+    between the steps. This way they all happen in a single atomic
+    step, so other tasks won't be able to tell what order they happened
+    in anyway.
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.io_manager.notify_closing(handle)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def register_with_iocp(handle: int | CData) -> None:
+    """TODO: these are implemented, but are currently more of a sketch than
+    anything real. See `#26
+    <https://github.com/python-trio/trio/issues/26>`__ and `#52
+    <https://github.com/python-trio/trio/issues/52>`__.
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.io_manager.register_with_iocp(handle)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+async def wait_overlapped(handle_: int | CData, lpOverlapped: CData | int) -> object:
+    """TODO: these are implemented, but are currently more of a sketch than
+    anything real. See `#26
+    <https://github.com/python-trio/trio/issues/26>`__ and `#52
+    <https://github.com/python-trio/trio/issues/52>`__.
+    """
+    try:
+        return await GLOBAL_RUN_CONTEXT.runner.io_manager.wait_overlapped(
+            handle_, lpOverlapped
+        )
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+async def write_overlapped(
+    handle: int | CData, data: Buffer, file_offset: int = 0
+) -> int:
+    """TODO: these are implemented, but are currently more of a sketch than
+    anything real. See `#26
+    <https://github.com/python-trio/trio/issues/26>`__ and `#52
+    <https://github.com/python-trio/trio/issues/52>`__.
+    """
+    try:
+        return await GLOBAL_RUN_CONTEXT.runner.io_manager.write_overlapped(
+            handle, data, file_offset
+        )
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+async def readinto_overlapped(
+    handle: int | CData, buffer: Buffer, file_offset: int = 0
+) -> int:
+    """TODO: these are implemented, but are currently more of a sketch than
+    anything real. See `#26
+    <https://github.com/python-trio/trio/issues/26>`__ and `#52
+    <https://github.com/python-trio/trio/issues/52>`__.
+    """
+    try:
+        return await GLOBAL_RUN_CONTEXT.runner.io_manager.readinto_overlapped(
+            handle, buffer, file_offset
+        )
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def current_iocp() -> int:
+    """TODO: these are implemented, but are currently more of a sketch than
+    anything real. See `#26
+    <https://github.com/python-trio/trio/issues/26>`__ and `#52
+    <https://github.com/python-trio/trio/issues/52>`__.
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.io_manager.current_iocp()
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def monitor_completion_key() -> (
+    AbstractContextManager[tuple[int, UnboundedQueue[object]]]
+):
+    """TODO: these are implemented, but are currently more of a sketch than
+    anything real. See `#26
+    <https://github.com/python-trio/trio/issues/26>`__ and `#52
+    <https://github.com/python-trio/trio/issues/52>`__.
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.io_manager.monitor_completion_key()
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None