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

package/lib/site-packages/trio/_tests/tools/test_gen_exports.py

@@ -0,0 +1,179 @@
+import ast
+import sys
+from pathlib import Path
+
+import pytest
+
+from trio._tests.pytest_plugin import skip_if_optional_else_raise
+
+# imports in gen_exports that are not in `install_requires` in setup.py
+try:
+    import astor  # noqa: F401
+    import isort  # noqa: F401
+except ImportError as error:
+    skip_if_optional_else_raise(error)
+
+
+from trio._tools.gen_exports import (
+    File,
+    create_passthrough_args,
+    get_public_methods,
+    process,
+    run_linters,
+    run_ruff,
+)
+
+from ..._core._tests.tutil import slow
+
+SOURCE = '''from _run import _public
+from collections import Counter
+
+class Test:
+    @_public
+    def public_func(self):
+        """With doc string"""
+
+    @ignore_this
+    @_public
+    @another_decorator
+    async def public_async_func(self) -> Counter:
+        pass  # no doc string
+
+    def not_public(self):
+        pass
+
+    async def not_public_async(self):
+        pass
+'''
+
+IMPORT_1 = """\
+from collections import Counter
+"""
+
+IMPORT_2 = """\
+from collections import Counter
+import os
+"""
+
+IMPORT_3 = """\
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from collections import Counter
+"""
+
+
+def test_get_public_methods() -> None:
+    methods = list(get_public_methods(ast.parse(SOURCE)))
+    assert {m.name for m in methods} == {"public_func", "public_async_func"}
+
+
+def test_create_pass_through_args() -> None:
+    testcases = [
+        ("def f()", "()"),
+        ("def f(one)", "(one)"),
+        ("def f(one, two)", "(one, two)"),
+        ("def f(one, *args)", "(one, *args)"),
+        (
+            "def f(one, *args, kw1, kw2=None, **kwargs)",
+            "(one, *args, kw1=kw1, kw2=kw2, **kwargs)",
+        ),
+    ]
+
+    for funcdef, expected in testcases:
+        func_node = ast.parse(funcdef + ":\n  pass").body[0]
+        assert isinstance(func_node, ast.FunctionDef)
+        assert create_passthrough_args(func_node) == expected
+
+
+skip_lints = pytest.mark.skipif(
+    sys.implementation.name != "cpython",
+    reason="gen_exports is internal, black/isort only runs on CPython",
+)
+
+
+@slow
+@skip_lints
+@pytest.mark.parametrize("imports", [IMPORT_1, IMPORT_2, IMPORT_3])
+def test_process(
+    tmp_path: Path,
+    imports: str,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    try:
+        import black  # noqa: F401
+    # there's no dedicated CI run that has astor+isort, but lacks black.
+    except ImportError as error:  # pragma: no cover
+        skip_if_optional_else_raise(error)
+
+    modpath = tmp_path / "_module.py"
+    genpath = tmp_path / "_generated_module.py"
+    modpath.write_text(SOURCE, encoding="utf-8")
+    file = File(modpath, "runner", platform="linux", imports=imports)
+    assert not genpath.exists()
+    with pytest.raises(SystemExit) as excinfo:
+        process([file], do_test=True)
+    assert excinfo.value.code == 1
+    captured = capsys.readouterr()
+    assert "Generated sources are outdated. Please regenerate." in captured.out
+    with pytest.raises(SystemExit) as excinfo:
+        process([file], do_test=False)
+    assert excinfo.value.code == 1
+    captured = capsys.readouterr()
+    assert "Regenerated sources successfully." in captured.out
+    assert genpath.exists()
+    process([file], do_test=True)
+    # But if we change the lookup path it notices
+    with pytest.raises(SystemExit) as excinfo:
+        process(
+            [File(modpath, "runner.io_manager", platform="linux", imports=imports)],
+            do_test=True,
+        )
+    assert excinfo.value.code == 1
+    # Also if the platform is changed.
+    with pytest.raises(SystemExit) as excinfo:
+        process([File(modpath, "runner", imports=imports)], do_test=True)
+    assert excinfo.value.code == 1
+
+
+@skip_lints
+def test_run_ruff(tmp_path: Path) -> None:
+    """Test that processing properly fails if ruff does."""
+    try:
+        import ruff  # noqa: F401
+    except ImportError as error:  # pragma: no cover
+        skip_if_optional_else_raise(error)
+
+    file = File(tmp_path / "module.py", "module")
+
+    success, _ = run_ruff(file, "class not valid code ><")
+    assert not success
+
+    test_function = '''def combine_and(data: list[str]) -> str:
+    """Join values of text, and have 'and' with the last one properly."""
+    if len(data) >= 2:
+        data[-1] = 'and ' + data[-1]
+    if len(data) > 2:
+        return ', '.join(data)
+    return ' '.join(data)'''
+
+    success, response = run_ruff(file, test_function)
+    assert success
+    assert response == test_function
+
+
+@skip_lints
+def test_lint_failure(tmp_path: Path) -> None:
+    """Test that processing properly fails if black or ruff does."""
+    try:
+        import black  # noqa: F401
+        import ruff  # noqa: F401
+    except ImportError as error:  # pragma: no cover
+        skip_if_optional_else_raise(error)
+
+    file = File(tmp_path / "module.py", "module")
+
+    with pytest.raises(SystemExit):
+        run_linters(file, "class not valid code ><")
+
+    with pytest.raises(SystemExit):
+        run_linters(file, "import waffle\n;import trio")

package/lib/site-packages/trio/_tests/tools/test_mypy_annotate.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import io
+import sys
+from typing import TYPE_CHECKING
+
+import pytest
+
+from trio._tools.mypy_annotate import Result, export, main, process_line
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@pytest.mark.parametrize(
+    ("src", "expected"),
+    [
+        ("", None),
+        ("a regular line\n", None),
+        (
+            "package\\filename.py:42:8: note: Some info\n",
+            Result(
+                kind="notice",
+                filename="package\\filename.py",
+                start_line=42,
+                start_col=8,
+                end_line=None,
+                end_col=None,
+                message=" Some info",
+            ),
+        ),
+        (
+            "package/filename.py:42:1:46:3: error: Type error here [code]\n",
+            Result(
+                kind="error",
+                filename="package/filename.py",
+                start_line=42,
+                start_col=1,
+                end_line=46,
+                end_col=3,
+                message=" Type error here [code]",
+            ),
+        ),
+        (
+            "package/module.py:87: warn: Bad code\n",
+            Result(
+                kind="warning",
+                filename="package/module.py",
+                start_line=87,
+                message=" Bad code",
+            ),
+        ),
+    ],
+    ids=["blank", "normal", "note-wcol", "error-wend", "warn-lineonly"],
+)
+def test_processing(src: str, expected: Result | None) -> None:
+    result = process_line(src)
+    assert result == expected
+
+
+def test_export(capsys: pytest.CaptureFixture[str]) -> None:
+    results = {
+        Result(
+            kind="notice",
+            filename="package\\filename.py",
+            start_line=42,
+            start_col=8,
+            end_line=None,
+            end_col=None,
+            message=" Some info",
+        ): ["Windows", "Mac"],
+        Result(
+            kind="error",
+            filename="package/filename.py",
+            start_line=42,
+            start_col=1,
+            end_line=46,
+            end_col=3,
+            message=" Type error here [code]",
+        ): ["Linux", "Mac"],
+        Result(
+            kind="warning",
+            filename="package/module.py",
+            start_line=87,
+            message=" Bad code",
+        ): ["Linux"],
+    }
+    export(results)
+    std = capsys.readouterr()
+    assert std.err == ""
+    assert std.out == (
+        "::notice file=package\\filename.py,line=42,col=8,"
+        "title=Mypy-Windows+Mac::package\\filename.py:(42:8): Some info"
+        "\n"
+        "::error file=package/filename.py,line=42,col=1,endLine=46,endColumn=3,"
+        "title=Mypy-Linux+Mac::package/filename.py:(42:1 - 46:3): Type error here [code]"
+        "\n"
+        "::warning file=package/module.py,line=87,"
+        "title=Mypy-Linux::package/module.py:87: Bad code\n"
+    )
+
+
+def test_endtoend(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    import trio._tools.mypy_annotate as mypy_annotate
+
+    inp_text = """\
+Mypy begun
+trio/core.py:15: error: Bad types here [misc]
+trio/package/module.py:48:4:56:18: warn: Missing annotations  [no-untyped-def]
+Found 3 errors in 29 files
+"""
+    result_file = tmp_path / "dump.dat"
+    assert not result_file.exists()
+    with monkeypatch.context():
+        monkeypatch.setattr(sys, "stdin", io.StringIO(inp_text))
+
+        mypy_annotate.main(
+            ["--dumpfile", str(result_file), "--platform", "SomePlatform"],
+        )
+
+    std = capsys.readouterr()
+    assert std.err == ""
+    assert std.out == inp_text  # Echos the original.
+
+    assert result_file.exists()
+
+    main(["--dumpfile", str(result_file)])
+
+    std = capsys.readouterr()
+    assert std.err == ""
+    assert std.out == (
+        "::error file=trio/core.py,line=15,title=Mypy-SomePlatform::trio/core.py:15: Bad types here [misc]\n"
+        "::warning file=trio/package/module.py,line=48,col=4,endLine=56,endColumn=18,"
+        "title=Mypy-SomePlatform::trio/package/module.py:(48:4 - 56:18): Missing "
+        "annotations  [no-untyped-def]\n"
+    )

package/lib/site-packages/trio/_tests/tools/test_sync_requirements.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from trio._tests.pytest_plugin import skip_if_optional_else_raise
+
+# imports in gen_exports that are not in `install_requires` in requirements
+try:
+    import yaml  # noqa: F401
+except ImportError as error:
+    skip_if_optional_else_raise(error)
+
+from trio._tools.sync_requirements import (
+    update_requirements,
+    yield_pre_commit_version_data,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_yield_pre_commit_version_data() -> None:
+    text = """
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.0
+  - repo: https://github.com/psf/black-pre-commit-mirror
+    rev: 25.1.0
+  - bad: data
+"""
+    results = tuple(yield_pre_commit_version_data(text))
+    assert results == (
+        ("ruff-pre-commit", "0.11.0"),
+        ("black-pre-commit-mirror", "25.1.0"),
+    )
+
+
+def test_update_requirements(
+    tmp_path: Path,
+) -> None:
+    requirements_file = tmp_path / "requirements.txt"
+    assert not requirements_file.exists()
+    requirements_file.write_text(
+        """# comment
+  # also comment but spaces line start
+waffles are delicious no equals
+black==3.1.4 ; specific version thingy
+mypy==1.15.0
+ruff==1.2.5
+# required by soupy cat""",
+        encoding="utf-8",
+    )
+    assert update_requirements(requirements_file, {"black": "3.1.5", "ruff": "1.2.7"})
+    assert requirements_file.read_text(encoding="utf-8") == """# comment
+  # also comment but spaces line start
+waffles are delicious no equals
+black==3.1.5 ; specific version thingy
+mypy==1.15.0
+ruff==1.2.7
+# required by soupy cat"""
+
+
+def test_update_requirements_no_changes(
+    tmp_path: Path,
+) -> None:
+    requirements_file = tmp_path / "requirements.txt"
+    assert not requirements_file.exists()
+    original = """# comment
+  # also comment but spaces line start
+waffles are delicious no equals
+black==3.1.4 ; specific version thingy
+mypy==1.15.0
+ruff==1.2.5
+# required by soupy cat"""
+    requirements_file.write_text(original, encoding="utf-8")
+    assert not update_requirements(
+        requirements_file, {"black": "3.1.4", "ruff": "1.2.5"}
+    )
+    assert requirements_file.read_text(encoding="utf-8") == original

package/lib/site-packages/trio/_tests/type_tests/check_wraps.py

@@ -0,0 +1,9 @@
+# https://github.com/python-trio/trio/issues/2775#issuecomment-1702267589
+# (except platform independent...)
+import trio
+from typing_extensions import assert_type
+
+
+async def fn(s: trio.SocketStream) -> None:
+    result = await s.socket.sendto(b"a", "h")
+    assert_type(result, int)

package/lib/site-packages/trio/_tests/type_tests/open_memory_channel.py

@@ -0,0 +1,4 @@
+# https://github.com/python-trio/trio/issues/2873
+import trio
+
+s, r = trio.open_memory_channel[int](0)

package/lib/site-packages/trio/_tests/type_tests/path.py

@@ -0,0 +1,140 @@
+"""Path wrapping is quite complex, ensure all methods are understood as wrapped correctly."""
+
+import io
+import os
+import pathlib
+import sys
+from typing import IO, Any, BinaryIO
+
+import trio
+from trio._file_io import AsyncIOWrapper
+from typing_extensions import assert_type
+
+
+def operator_checks(text: str, tpath: trio.Path, ppath: pathlib.Path) -> None:
+    """Verify operators produce the right results."""
+    assert_type(tpath / ppath, trio.Path)
+    assert_type(tpath / tpath, trio.Path)
+    assert_type(tpath / text, trio.Path)
+    assert_type(text / tpath, trio.Path)
+
+    assert_type(tpath > tpath, bool)
+    assert_type(tpath >= tpath, bool)
+    assert_type(tpath < tpath, bool)
+    assert_type(tpath <= tpath, bool)
+
+    assert_type(tpath > ppath, bool)
+    assert_type(tpath >= ppath, bool)
+    assert_type(tpath < ppath, bool)
+    assert_type(tpath <= ppath, bool)
+
+    assert_type(ppath > tpath, bool)
+    assert_type(ppath >= tpath, bool)
+    assert_type(ppath < tpath, bool)
+    assert_type(ppath <= tpath, bool)
+
+
+def sync_attrs(path: trio.Path) -> None:
+    assert_type(path.parts, tuple[str, ...])
+    assert_type(path.drive, str)
+    assert_type(path.root, str)
+    assert_type(path.anchor, str)
+    assert_type(path.parents[3], trio.Path)
+    assert_type(path.parent, trio.Path)
+    assert_type(path.name, str)
+    assert_type(path.suffix, str)
+    assert_type(path.suffixes, list[str])
+    assert_type(path.stem, str)
+    assert_type(path.as_posix(), str)
+    assert_type(path.as_uri(), str)
+    assert_type(path.is_absolute(), bool)
+    assert_type(path.is_relative_to(path), bool)
+    assert_type(path.is_reserved(), bool)
+    assert_type(path.joinpath(path, "folder"), trio.Path)
+    assert_type(path.match("*.py"), bool)
+    assert_type(path.relative_to("/usr"), trio.Path)
+    if sys.version_info >= (3, 12):
+        assert_type(path.relative_to("/", walk_up=True), trio.Path)
+    assert_type(path.with_name("filename.txt"), trio.Path)
+    assert_type(path.with_stem("readme"), trio.Path)
+    assert_type(path.with_suffix(".log"), trio.Path)
+
+
+async def async_attrs(path: trio.Path) -> None:
+    assert_type(await trio.Path.cwd(), trio.Path)
+    assert_type(await trio.Path.home(), trio.Path)
+    assert_type(await path.stat(), os.stat_result)
+    assert_type(await path.chmod(0o777), None)
+    assert_type(await path.exists(), bool)
+    assert_type(await path.expanduser(), trio.Path)
+    for result in await path.glob("*.py"):
+        assert_type(result, trio.Path)
+    if sys.platform != "win32":
+        assert_type(await path.group(), str)
+    assert_type(await path.is_dir(), bool)
+    assert_type(await path.is_file(), bool)
+    if sys.version_info >= (3, 12):
+        assert_type(await path.is_junction(), bool)
+    if sys.platform != "win32":
+        assert_type(await path.is_mount(), bool)
+    assert_type(await path.is_symlink(), bool)
+    assert_type(await path.is_socket(), bool)
+    assert_type(await path.is_fifo(), bool)
+    assert_type(await path.is_block_device(), bool)
+    assert_type(await path.is_char_device(), bool)
+    for child_iter in await path.iterdir():
+        assert_type(child_iter, trio.Path)
+    # TODO: Path.walk() in 3.12
+    assert_type(await path.lchmod(0o111), None)
+    assert_type(await path.lstat(), os.stat_result)
+    assert_type(await path.mkdir(mode=0o777, parents=True, exist_ok=False), None)
+    # Open done separately.
+    if sys.platform != "win32":
+        assert_type(await path.owner(), str)
+    assert_type(await path.read_bytes(), bytes)
+    assert_type(await path.read_text(encoding="utf16", errors="replace"), str)
+    assert_type(await path.readlink(), trio.Path)
+    assert_type(await path.rename("another"), trio.Path)
+    assert_type(await path.replace(path), trio.Path)
+    assert_type(await path.resolve(), trio.Path)
+    for child_glob in await path.glob("*.py"):
+        assert_type(child_glob, trio.Path)
+    for child_rglob in await path.rglob("*.py"):
+        assert_type(child_rglob, trio.Path)
+    assert_type(await path.rmdir(), None)
+    assert_type(await path.samefile("something_else"), bool)
+    assert_type(await path.symlink_to("somewhere"), None)
+    assert_type(await path.hardlink_to("elsewhere"), None)
+    assert_type(await path.touch(), None)
+    assert_type(await path.unlink(missing_ok=True), None)
+    assert_type(await path.write_bytes(b"123"), int)
+    assert_type(
+        await path.write_text("hello", encoding="utf32le", errors="ignore"),
+        int,
+    )
+
+
+async def open_results(path: trio.Path, some_int: int, some_str: str) -> None:
+    # Check the overloads.
+    assert_type(await path.open(), AsyncIOWrapper[io.TextIOWrapper])
+    assert_type(await path.open("r"), AsyncIOWrapper[io.TextIOWrapper])
+    assert_type(await path.open("r+"), AsyncIOWrapper[io.TextIOWrapper])
+    assert_type(await path.open("w"), AsyncIOWrapper[io.TextIOWrapper])
+    assert_type(await path.open("rb", buffering=0), AsyncIOWrapper[io.FileIO])
+    assert_type(await path.open("rb+"), AsyncIOWrapper[io.BufferedRandom])
+    assert_type(await path.open("wb"), AsyncIOWrapper[io.BufferedWriter])
+    assert_type(await path.open("rb"), AsyncIOWrapper[io.BufferedReader])
+    assert_type(await path.open("rb", buffering=some_int), AsyncIOWrapper[BinaryIO])
+    assert_type(await path.open(some_str), AsyncIOWrapper[IO[Any]])
+
+    # Check they produce the right types.
+    file_bin = await path.open("rb+")
+    assert_type(await file_bin.read(), bytes)
+    assert_type(await file_bin.write(b"test"), int)
+    assert_type(await file_bin.seek(32), int)
+
+    file_text = await path.open("r+t")
+    assert_type(await file_text.read(), str)
+    assert_type(await file_text.write("test"), int)
+    # TODO: report mypy bug: equiv to https://github.com/microsoft/pyright/issues/6833
+    assert_type(await file_text.readlines(), list[str])

package/lib/site-packages/trio/_tests/type_tests/subprocesses.py

@@ -0,0 +1,23 @@
+import sys
+
+import trio
+
+
+async def test() -> None:
+    # this could test more by using platform checks, but currently this
+    # is just regression tests + sanity checks.
+    await trio.run_process("python", executable="ls")
+    await trio.lowlevel.open_process("python", executable="ls")
+
+    # note: there's no error code on the type ignore as it varies
+    # between platforms.
+    await trio.run_process("python", capture_stdout=True)
+    await trio.lowlevel.open_process("python", capture_stdout=True)  # type: ignore
+
+    if sys.platform != "win32" and sys.version_info >= (3, 9):
+        await trio.run_process("python", extra_groups=[5])
+        await trio.lowlevel.open_process("python", extra_groups=[5])
+
+        # 3.11+:
+        await trio.run_process("python", process_group=5)  # type: ignore
+        await trio.lowlevel.open_process("python", process_group=5)  # type: ignore

package/lib/site-packages/trio/_tests/type_tests/task_status.py

@@ -0,0 +1,29 @@
+"""Check that started() can only be called for TaskStatus[None]."""
+
+from trio import TaskStatus
+from typing_extensions import assert_type
+
+
+def check_status(
+    none_status_explicit: TaskStatus[None],
+    none_status_implicit: TaskStatus,
+    int_status: TaskStatus[int],
+) -> None:
+    assert_type(none_status_explicit, TaskStatus[None])
+    assert_type(none_status_implicit, TaskStatus[None])  # Default typevar
+    assert_type(int_status, TaskStatus[int])
+
+    # Omitting the parameter is only allowed for None.
+    none_status_explicit.started()
+    none_status_implicit.started()
+    int_status.started()  # type: ignore
+
+    # Explicit None is allowed.
+    none_status_explicit.started(None)
+    none_status_implicit.started(None)
+    int_status.started(None)  # type: ignore
+
+    none_status_explicit.started(42)  # type: ignore
+    none_status_implicit.started(42)  # type: ignore
+    int_status.started(42)
+    int_status.started(True)