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

package/lib/site-packages/trio/_tools/mypy_annotate.py

@@ -0,0 +1,126 @@
+"""Translates Mypy's output into GitHub's error/warning annotation syntax.
+
+See: https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions
+
+This first is run with Mypy's output piped in, to collect messages in
+mypy_annotate.dat. After all platforms run, we run this again, which prints the
+messages in GitHub's format but with cross-platform failures deduplicated.
+"""
+
+from __future__ import annotations
+
+import argparse
+import pickle
+import re
+import sys
+
+import attrs
+
+# Example: 'package/filename.py:42:1:46:3: error: Type error here [code]'
+report_re = re.compile(
+    r"""
+    ([^:]+):  # Filename (anything but ":")
+    ([0-9]+):  # Line number (start)
+    (?:([0-9]+):  # Optional column number
+      (?:([0-9]+):([0-9]+):)?  # then also optionally, 2 more numbers for end columns
+    )?
+    \s*(error|warn|note):  # Kind, prefixed with space
+    (.+)  # Message
+    """,
+    re.VERBOSE,
+)
+
+mypy_to_github = {
+    "error": "error",
+    "warn": "warning",
+    "note": "notice",
+}
+
+
+@attrs.frozen(kw_only=True)
+class Result:
+    """Accumulated results, used as a dict key to deduplicate."""
+
+    filename: str
+    start_line: int
+    kind: str
+    message: str
+    start_col: int | None = None
+    end_line: int | None = None
+    end_col: int | None = None
+
+
+def process_line(line: str) -> Result | None:
+    if match := report_re.fullmatch(line.rstrip()):
+        filename, st_line, st_col, end_line, end_col, kind, message = match.groups()
+        return Result(
+            filename=filename,
+            start_line=int(st_line),
+            start_col=int(st_col) if st_col is not None else None,
+            end_line=int(end_line) if end_line is not None else None,
+            end_col=int(end_col) if end_col is not None else None,
+            kind=mypy_to_github[kind],
+            message=message,
+        )
+    else:
+        return None
+
+
+def export(results: dict[Result, list[str]]) -> None:
+    """Display the collected results."""
+    for res, platforms in results.items():
+        print(f"::{res.kind} file={res.filename},line={res.start_line},", end="")
+        if res.start_col is not None:
+            print(f"col={res.start_col},", end="")
+            if res.end_col is not None and res.end_line is not None:
+                print(f"endLine={res.end_line},endColumn={res.end_col},", end="")
+                message = f"({res.start_line}:{res.start_col} - {res.end_line}:{res.end_col}):{res.message}"
+            else:
+                message = f"({res.start_line}:{res.start_col}):{res.message}"
+        else:
+            message = f"{res.start_line}:{res.message}"
+        print(f"title=Mypy-{'+'.join(platforms)}::{res.filename}:{message}")
+
+
+def main(argv: list[str]) -> None:
+    """Look for error messages, and convert the format."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--dumpfile",
+        help="File to write pickled messages to.",
+        required=True,
+    )
+    parser.add_argument(
+        "--platform",
+        help="OS name, if set Mypy should be piped to stdin.",
+        default=None,
+    )
+    cmd_line = parser.parse_args(argv)
+
+    results: dict[Result, list[str]]
+    try:
+        with open(cmd_line.dumpfile, "rb") as f:
+            results = pickle.load(f)
+    except (FileNotFoundError, pickle.UnpicklingError):
+        # If we fail to load, assume it's an old result.
+        results = {}
+
+    if cmd_line.platform is None:
+        # Write out the results.
+        export(results)
+    else:
+        platform: str = cmd_line.platform
+        for line in sys.stdin:
+            parsed = process_line(line)
+            if parsed is not None:
+                try:
+                    results[parsed].append(platform)
+                except KeyError:
+                    results[parsed] = [platform]
+            sys.stdout.write(line)
+        with open(cmd_line.dumpfile, "wb") as f:
+            pickle.dump(results, f)
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

package/lib/site-packages/trio/_tools/sync_requirements.py

@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+
+"""Sync Requirements - Automatically upgrade test requirements pinned
+versions from pre-commit config file."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from yaml import load as load_yaml
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+    from yaml import CLoader as _CLoader, Loader as _Loader
+
+    Loader: type[_CLoader | _Loader]
+
+try:
+    from yaml import CLoader as Loader
+except ImportError:
+    from yaml import Loader
+
+
+def yield_pre_commit_version_data(
+    pre_commit_text: str,
+) -> Generator[tuple[str, str], None, None]:
+    """Yield (name, rev) tuples from pre-commit config file."""
+    pre_commit_config = load_yaml(pre_commit_text, Loader)
+    for repo in pre_commit_config["repos"]:
+        if "repo" not in repo or "rev" not in repo:
+            continue
+        url = repo["repo"]
+        name = url.rsplit("/", 1)[-1]
+        rev = repo["rev"].removeprefix("v")
+        yield name, rev
+
+
+def update_requirements(
+    requirements: Path,
+    version_data: dict[str, str],
+) -> bool:
+    """Return if updated requirements file.
+
+    Update requirements file to match versions in version_data."""
+    changed = False
+    old_lines = requirements.read_text(encoding="utf-8").splitlines(True)
+
+    with requirements.open("w", encoding="utf-8") as file:
+        for line in old_lines:
+            # If comment or not version mark line, ignore.
+            if line.startswith("#") or "==" not in line:
+                file.write(line)
+                continue
+            name, rest = line.split("==", 1)
+            # Maintain extra markers if they exist
+            old_version = rest.strip()
+            extra = "\n"
+            if ";" in rest:
+                old_version, extra = rest.split(";", 1)
+                old_version = old_version.strip()
+                extra = " ;" + extra
+            version = version_data.get(name)
+            # If does not exist, skip
+            if version is None:
+                file.write(line)
+                continue
+            # Otherwise might have changed
+            new_line = f"{name}=={version}{extra}"
+            if new_line != line:
+                if not changed:
+                    changed = True
+                    print("Changed test requirements version to match pre-commit")
+                print(f"{name}=={old_version} -> {name}=={version}")
+            file.write(new_line)
+    return changed
+
+
+if __name__ == "__main__":
+    source_root = Path.cwd().absolute()
+
+    # Double-check we found the right directory
+    assert (source_root / "LICENSE").exists()
+    pre_commit = source_root / ".pre-commit-config.yaml"
+    test_requirements = source_root / "test-requirements.txt"
+
+    pre_commit_text = pre_commit.read_text(encoding="utf-8")
+
+    # Get tool versions from pre-commit
+    # Get correct names
+    pre_commit_versions = {
+        name.removesuffix("-mirror").removesuffix("-pre-commit"): version
+        for name, version in yield_pre_commit_version_data(pre_commit_text)
+    }
+    changed = update_requirements(test_requirements, pre_commit_versions)
+    sys.exit(int(changed))

