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

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

@@ -0,0 +1,269 @@
+# ***********************************************************
+# ******* 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 _NO_SEND, GLOBAL_RUN_CONTEXT, RunStatistics, Task
+
+if TYPE_CHECKING:
+    import contextvars
+    from collections.abc import Awaitable, Callable
+
+    import outcome
+    from typing_extensions import Unpack
+
+    from .._abc import Clock
+    from ._entry_queue import TrioToken
+    from ._run import PosArgT
+
+
+__all__ = [
+    "current_clock",
+    "current_root_task",
+    "current_statistics",
+    "current_time",
+    "current_trio_token",
+    "reschedule",
+    "spawn_system_task",
+    "wait_all_tasks_blocked",
+]
+
+
+@enable_ki_protection
+def current_statistics() -> RunStatistics:
+    """Returns ``RunStatistics``, which contains run-loop-level debugging information.
+
+    Currently, the following fields are defined:
+
+    * ``tasks_living`` (int): The number of tasks that have been spawned
+      and not yet exited.
+    * ``tasks_runnable`` (int): The number of tasks that are currently
+      queued on the run queue (as opposed to blocked waiting for something
+      to happen).
+    * ``seconds_to_next_deadline`` (float): The time until the next
+      pending cancel scope deadline. May be negative if the deadline has
+      expired but we haven't yet processed cancellations. May be
+      :data:`~math.inf` if there are no pending deadlines.
+    * ``run_sync_soon_queue_size`` (int): The number of
+      unprocessed callbacks queued via
+      :meth:`trio.lowlevel.TrioToken.run_sync_soon`.
+    * ``io_statistics`` (object): Some statistics from Trio's I/O
+      backend. This always has an attribute ``backend`` which is a string
+      naming which operating-system-specific I/O backend is in use; the
+      other attributes vary between backends.
+
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.current_statistics()
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def current_time() -> float:
+    """Returns the current time according to Trio's internal clock.
+
+    Returns:
+        float: The current time.
+
+    Raises:
+        RuntimeError: if not inside a call to :func:`trio.run`.
+
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.current_time()
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def current_clock() -> Clock:
+    """Returns the current :class:`~trio.abc.Clock`."""
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.current_clock()
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def current_root_task() -> Task | None:
+    """Returns the current root :class:`Task`.
+
+    This is the task that is the ultimate parent of all other tasks.
+
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.current_root_task()
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def reschedule(task: Task, next_send: outcome.Outcome[object] = _NO_SEND) -> None:
+    """Reschedule the given task with the given
+    :class:`outcome.Outcome`.
+
+    See :func:`wait_task_rescheduled` for the gory details.
+
+    There must be exactly one call to :func:`reschedule` for every call to
+    :func:`wait_task_rescheduled`. (And when counting, keep in mind that
+    returning :data:`Abort.SUCCEEDED` from an abort callback is equivalent
+    to calling :func:`reschedule` once.)
+
+    Args:
+      task (trio.lowlevel.Task): the task to be rescheduled. Must be blocked
+          in a call to :func:`wait_task_rescheduled`.
+      next_send (outcome.Outcome): the value (or error) to return (or
+          raise) from :func:`wait_task_rescheduled`.
+
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.reschedule(task, next_send)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def spawn_system_task(
+    async_fn: Callable[[Unpack[PosArgT]], Awaitable[object]],
+    *args: Unpack[PosArgT],
+    name: object = None,
+    context: contextvars.Context | None = None,
+) -> Task:
+    """Spawn a "system" task.
+
+    System tasks have a few differences from regular tasks:
+
+    * They don't need an explicit nursery; instead they go into the
+      internal "system nursery".
+
+    * If a system task raises an exception, then it's converted into a
+      :exc:`~trio.TrioInternalError` and *all* tasks are cancelled. If you
+      write a system task, you should be careful to make sure it doesn't
+      crash.
+
+    * System tasks are automatically cancelled when the main task exits.
+
+    * By default, system tasks have :exc:`KeyboardInterrupt` protection
+      *enabled*. If you want your task to be interruptible by control-C,
+      then you need to use :func:`disable_ki_protection` explicitly (and
+      come up with some plan for what to do with a
+      :exc:`KeyboardInterrupt`, given that system tasks aren't allowed to
+      raise exceptions).
+
+    * System tasks do not inherit context variables from their creator.
+
+    Towards the end of a call to :meth:`trio.run`, after the main
+    task and all system tasks have exited, the system nursery
+    becomes closed. At this point, new calls to
+    :func:`spawn_system_task` will raise ``RuntimeError("Nursery
+    is closed to new arrivals")`` instead of creating a system
+    task. It's possible to encounter this state either in
+    a ``finally`` block in an async generator, or in a callback
+    passed to :meth:`TrioToken.run_sync_soon` at the right moment.
+
+    Args:
+      async_fn: An async callable.
+      args: Positional arguments for ``async_fn``. If you want to pass
+          keyword arguments, use :func:`functools.partial`.
+      name: The name for this task. Only used for debugging/introspection
+          (e.g. ``repr(task_obj)``). If this isn't a string,
+          :func:`spawn_system_task` will try to make it one. A common use
+          case is if you're wrapping a function before spawning a new
+          task, you might pass the original function as the ``name=`` to
+          make debugging easier.
+      context: An optional ``contextvars.Context`` object with context variables
+          to use for this task. You would normally get a copy of the current
+          context with ``context = contextvars.copy_context()`` and then you would
+          pass that ``context`` object here.
+
+    Returns:
+      Task: the newly spawned task
+
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.spawn_system_task(
+            async_fn, *args, name=name, context=context
+        )
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+def current_trio_token() -> TrioToken:
+    """Retrieve the :class:`TrioToken` for the current call to
+    :func:`trio.run`.
+
+    """
+    try:
+        return GLOBAL_RUN_CONTEXT.runner.current_trio_token()
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None
+
+
+@enable_ki_protection
+async def wait_all_tasks_blocked(cushion: float = 0.0) -> None:
+    """Block until there are no runnable tasks.
+
+    This is useful in testing code when you want to give other tasks a
+    chance to "settle down". The calling task is blocked, and doesn't wake
+    up until all other tasks are also blocked for at least ``cushion``
+    seconds. (Setting a non-zero ``cushion`` is intended to handle cases
+    like two tasks talking to each other over a local socket, where we
+    want to ignore the potential brief moment between a send and receive
+    when all tasks are blocked.)
+
+    Note that ``cushion`` is measured in *real* time, not the Trio clock
+    time.
+
+    If there are multiple tasks blocked in :func:`wait_all_tasks_blocked`,
+    then the one with the shortest ``cushion`` is the one woken (and
+    this task becoming unblocked resets the timers for the remaining
+    tasks). If there are multiple tasks that have exactly the same
+    ``cushion``, then all are woken.
+
+    You should also consider :class:`trio.testing.Sequencer`, which
+    provides a more explicit way to control execution ordering within a
+    test, and will often produce more readable tests.
+
+    Example:
+      Here's an example of one way to test that Trio's locks are fair: we
+      take the lock in the parent, start a child, wait for the child to be
+      blocked waiting for the lock (!), and then check that we can't
+      release and immediately re-acquire the lock::
+
+         async def lock_taker(lock):
+             await lock.acquire()
+             lock.release()
+
+         async def test_lock_fairness():
+             lock = trio.Lock()
+             await lock.acquire()
+             async with trio.open_nursery() as nursery:
+                 nursery.start_soon(lock_taker, lock)
+                 # child hasn't run yet, we have the lock
+                 assert lock.locked()
+                 assert lock._owner is trio.lowlevel.current_task()
+                 await trio.testing.wait_all_tasks_blocked()
+                 # now the child has run and is blocked on lock.acquire(), we
+                 # still have the lock
+                 assert lock.locked()
+                 assert lock._owner is trio.lowlevel.current_task()
+                 lock.release()
+                 try:
+                     # The child has a prior claim, so we can't have it
+                     lock.acquire_nowait()
+                 except trio.WouldBlock:
+                     assert lock._owner is not trio.lowlevel.current_task()
+                     print("PASS")
+                 else:
+                     print("FAIL")
+
+    """
+    try:
+        return await GLOBAL_RUN_CONTEXT.runner.wait_all_tasks_blocked(cushion)
+    except AttributeError:
+        raise RuntimeError("must be called from async context") from None

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

@@ -0,0 +1,10 @@
+# auto-generated file
+import _cffi_backend
+
+ffi = _cffi_backend.FFI('trio._core._generated_windows_ffi',
+    _version = 0x2601,
+    _types = b'\x00\x00\x39\x0D\x00\x00\x1A\x01\x00\x00\x0A\x01\x00\x00\x72\x03\x00\x00\x0A\x01\x00\x00\x03\x11\x00\x00\x0A\x01\x00\x00\x02\x03\x00\x00\x6D\x03\x00\x00\x03\x11\x00\x00\x00\x0F\x00\x00\x39\x0D\x00\x00\x03\x11\x00\x00\x00\x0F\x00\x00\x39\x0D\x00\x00\x03\x11\x00\x00\x04\x01\x00\x00\x00\x0F\x00\x00\x39\x0D\x00\x00\x03\x11\x00\x00\x0A\x01\x00\x00\x03\x11\x00\x00\x0A\x01\x00\x00\x03\x11\x00\x00\x0A\x01\x00\x00\x07\x11\x00\x00\x08\x11\x00\x00\x00\x0F\x00\x00\x39\x0D\x00\x00\x03\x11\x00\x00\x03\x11\x00\x00\x0A\x01\x00\x00\x07\x11\x00\x00\x08\x11\x00\x00\x00\x0F\x00\x00\x39\x0D\x00\x00\x03\x11\x00\x00\x72\x03\x00\x00\x0A\x01\x00\x00\x07\x11\x00\x00\x08\x11\x00\x00\x00\x0F\x00\x00\x39\x0D\x00\x00\x00\x0F\x00\x00\x39\x0D\x00\x00\x03\x11\x00\x00\x02\x0F\x00\x00\x39\x0D\x00\x00\x03\x11\x00\x00\x08\x11\x00\x00\x02\x0F\x00\x00\x39\x0D\x00\x00\x03\x11\x00\x00\x6E\x03\x00\x00\x0A\x01\x00\x00\x07\x11\x00\x00\x0A\x01\x00\x00\x07\x01\x00\x00\x02\x0F\x00\x00\x39\x0D\x00\x00\x03\x11\x00\x00\x07\x01\x00\x00\x02\x0F\x00\x00\x39\x0D\x00\x00\x03\x11\x00\x00\x0A\x01\x00\x00\x1A\x01\x00\x00\x08\x11\x00\x00\x02\x0F\x00\x00\x02\x0D\x00\x00\x08\x01\x00\x00\x00\x0F\x00\x00\x02\x0D\x00\x00\x0A\x01\x00\x00\x03\x03\x00\x00\x07\x01\x00\x00\x0A\x01\x00\x00\x00\x0F\x00\x00\x02\x0D\x00\x00\x03\x11\x00\x00\x0A\x01\x00\x00\x00\x0F\x00\x00\x03\x0D\x00\x00\x03\x11\x00\x00\x07\x01\x00\x00\x07\x01\x00\x00\x03\x11\x00\x00\x00\x0F\x00\x00\x03\x0D\x00\x00\x73\x03\x00\x00\x0A\x01\x00\x00\x0A\x01\x00\x00\x03\x11\x00\x00\x0A\x01\x00\x00\x0A\x01\x00\x00\x03\x11\x00\x00\x00\x0F\x00\x00\x03\x0D\x00\x00\x03\x11\x00\x00\x03\x11\x00\x00\x1A\x01\x00\x00\x0A\x01\x00\x00\x02\x0F\x00\x00\x68\x03\x00\x00\x02\x09\x00\x00\x68\x05\x00\x00\x00\x01\x00\x00\x6C\x03\x00\x00\x03\x09\x00\x00\x04\x09\x00\x00\x05\x09\x00\x00\x17\x01\x00\x00\x01\x09\x00\x00\x00\x09\x00\x00\x00\x01\x00\x00\x10\x01',
+    _globals = (b'\x00\x00\x2F\x23CancelIoEx',0,b'\x00\x00\x2C\x23CloseHandle',0,b'\x00\x00\x52\x23CreateEventA',0,b'\x00\x00\x58\x23CreateFileW',0,b'\x00\x00\x61\x23CreateIoCompletionPort',0,b'\x00\x00\x12\x23DeviceIoControl',0,b'\x00\x00\x33\x23GetQueuedCompletionStatusEx',0,b'\x00\x00\x3F\x23PostQueuedCompletionStatus',0,b'\x00\x00\x1C\x23ReadFile',0,b'\x00\x00\x0B\x23ResetEvent',0,b'\x00\x00\x45\x23RtlNtStatusToDosError',0,b'\x00\x00\x3B\x23SetConsoleCtrlHandler',0,b'\x00\x00\x0B\x23SetEvent',0,b'\x00\x00\x0E\x23SetFileCompletionNotificationModes',0,b'\x00\x00\x2A\x23WSAGetLastError',0,b'\x00\x00\x00\x23WSAIoctl',0,b'\x00\x00\x48\x23WaitForMultipleObjects',0,b'\x00\x00\x4E\x23WaitForSingleObject',0,b'\x00\x00\x23\x23WriteFile',0),
+    _struct_unions = ((b'\x00\x00\x00\x71\x00\x00\x00\x03$1',b'\x00\x00\x70\x11DUMMYSTRUCTNAME',b'\x00\x00\x03\x11Pointer'),(b'\x00\x00\x00\x70\x00\x00\x00\x02$2',b'\x00\x00\x02\x11Offset',b'\x00\x00\x02\x11OffsetHigh'),(b'\x00\x00\x00\x68\x00\x00\x00\x02_AFD_POLL_HANDLE_INFO',b'\x00\x00\x03\x11Handle',b'\x00\x00\x02\x11Events',b'\x00\x00\x46\x11Status'),(b'\x00\x00\x00\x6C\x00\x00\x00\x02_AFD_POLL_INFO',b'\x00\x00\x6F\x11Timeout',b'\x00\x00\x02\x11NumberOfHandles',b'\x00\x00\x02\x11Exclusive',b'\x00\x00\x69\x11Handles'),(b'\x00\x00\x00\x6D\x00\x00\x00\x02_OVERLAPPED',b'\x00\x00\x01\x11Internal',b'\x00\x00\x01\x11InternalHigh',b'\x00\x00\x71\x11DUMMYUNIONNAME',b'\x00\x00\x03\x11hEvent'),(b'\x00\x00\x00\x6E\x00\x00\x00\x02_OVERLAPPED_ENTRY',b'\x00\x00\x01\x11lpCompletionKey',b'\x00\x00\x08\x11lpOverlapped',b'\x00\x00\x01\x11Internal',b'\x00\x00\x02\x11dwNumberOfBytesTransferred')),
+    _typenames = (b'\x00\x00\x00\x68AFD_POLL_HANDLE_INFO',b'\x00\x00\x00\x6CAFD_POLL_INFO',b'\x00\x00\x00\x39BOOL',b'\x00\x00\x00\x10BOOLEAN',b'\x00\x00\x00\x10BYTE',b'\x00\x00\x00\x02DWORD',b'\x00\x00\x00\x03HANDLE',b'\x00\x00\x00\x6FLARGE_INTEGER',b'\x00\x00\x00\x03LPCSTR',b'\x00\x00\x00\x25LPCVOID',b'\x00\x00\x00\x59LPCWSTR',b'\x00\x00\x00\x07LPDWORD',b'\x00\x00\x00\x08LPOVERLAPPED',b'\x00\x00\x00\x35LPOVERLAPPED_ENTRY',b'\x00\x00\x00\x03LPSECURITY_ATTRIBUTES',b'\x00\x00\x00\x03LPVOID',b'\x00\x00\x00\x08LPWSAOVERLAPPED',b'\x00\x00\x00\x46NTSTATUS',b'\x00\x00\x00\x6DOVERLAPPED',b'\x00\x00\x00\x6EOVERLAPPED_ENTRY',b'\x00\x00\x00\x67PAFD_POLL_HANDLE_INFO',b'\x00\x00\x00\x6BPAFD_POLL_INFO',b'\x00\x00\x00\x07PULONG',b'\x00\x00\x00\x03PVOID',b'\x00\x00\x00\x01SOCKET',b'\x00\x00\x00\x10UCHAR',b'\x00\x00\x00\x01UINT_PTR',b'\x00\x00\x00\x02ULONG',b'\x00\x00\x00\x01ULONG_PTR',b'\x00\x00\x00\x6DWSAOVERLAPPED',b'\x00\x00\x00\x02u_long'),
+)

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

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+import logging
+import types
+from collections import UserDict
+from typing import TYPE_CHECKING, TypeVar
+
+from .._abc import Instrument
+
+# Used to log exceptions in instruments
+INSTRUMENT_LOGGER = logging.getLogger("trio.abc.Instrument")
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    T = TypeVar("T")
+
+
+# Decorator to mark methods public. This does nothing by itself, but
+# trio/_tools/gen_exports.py looks for it.
+def _public(fn: T) -> T:
+    return fn
+
+
+class Instruments(UserDict[str, dict[Instrument, None]]):
+    """A collection of `trio.abc.Instrument` organized by hook.
+
+    Instrumentation calls are rather expensive, and we don't want a
+    rarely-used instrument (like before_run()) to slow down hot
+    operations (like before_task_step()). Thus, we cache the set of
+    instruments to be called for each hook, and skip the instrumentation
+    call if there's nothing currently installed for that hook.
+    """
+
+    __slots__ = ()
+
+    def __init__(self, incoming: Sequence[Instrument]) -> None:
+        super().__init__({"_all": {}})
+        for instrument in incoming:
+            self.add_instrument(instrument)
+
+    @_public
+    def add_instrument(self, 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.
+
+        """
+        if instrument in self.data["_all"]:
+            return
+        self.data["_all"][instrument] = None
+        try:
+            for name in dir(instrument):
+                if name.startswith("_"):
+                    continue
+                try:
+                    prototype = getattr(Instrument, name)
+                except AttributeError:
+                    continue
+                impl = getattr(instrument, name)
+                if isinstance(impl, types.MethodType) and impl.__func__ is prototype:
+                    # Inherited unchanged from _abc.Instrument
+                    continue
+                self.data.setdefault(name, {})[instrument] = None
+        except:
+            self.remove_instrument(instrument)
+            raise
+
+    @_public
+    def remove_instrument(self, 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.
+
+        """
+        # If instrument isn't present, the KeyError propagates out
+        self.data["_all"].pop(instrument)
+        for hookname, instruments in list(self.data.items()):
+            if instrument in instruments:
+                del instruments[instrument]
+                if not instruments:
+                    del self.data[hookname]
+
+    def call(
+        self,
+        hookname: str,
+        *args: object,
+    ) -> None:
+        """Call hookname(*args) on each applicable instrument.
+
+        You must first check whether there are any instruments installed for
+        that hook, e.g.::
+
+            if "before_task_step" in instruments:
+                instruments.call("before_task_step", task)
+        """
+        for instrument in list(self.data[hookname]):
+            try:
+                getattr(instrument, hookname)(*args)
+            except BaseException:
+                self.remove_instrument(instrument)
+                INSTRUMENT_LOGGER.exception(
+                    "Exception raised when calling %r on instrument %r. "
+                    "Instrument has been disabled.",
+                    hookname,
+                    instrument,
+                )

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

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import copy
+from typing import TYPE_CHECKING
+
+import outcome
+
+from .. import _core
+
+if TYPE_CHECKING:
+    from ._io_epoll import EpollWaiters
+    from ._io_windows import AFDWaiters
+
+
+# Utility function shared between _io_epoll and _io_windows
+def wake_all(waiters: EpollWaiters | AFDWaiters, exc: BaseException) -> None:
+    try:
+        current_task = _core.current_task()
+    except RuntimeError:
+        current_task = None
+    raise_at_end = False
+    for attr_name in ["read_task", "write_task"]:
+        task = getattr(waiters, attr_name)
+        if task is not None:
+            if task is current_task:
+                raise_at_end = True
+            else:
+                _core.reschedule(task, outcome.Error(copy.copy(exc)))
+            setattr(waiters, attr_name, None)
+    if raise_at_end:
+        raise exc