package/lib/site-packages/trio/_tools/windows_ffi_build.py

@@ -0,0 +1,220 @@
+# builder for CFFI out-of-line mode, for reduced import time.
+# run this to generate `trio._core._generated_windows_ffi`.
+import re
+
+import cffi
+
+LIB = """
+// https://msdn.microsoft.com/en-us/library/windows/desktop/aa383751(v=vs.85).aspx
+typedef int BOOL;
+typedef unsigned char BYTE;
+typedef unsigned char UCHAR;
+typedef BYTE BOOLEAN;
+typedef void* PVOID;
+typedef PVOID HANDLE;
+typedef unsigned long DWORD;
+typedef unsigned long ULONG;
+typedef unsigned int NTSTATUS;
+typedef unsigned long u_long;
+typedef ULONG *PULONG;
+typedef const void *LPCVOID;
+typedef void *LPVOID;
+typedef const wchar_t *LPCWSTR;
+typedef DWORD* LPDWORD;
+
+typedef uintptr_t ULONG_PTR;
+typedef uintptr_t UINT_PTR;
+
+typedef UINT_PTR SOCKET;
+
+typedef struct _OVERLAPPED {
+    ULONG_PTR Internal;
+    ULONG_PTR InternalHigh;
+    union {
+        struct {
+            DWORD Offset;
+            DWORD OffsetHigh;
+        } DUMMYSTRUCTNAME;
+        PVOID Pointer;
+    } DUMMYUNIONNAME;
+
+    HANDLE  hEvent;
+} OVERLAPPED, *LPOVERLAPPED;
+
+typedef OVERLAPPED WSAOVERLAPPED;
+typedef LPOVERLAPPED LPWSAOVERLAPPED;
+typedef PVOID LPSECURITY_ATTRIBUTES;
+typedef PVOID LPCSTR;
+
+typedef struct _OVERLAPPED_ENTRY {
+    ULONG_PTR lpCompletionKey;
+    LPOVERLAPPED lpOverlapped;
+    ULONG_PTR Internal;
+    DWORD dwNumberOfBytesTransferred;
+} OVERLAPPED_ENTRY, *LPOVERLAPPED_ENTRY;
+
+// kernel32.dll
+HANDLE WINAPI CreateIoCompletionPort(
+  _In_     HANDLE    FileHandle,
+  _In_opt_ HANDLE    ExistingCompletionPort,
+  _In_     ULONG_PTR CompletionKey,
+  _In_     DWORD     NumberOfConcurrentThreads
+);
+
+BOOL SetFileCompletionNotificationModes(
+  HANDLE FileHandle,
+  UCHAR  Flags
+);
+
+HANDLE CreateFileW(
+  LPCWSTR               lpFileName,
+  DWORD                 dwDesiredAccess,
+  DWORD                 dwShareMode,
+  LPSECURITY_ATTRIBUTES lpSecurityAttributes,
+  DWORD                 dwCreationDisposition,
+  DWORD                 dwFlagsAndAttributes,
+  HANDLE                hTemplateFile
+);
+
+BOOL WINAPI CloseHandle(
+  _In_ HANDLE hObject
+);
+
+BOOL WINAPI PostQueuedCompletionStatus(
+  _In_     HANDLE       CompletionPort,
+  _In_     DWORD        dwNumberOfBytesTransferred,
+  _In_     ULONG_PTR    dwCompletionKey,
+  _In_opt_ LPOVERLAPPED lpOverlapped
+);
+
+BOOL WINAPI GetQueuedCompletionStatusEx(
+  _In_  HANDLE             CompletionPort,
+  _Out_ LPOVERLAPPED_ENTRY lpCompletionPortEntries,
+  _In_  ULONG              ulCount,
+  _Out_ PULONG             ulNumEntriesRemoved,
+  _In_  DWORD              dwMilliseconds,
+  _In_  BOOL               fAlertable
+);
+
+BOOL WINAPI CancelIoEx(
+  _In_     HANDLE       hFile,
+  _In_opt_ LPOVERLAPPED lpOverlapped
+);
+
+BOOL WriteFile(
+  HANDLE       hFile,
+  LPCVOID      lpBuffer,
+  DWORD        nNumberOfBytesToWrite,
+  LPDWORD      lpNumberOfBytesWritten,
+  LPOVERLAPPED lpOverlapped
+);
+
+BOOL ReadFile(
+  HANDLE       hFile,
+  LPVOID       lpBuffer,
+  DWORD        nNumberOfBytesToRead,
+  LPDWORD      lpNumberOfBytesRead,
+  LPOVERLAPPED lpOverlapped
+);
+
+BOOL WINAPI SetConsoleCtrlHandler(
+  _In_opt_ void*            HandlerRoutine,
+  _In_     BOOL             Add
+);
+
+HANDLE CreateEventA(
+  LPSECURITY_ATTRIBUTES lpEventAttributes,
+  BOOL                  bManualReset,
+  BOOL                  bInitialState,
+  LPCSTR                lpName
+);
+
+BOOL SetEvent(
+  HANDLE hEvent
+);
+
+BOOL ResetEvent(
+  HANDLE hEvent
+);
+
+DWORD WaitForSingleObject(
+  HANDLE hHandle,
+  DWORD  dwMilliseconds
+);
+
+DWORD WaitForMultipleObjects(
+  DWORD        nCount,
+  HANDLE       *lpHandles,
+  BOOL         bWaitAll,
+  DWORD        dwMilliseconds
+);
+
+ULONG RtlNtStatusToDosError(
+  NTSTATUS Status
+);
+
+int WSAIoctl(
+  SOCKET                             s,
+  DWORD                              dwIoControlCode,
+  LPVOID                             lpvInBuffer,
+  DWORD                              cbInBuffer,
+  LPVOID                             lpvOutBuffer,
+  DWORD                              cbOutBuffer,
+  LPDWORD                            lpcbBytesReturned,
+  LPWSAOVERLAPPED                    lpOverlapped,
+  // actually LPWSAOVERLAPPED_COMPLETION_ROUTINE
+  void* lpCompletionRoutine
+);
+
+int WSAGetLastError();
+
+BOOL DeviceIoControl(
+  HANDLE       hDevice,
+  DWORD        dwIoControlCode,
+  LPVOID       lpInBuffer,
+  DWORD        nInBufferSize,
+  LPVOID       lpOutBuffer,
+  DWORD        nOutBufferSize,
+  LPDWORD      lpBytesReturned,
+  LPOVERLAPPED lpOverlapped
+);
+
+// From https://github.com/piscisaureus/wepoll/blob/master/src/afd.h
+typedef struct _AFD_POLL_HANDLE_INFO {
+  HANDLE Handle;
+  ULONG Events;
+  NTSTATUS Status;
+} AFD_POLL_HANDLE_INFO, *PAFD_POLL_HANDLE_INFO;
+
+// This is really defined as a messy union to allow stuff like
+// i.DUMMYSTRUCTNAME.LowPart, but we don't need those complications.
+// Under all that it's just an int64.
+typedef int64_t LARGE_INTEGER;
+
+typedef struct _AFD_POLL_INFO {
+  LARGE_INTEGER Timeout;
+  ULONG NumberOfHandles;
+  ULONG Exclusive;
+  AFD_POLL_HANDLE_INFO Handles[1];
+} AFD_POLL_INFO, *PAFD_POLL_INFO;
+
+"""
+
+# cribbed from pywincffi
+# programmatically strips out those annotations MSDN likes, like _In_
+LIB = re.sub(r"\b(_In_|_Inout_|_Out_|_Outptr_|_Reserved_)(opt_)?\b", " ", LIB)
+
+# Other fixups:
+# - get rid of FAR, cffi doesn't like it
+LIB = re.sub(r"\bFAR\b", " ", LIB)
+# - PASCAL is apparently an alias for __stdcall (on modern compilers - modern
+#   being _MSC_VER >= 800)
+LIB = re.sub(r"\bPASCAL\b", "__stdcall", LIB)
+
+ffibuilder = cffi.FFI()
+# a bit hacky but, it works
+ffibuilder.set_source("trio._core._generated_windows_ffi", None)
+ffibuilder.cdef(LIB)
+
+if __name__ == "__main__":
+    ffibuilder.compile("src")

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

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import errno
+import os
+import sys
+from typing import TYPE_CHECKING, Final as FinalType
+
+import trio
+
+from ._abc import Stream
+from ._util import ConflictDetector, final
+
+assert not TYPE_CHECKING or sys.platform != "win32"
+
+# XX TODO: is this a good number? who knows... it does match the default Linux
+# pipe capacity though.
+DEFAULT_RECEIVE_SIZE: FinalType = 65536
+
+
+class _FdHolder:
+    # This class holds onto a raw file descriptor, in non-blocking mode, and
+    # is responsible for managing its lifecycle. In particular, it's
+    # responsible for making sure it gets closed, and also for tracking
+    # whether it's been closed.
+    #
+    # The way we track closure is to set the .fd field to -1, discarding the
+    # original value. You might think that this is a strange idea, since it
+    # overloads the same field to do two different things. Wouldn't it be more
+    # natural to have a dedicated .closed field? But that would be more
+    # error-prone. Fds are represented by small integers, and once an fd is
+    # closed, its integer value may be reused immediately. If we accidentally
+    # used the old fd after being closed, we might end up doing something to
+    # another unrelated fd that happened to get assigned the same integer
+    # value. By throwing away the integer value immediately, it becomes
+    # impossible to make this mistake – we'll just get an EBADF.
+    #
+    # (This trick was copied from the stdlib socket module.)
+    fd: int
+
+    def __init__(self, fd: int) -> None:
+        # make sure self.fd is always initialized to *something*, because even
+        # if we error out here then __del__ will run and access it.
+        self.fd = -1
+        if not isinstance(fd, int):
+            raise TypeError("file descriptor must be an int")
+        self.fd = fd
+        # Store original state, and ensure non-blocking mode is enabled
+        self._original_is_blocking = os.get_blocking(fd)
+        os.set_blocking(fd, False)
+
+    @property
+    def closed(self) -> bool:
+        return self.fd == -1
+
+    def _raw_close(self) -> None:
+        # This doesn't assume it's in a Trio context, so it can be called from
+        # __del__. You should never call it from Trio context, because it
+        # skips calling notify_fd_close. But from __del__, skipping that is
+        # OK, because notify_fd_close just wakes up other tasks that are
+        # waiting on this fd, and those tasks hold a reference to this object.
+        # So if __del__ is being called, we know there aren't any tasks that
+        # need to be woken.
+        if self.closed:
+            return
+        fd = self.fd
+        self.fd = -1
+        os.set_blocking(fd, self._original_is_blocking)
+        os.close(fd)
+
+    def __del__(self) -> None:
+        self._raw_close()
+
+    def close(self) -> None:
+        if not self.closed:
+            trio.lowlevel.notify_closing(self.fd)
+            self._raw_close()
+
+
+@final
+class FdStream(Stream):
+    """Represents a stream given the file descriptor to a pipe, TTY, etc.
+
+    *fd* must refer to a file that is open for reading and/or writing and
+    supports non-blocking I/O (pipes and TTYs will work, on-disk files probably
+    not).  The returned stream takes ownership of the fd, so closing the stream
+    will close the fd too.  As with `os.fdopen`, you should not directly use
+    an fd after you have wrapped it in a stream using this function.
+
+    To be used as a Trio stream, an open file must be placed in non-blocking
+    mode.  Unfortunately, this impacts all I/O that goes through the
+    underlying open file, including I/O that uses a different
+    file descriptor than the one that was passed to Trio. If other threads
+    or processes are using file descriptors that are related through `os.dup`
+    or inheritance across `os.fork` to the one that Trio is using, they are
+    unlikely to be prepared to have non-blocking I/O semantics suddenly
+    thrust upon them.  For example, you can use
+    ``FdStream(os.dup(sys.stdin.fileno()))`` to obtain a stream for reading
+    from standard input, but it is only safe to do so with heavy caveats: your
+    stdin must not be shared by any other processes, and you must not make any
+    calls to synchronous methods of `sys.stdin` until the stream returned by
+    `FdStream` is closed. See `issue #174
+    <https://github.com/python-trio/trio/issues/174>`__ for a discussion of the
+    challenges involved in relaxing this restriction.
+
+    .. warning:: one specific consequence of non-blocking mode
+      applying to the entire open file description is that when
+      your program is run with multiple standard streams connected to
+      a TTY (as in a terminal emulator), all of the streams become
+      non-blocking when you construct an `FdStream` for any of them.
+      For example, if you construct an `FdStream` for standard input,
+      you might observe Python loggers begin to fail with
+      `BlockingIOError`.
+
+    Args:
+      fd (int): The fd to be wrapped.
+
+    Returns:
+      A new `FdStream` object.
+    """
+
+    def __init__(self, fd: int) -> None:
+        self._fd_holder = _FdHolder(fd)
+        self._send_conflict_detector = ConflictDetector(
+            "another task is using this stream for send",
+        )
+        self._receive_conflict_detector = ConflictDetector(
+            "another task is using this stream for receive",
+        )
+
+    async def send_all(self, data: bytes) -> None:
+        with self._send_conflict_detector:
+            # have to check up front, because send_all(b"") on a closed pipe
+            # should raise
+            if self._fd_holder.closed:
+                raise trio.ClosedResourceError("file was already closed")
+            await trio.lowlevel.checkpoint()
+            length = len(data)
+            # adapted from the SocketStream code
+            with memoryview(data) as view:
+                sent = 0
+                while sent < length:
+                    with view[sent:] as remaining:
+                        try:
+                            sent += os.write(self._fd_holder.fd, remaining)
+                        except BlockingIOError:
+                            await trio.lowlevel.wait_writable(self._fd_holder.fd)
+                        except OSError as e:
+                            if e.errno == errno.EBADF:
+                                raise trio.ClosedResourceError(
+                                    "file was already closed",
+                                ) from None
+                            else:
+                                raise trio.BrokenResourceError from e
+
+    async def wait_send_all_might_not_block(self) -> None:
+        with self._send_conflict_detector:
+            if self._fd_holder.closed:
+                raise trio.ClosedResourceError("file was already closed")
+            await trio.lowlevel.wait_writable(self._fd_holder.fd)
+
+    async def receive_some(self, max_bytes: int | None = None) -> bytes:
+        with self._receive_conflict_detector:
+            if max_bytes is None:
+                max_bytes = DEFAULT_RECEIVE_SIZE
+            else:
+                if not isinstance(max_bytes, int):
+                    raise TypeError("max_bytes must be integer >= 1")
+                if max_bytes < 1:
+                    raise ValueError("max_bytes must be integer >= 1")
+
+            await trio.lowlevel.checkpoint()
+            while True:
+                try:
+                    data = os.read(self._fd_holder.fd, max_bytes)
+                except BlockingIOError:
+                    await trio.lowlevel.wait_readable(self._fd_holder.fd)
+                except OSError as exc:
+                    if exc.errno == errno.EBADF:
+                        raise trio.ClosedResourceError(
+                            "file was already closed",
+                        ) from None
+                    else:
+                        raise trio.BrokenResourceError from exc
+                else:
+                    break
+
+            return data
+
+    def close(self) -> None:
+        self._fd_holder.close()
+
+    async def aclose(self) -> None:
+        self.close()
+        await trio.lowlevel.checkpoint()
+
+    def fileno(self) -> int:
+        return self._fd_holder.fd