agronholm-anyio-1397-1403

drwxr-xr-x 1 root root 4096 Nov  5 16:31 changelog.d
drwxr-xr-x 1 root root 4096 Nov  5 16:31 docs
-rw-r--r-- 1 root root 5874 Nov  5 16:31 pyproject.toml
drwxr-xr-x 1 root root 4096 Nov  5 16:32 src
drwxr-xr-x 1 root root 4096 Nov  5 16:31 tests
d562433 base
./.git/COMMIT_EDITMSG
./.git/config
./.git/description
./.git/HEAD
.
…[703 chars omitted]…
t.j2
./CLAUDE.md
./docs/api.rst
./docs/basics.rst
./docs/cancellation.rst
./docs/conf.py
./docs/contextmanagers.rst
./docs/contributing.rst
./docs/faq.rst
./docs/fileio.rst
./docs/index.rst
./docs/migration.rst
./docs/networking.rst
./docs/signals.rst
./docs/streams.rst
./docs/subinterpreters.rst
./docs/subprocesses.rst
./docs/support.rst
./docs/synchronization.rst
./docs/tasks.rst
./docs/tempfile.rst

src/anyio/_core/__init__.py
src/anyio/_core/_asyncio_selector_thread.py
src/anyio/_core/_concurrency_utils.py
src/anyio/_core/_contextmanagers.py
src/anyio/_core/_eventloop.py
src/anyio/_core/_exceptions.py
src/anyio/_core/_fileio.py
src/anyio/_core/_futures.py
src/anyio/_core/_resources.py
src/anyio/_core/_signals.py
src/anyio/_core/_sockets.py
src/anyio/_core/_streams.py
src/anyio/_core/_subprocesses.py
src/anyio/_core/_synchronization.py
src/anyio/_core/_tasks.py
src/anyio/_core/_tempfile.py
src/anyi
…[1120 chars omitted]…
read.py
tests/test_functools.py
tests/test_futures.py
tests/test_itertools.py
tests/test_lazyimport.py
tests/test_lowlevel.py
tests/test_pytest_plugin.py
tests/test_signals.py
tests/test_sockets.py
tests/test_subprocesses.py
tests/test_synchronization.py
tests/test_taskgroups.py
tests/test_tempfile.py
tests/test_to_interpreter.py
tests/test_to_process.py
tests/test_to_thread.py
tests/test_typedattr.py

    Generic,
    overload,
)

from .. import to_thread
from .._core._fileio import AsyncFile
from ..lowlevel import checkpoint_if_cancelled
from ._tasks import CancelScope

if TYPE_CHECKING:
    from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer


class TemporaryFile(Generic[AnyStr]):
    """
    An asynchronous temporary file that is automatically created and cleaned up.

    This class provides an asynchronous context manager interface to a temporary file.
    The file is created using Python's standard `tempfile.TemporaryFile` function in a
    background thread, and is wrapped as an asynchronous file using `Asyn
…[7337 chars omitted]…
yMode = ...,
        buffering: int = ...,
        encoding: str | None = ...,
        newline: str | None = ...,
        suffix: str | None = ...,
        prefix: str | None = ...,
        dir: str | None = ...,
        *,
        errors: str | None = ...,
    ): ...
    @overload
    def __init__(
        self: SpooledTemporaryFile[str],
        max_size: int = ...,
        mode: OpenTextMode = ...,

        self,
        max_size: int = 0,
        mode: OpenBinaryMode | OpenTextMode = "w+b",
        buffering: int = -1,
        encoding: str | None = None,
        newline: str | None = None,
        suffix: str | None = None,
        prefix: str | None = None,
        dir: str | None = None,
        *,
        errors: str | None = None,
    ) -> None:
        self._tempfile_params: dict[str, Any] = {
            "mode": mode,
            "buffering": buffering,
            "encoding": encoding,
            "newline": newline,
            "suffix": suffix,
            "prefix":
…[8629 chars omitted]…
"
    return await to_thread.run_sync(tempfile.gettempdir)


async def gettempdirb() -> bytes:
    """
    Asynchronously return the name of the directory used for temporary files in bytes.

    This function wraps `tempfile.gettempdirb` and executes it in a background thread.

    :return: The path of the temporary directory as bytes.

    """
    return await to_thread.run_sync(tempfile.gettempdirb)

        return await super().tell()

    async def truncate(self, size: int | None = None) -> int:
        if not self._rolled:
            await checkpoint_if_cancelled()
            return self._fp.truncate(size)

        return await super().truncate(size)

    @overload
    async def write(self: SpooledTemporaryFile[bytes], b: ReadableBuffer) -> int: ...
    @overload
    async def write(self: SpooledTemporaryFile[str], b: str) -> int: ...

    async def write(self, b: ReadableBuffer | str) -
…[3801 chars omitted]…
alue, traceback
                )

    async def cleanup(self) -> None:
        if self._tempdir is not None:
            await to_thread.run_sync(self._tempdir.cleanup)


@overload
async def mkstemp(
    suffix: str | None = None,
    prefix: str | None = None,
    dir: str | None = None,
    text: bool = False,
) -> tuple[int, str]: ...


@overload
async def mkstemp(
    suffix: bytes | None = None,

class _SupportsCtxMgr(Protocol[_T_co, _ExitT_co]):
    def __contextmanager__(self) -> AbstractContextManager[_T_co, _ExitT_co]: ...


class _SupportsAsyncCtxMgr(Protocol[_T_co, _ExitT_co]):
    def __asynccontextmanager__(
        self,
    ) -> AbstractAsyncContextManager[_T_co, _ExitT_co]: ...


class ContextManagerMixin:
    """
    Mixin class providing context manager functionality via a generator-based
    implementation.

    This class allows you to implement a context manager via :meth:`
…[6652 chars omitted]…
_size=10) as stf:
113:        async with SpooledTemporaryFile(max_size=1024, mode="w+b") as stf:
121:        async with SpooledTemporaryFile(max_size=1024, mode="w+b") as stf:
129:class TestTemporaryDirectory:
131:        async with TemporaryDirectory() as td:
142:        td = TemporaryDirectory()
153:        async with TemporaryDirectory() as td:
173:            async with TemporaryDirectory() as td:

    CancelScope,
    NamedTemporaryFile,
    SpooledTemporaryFile,
    TemporaryDirectory,
    TemporaryFile,
    gettempdir,
    gettempdirb,
    mkdtemp,
    mkstemp,
)


class TestTemporaryFile:
    async def test_temporary_file(self) -> None:
        data = b"temporary file data"
        async with TemporaryFile[bytes]() as af:
            await af.write(data)
            await af.seek(0)
            result = await af.read()

        assert result == data
        assert af.closed


class TestNamedTemporaryFile:
    async def test_named_temporary_file(self) -> None:
        data = b"named temporary file data"
        async with NamedTemporaryFile[bytes]() as af:
            filename = af.name
       
…[5677 chars omitted]…
 f:
            read_content = f.read()

    assert read_content == content

    os.remove(path)


@pytest.mark.parametrize("prefix", [b"mkdtemp_", "mkdtemp_"])
async def test_mkdtemp(prefix: AnyStr) -> None:
    d = await mkdtemp(prefix=prefix)

    if isinstance(d, bytes):
        dp = pathlib.Path(os.fsdecode(d))
    else:
        dp = pathlib.Path(d)

    assert dp.is_dir()

    shutil.rmtree(dp)

docs/tempfile.rst:18:    from anyio import TemporaryFile, run
docs/tempfile.rst:2
…[2120 chars omitted]…
poraryFile.readinto()`` and ``readinto1()`` reading twice before
docs/versionhistory.rst:106:- Fixed ``TemporaryDirectory`` not cleaning up when the host task was cancelled while
docs/versionhistory.rst:391:- Fixed rollover boundary check in ``SpooledTemporaryFile`` so that rollover
docs/versionhistory.rst:411:- Added async support for temporary file handling
Python 3.12.13
/repo/src/anyio/__init__.py

**4.15.0**

- Added support for the newer keyword-only arguments on ``anyio.Path`` methods to match
  the standard library ``pathlib.Path``:

  * ``follow_symlinks`` on ``exists()`` (Python 3.12+)
  * ``follow_symlinks`` on ``is_dir()`` (Python 3.13+)
  * ``follow_symlinks`` on ``is_file()`` (Python 3.13+)
  * ``follow_symlinks`` on ``owner()`` (Python 3.13+)
  * ``follow_symlinks`` on ``group()`` (Python 3.13+)
  * ``newline`` on ``read_text()`` (Python 3.13+)

  (`#1286 <https://github.com/agronholm/an
…[7816 chars omitted]…
_tokens`` exceeding ``total_tokens`` and ``available_tokens`` going
  negative) when a non-blocking acquire was made in the window between a token
  being released and the notified waiter resuming. The freed token is now
  reserved for the woken waiter right away, so the non-blocking acquire correctly
  raises ``WouldBlock``
  (`#1170 <https://github.com/agronholm/anyio/issues/1170>`_; PR by @gaoflow)

…[727 chars omitted]…
=shield
src/anyio/_core/_tasks.py:178:    with fail_at(deadline, shield=shield, reason=reason) as scope:
src/anyio/_core/_tasks.py:197:        deadline=deadline if deadline is not None else math.inf, shield=shield
src/anyio/_core/_tasks.py:219:    return get_async_backend().create_cancel_scope(deadline=deadline, shield=shield)
src/anyio/_core/_tempfile.py:509:            with CancelScope(shield=True):

                break
            elif cancel_scope.shield:
                break
            else:
                cancel_scope = cancel_scope._parent_scope

        return deadline

    @classmethod
    def create_task_group(cls) -> abc.TaskGroup:
        return TaskGroup()

    @classmethod
    def create_event(cls) -> BaseEvent:
        return Event()

    @classmethod
    def create_lock(cls, *, fast_acquire: bool) -> BaseLock:
        return Lock(fast_acquire=fast_acquire)

    @classmethod
    def create_semaphore(
        cls,
    
…[6363 chars omitted]…
iter
    )


def current_default_thread_limiter() -> CapacityLimiter:
    """
    Return the capacity limiter that is used by default to limit the number of
    concurrent threads.

    :return: a capacity limiter object
    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
        current thread

    """
    return get_async_backend().current_default_thread_limiter()

        data = await self._stream.read(max_bytes)
        if data:
            return data
        else:
            raise EndOfStream

    async def aclose(self) -> None:
        self._stream.set_exception(ClosedResourceError())
        await AsyncIOBackend.checkpoint()


@dataclass(eq=False)
class StreamWriterWrapper(abc.ByteSendStream):
    _stream: asyncio.StreamWriter
    _closed: bool = field(init=False, default=False)

    async def send(self, item: bytes) -> None:
        await AsyncIOBackend.checkpoint_if_cancelled()
        stream_paused = self._stream._prot
…[2652 chars omitted]…
process.pid

    @property
    def returncode(self) -> int | None:
        return self._process.returncode

    @property
    def stdin(self) -> abc.ByteSendStream | None:
        return self._stdin

    @property
    def stdout(self) -> abc.ByteReceiveStream | None:
        return self._stdout

    @property
150:        def __exit__(
461:    def __exit__(
2320:    def __exit__(
2406:    def __exit__(

        "_pending_uncancellations",
        "_shield",
        "_tasks",
        "_timeout_handle",
    )

    def __new__(cls, *, deadline: float = math.inf, shield: bool = False) -> Self:
        return object.__new__(cls)

    def __init__(self, deadline: float = math.inf, shield: bool = False):
        if math.isnan(deadline):
            raise ValueError("deadline must not be NaN")

        self._deadline = deadline
        self._shield = shield
        self._parent_scope: CancelScope | None = None
        self._child_scopes: set[CancelScope] = set()
        self._cancel_called = 
…[4180 chars omitted]…
ncellation, asyncio folded the two requests into a
                # single CancelledError carrying our cancellation message, so we must
                # not swallow that exception even though it looks like ours (#1214).
                if (
                    self._pending_uncancellations is not None
                    and self._host_task.cancelling() > self._cancelling_at_enter
                ):

        fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]],
        kwargs: dict[str, Any],
    ) -> T_Retval:
        return self._call_in_runner_task(fixture_func, **kwargs)

    def run_test(
        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any]
    ) -> None:
        self._call_in_runner_task(test_func, **kwargs)


class TrioTaskInfo(TaskInfo):
    def __init__(self, task: trio.lowlevel.Task):
        parent_id = None
        if task.parent_nursery and task.parent_nursery.parent_task:
            parent_id = id(tas
…[2009 chars omitted]…
assmethod
    def create_event(cls) -> BaseEvent:
        return Event()

    @classmethod
    def create_lock(cls, *, fast_acquire: bool) -> Lock:
        return Lock(fast_acquire=fast_acquire)

    @classmethod
    def create_semaphore(
        cls,
        initial_value: int,
        *,
        max_value: int | None = None,
        fast_acquire: bool = False,
147:class CancelScope(BaseCancelScope):

#
# Timeouts and cancellation
#


class CancelScope(BaseCancelScope):
    __slots__ = ("__original",)

    def __new__(
        cls, original: trio.CancelScope | None = None, **kwargs: object
    ) -> Self:
        return object.__new__(cls)

    def __init__(self, original: trio.CancelScope | None = None, **kwargs: Any) -> None:
        self.__original = original or trio.CancelScope(**kwargs)

    def __enter__(self) -> Self:
        self.__original.__enter__()
        return self

    def __exit__(
        self,
        exc_type: type[BaseException] | None,
        exc_val: BaseException | None,
        exc_tb: TracebackType | None,
    ) -> bool:
        return self.__original.__exit__(exc_type, exc_val, exc_tb)

    def cancel(self, reason: str | None = None) -> None:
       
…[2029 chars omitted]…

    ) -> bool:
        try:
            # trio.Nursery.__exit__ returns bool; .open_nursery has wrong type
            return await self._nursery_manager.__aexit__(exc_type, exc_val, exc_tb)  # type: ignore[return-value]
        except BaseExceptionGroup as exc:
            if not exc.split(trio.Cancelled)[1]:
                raise trio.Cancelled._create() from exc

            raise
        finally:

--- changelog.d/1299.fixed.rst
Fixed ``SocketStream.send()`` on the asyncio backend handing its data to a paused
transport after a p
…[2497 chars omitted]…
f the requested one
--- changelog.d/773.fixed.rst
Fixed ``get_current_task()`` on the asyncio backend raising an opaque
``TypeError: cannot create weak reference to 'NoneType' object`` instead of a clear
error when called from a callback scheduled via ``loop.call_soon_threadsafe()`` (e.g.
from within ``from_thread.run_sync()``), where ``asyncio.current_task()`` is
legitimately ``None``
PR by @AmirF194

License-Expression: MIT
Location: /usr/local/lib/python3.12/site-packages
Editable project location: /repo
Requires: idna, typing_extensions
Required-by: 
__editable__.anyio-0.0.post1.pth
anyio-0.0.post1.dist-info

## Code Style

- Follow the existing code style — the project enforces it via Ruff (see `[tool.ruff]` in `pyproject.toml`)
…[8141 chars omitted]…
ws bug (https://bugs.python.org/issue44428)
    "ignore:unclosed transport <_ProactorSocketTransport.*:ResourceWarning",
    # Ignore deprecation warning occurring under coverage.py on Python 3.15
    "ignore:Module globals; __loader__ != __spec__.loader:DeprecationWarning:",
]
markers = [
    "network: marks tests as requiring Internet access",
]

[tool.codespell]
ignore-words-list = "asend,daa,hel"

cancelled_caught False
td <TemporaryDirectory '/tmp/tmpktbv72jr'> /tmp/tmpktbv72jr True

                    if cancelleds_caught is None:
                        return False

                    self._cancelled_caught = True

                    if remaining is None:
                        return True

                    context = remaining.__context__
                    try:
                        # Preserve __cause__ and __suppress_context__ by avoiding `raise
                        # ... from ...`
 
…[5925 chars omitted]…
   def deadline(self) -> float:
        return self._deadline

    @deadline.setter
    def deadline(self, value: float) -> None:
        value = float(value)
        if math.isnan(value):
            raise ValueError("deadline must not be NaN")

        self._deadline = value
        if self._timeout_handle is not None:
            self._timeout_handle.cancel()
            self._timeout_handle = None

        else:
            encoding = _io.text_encoding(encoding)
            self._file = _io.TextIOWrapper(_io.BytesIO(),
                            encoding=encoding, errors=errors,
                            newline=newline)
        self._max_size = max_size
        self._rolled = False
        self._TemporaryFileArgs = {'mode': mode, 'buffering': buffering,
                                   'suffix': suffix, 'prefix':
…[3460 chars omitted]…
te(s)
        self._check(file)
        return rv

    def writelines(self, iterable):
        if self._max_size == 0 or self._rolled:
            return self._file.writelines(iterable)

        it = iter(iterable)
        for line in it:
            self.write(line)
            if self._rolled:
                return self._file.writelines(it)

    def detach(self):
        return self._file.detach()

**Example:**

.. code-block:: python

    from anyio import SpooledTemporaryFile, run

    async def main():
        async with SpooledTemporaryFile(max_size=1024, mode="w+") as f:
            await f.write("Spooled temp file content")
            await f.seek(0)
            print(await f.read())

    run(main)

Temporary Directory
-------------------

The :class:`TemporaryDirectory` provides an asynchronous way to create temporary directories.

**Example:**

.. code
…[1625 chars omitted]…
w+b") as stf:
tests/test_tempfile.py:121:        async with SpooledTemporaryFile(max_size=1024, mode="w+b") as stf:
docs/tempfile.rst:60:        async with SpooledTemporaryFile(max_size=1024, mode="w+") as f:
docs/versionhistory.rst:392:  only occurs when the buffer size exceeds ``max_size``
docs/versionhistory.rst:1313:  - **BACKWARDS INCOMPATIBLE** Renamed the ``max_size`` parameter to ``max_bytes``

         await self.rollover()
@@ -494,10 +494,11 @@ class TemporaryDirectory(Generic[AnyStr]):
         if sys.version_info >= (3, 12):
             params["delete"] = self.delete
 
-        self._tempdir = await to_thread.run_sync(
-            lambda: tempfile.TemporaryDirectory(**params)
-        )
-        return await to_thread.run_sync(self._tempdir.__enter__)
+        with CancelScope(shield=True):
+            self._tempdir = await to_thread.run_sync(
+                lambda: tempfile.TemporaryDirectory(**params)
+            )
+            return await to_thread.run_sync(self._tempdir.__enter__)
 
     async def __aexit__(
         self,

body entered; cancelled? True
cancelled caught: False
td_path: /tmp/tmp7pz3tigb exists: False
tempdir OK

FAILED tests/test_sockets.py::test_getaddrinfo[asyncio] - socket.gaierror: [E...
FAILED tests/test_sockets.py::test_getaddrinfo[asyncio+uvloop] - socket.gaier...
FAILED tests/test_sockets.py::test_getaddrinfo[asyncio+eager] - socket.gaierr...
FAILED tests/test_sockets.py::test_getaddrinfo[trio] - socket.gaierror: [Errn...
209 failed, 4028 passed, 118 skipped, 5 xfailed in 408.07s (0:06:48)

---
…[2176 chars omitted]…
d-with-error

× pip subprocess to install build dependencies did not run successfully.
│ exit code: 1
╰─> See above for output.

note: This error originates from a subprocess, and is likely not a problem with pip.
=========================== short test summary info ============================
FAILED tests/test_lazyimport.py::test_sourceless_install - subprocess.CalledP...
1 failed, 5 passed in 10.79s

from dataclasses import dataclass
from functools import partial
from os import PathLike
from typing import (
    IO,
    TYPE_CHECKING,
    Any,
    AnyStr,
    ClassVar,
    Final,
    Generic,
    TypeVar,
    overload,
)

from .. import to_thread
from ..abc import AsyncResource
from ._synchronization import CapacityLimiter
from ._tasks import CancelScope

if sys.version_info >= (3, 11):
    from typing import Self
else:
    from typing_extensions import Self

if sys.version_info >= (3, 14):
    from pathlib.types import PathInfo

if TYPE_CHECKING:
    from types import ModuleType

    from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer
else:
    ReadableBuffer = OpenBinaryMo
…[4964 chars omitted]…
thLike[str] | int,
    mode: str = "r",
    buffering: int = -1,
    encoding: str | None = None,
    errors: str | None = None,
    newline: str | None = None,
    closefd: bool = True,
    opener: Callable[[str, int], int] | None = None,
    *,
    limiter: CapacityLimiter | None = None,
) -> AsyncFile[Any]:
    """
    Open a file asynchronously.

52:class AsyncFile(AsyncResource, Generic[AnyStr]):

     :param buffering: The buffering policy (-1 means the default buffering).
     :param encoding: The encoding used to decode or encode the file (text mode only).
@@ -313,7 +314,7 @@ 
…[788 chars omitted]…
ext manager instead of escaping from
+        # __aenter__, which would leave the directory without running __aexit__.
+        with CancelScope(shield=True):
+            self._tempdir = await to_thread.run_sync(
+                lambda: tempfile.TemporaryDirectory(**params)
+            )
+            return await to_thread.run_sync(self._tempdir.__enter__)
 
     async def __aexit__(
         self,

           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/asyncio/base_events.py", line 691, in run_until_complete
    return future.result()
           ^^^^^^^^^^^^^^^
  File "/repo/src/anyio/_backends/_asyncio.py", line 2588, in wrapper
    return await func(*args)
           ^^^^^^^^^^^^^^^^^
  File "<stdin>", line 30, in main
  File "/usr/local/lib/python3.12/site-packages/trio/_core/_generated_run.py", line 204, in current_trio_token
    raise RuntimeError("must be called from async context") from None
RuntimeError: must be called from async context

    return future.result()
           ^^^^^^^^^^^^^^^
  File "/repo/src/anyio/_backends/_asyncio.py", line 2588, in wrapper
    return await func(*args)
                 ^^^^^^^^^^^
TypeError: main() missing 1 required positional argument: 'backend'

default rolled after writelines: False
spooled OK
body entered; cancelled? True
cancelled caught: False
td_path: /tmp/tmp65_nyyek exists: False
tempdir OK

+        value of 0 (the default) disables automatic rollover.
     :param mode: The mode in which the file is opened. Defaults to "w+b".
     :param buffering: The buffering policy (-1 means the default buffering).
    
…[923 chars omitted]…
from
+        # __aenter__, which would leave the directory without running __aexit__.
+        with CancelScope(shield=True):
+            self._tempdir = await to_thread.run_sync(
+                lambda: tempfile.TemporaryDirectory(**params)
+            )
+            return await to_thread.run_sync(self._tempdir.__enter__)
 
     async def __aexit__(
         self,
 M src/anyio/_core/_tempfile.py

        tg.cancel_scope.cancel()

    assert cancel_received


async def test_cancel_before_entering_scope() -> None:
    """
    Test that CancelScope.cancel() is honored even if called before entering the scope.

    """
    cancel_scope = anyio.CancelScope()
    cancel_scope.cancel()
    with cancel_scope:
        await anyio.sleep(1)  # Checkpoint to allow anyio to check for cancellation
        pytest.fail("execution should not reach this point")


async def test_exception_group_children() -> None:
    with pytest.raises(BaseExceptionGroup) as exc:
        async 
…[530 chars omitted]…


    assert len(exc.value.exceptions) == 2
    assert sorted(str(e) for e in exc.value.exceptions) == ["child", "host"]


async def test_escaping_cancelled_exception() -> None:
    async with create_task_group() as tg:
        tg.cancel_scope.cancel()
        await checkpoint()


async def test_cancel_scope_cleared() -> None:
    with move_on_after(0.1):
        await sleep(1)

    await checkpoint()

-rw-r--r-- 1 root root 3284 Nov  3 04:58 README.rst
drwxr-xr-x 1 root root 4096 Nov  3 04:58 changelog.d
drwxr-xr-x 1 root root 4096 Nov  3 04:58 docs
-rw-r--r-- 1 root root 5874 Nov  3 04:58 pyproject.toml
drwxr-xr-x 1 root root 4096 Nov  3 04:59 src
drwxr-xr-x 1 root root 4096 Nov  3 04:58 tests
.git/COMMIT_EDITMSG
.git/config
.git/description
.git/HEAD
.git/index
.gith
…[1340 chars omitted]…
_functools.py
tests/test_futures.py
tests/test_itertools.py
tests/test_lazyimport.py
tests/test_lowlevel.py
tests/test_pytest_plugin.py
tests/test_signals.py
tests/test_sockets.py
tests/test_subprocesses.py
tests/test_synchronization.py
tests/test_taskgroups.py
tests/test_tempfile.py
tests/test_to_interpreter.py
tests/test_to_process.py
tests/test_to_thread.py
tests/test_typedattr.py
tests/__init__.py

## Code Style

- Follow the existing code style — the project enforces it via Ruff (see `[tool.ruff]` in `pyproject.toml`)
…[7770 chars omitted]…
with SpooledTemporaryFile(max_size=1024, mode="w+b") as stf:
tests/test_tempfile.py:129:class TestTemporaryDirectory:
tests/test_tempfile.py:131:        async with TemporaryDirectory() as td:
tests/test_tempfile.py:142:        td = TemporaryDirectory()
tests/test_tempfile.py:153:        async with TemporaryDirectory() as td:
tests/test_tempfile.py:173:            async with TemporaryDirectory() as td:

    CancelScope,
    NamedTemporaryFile,
    SpooledTemporaryFile,
    TemporaryDirectory,
    TemporaryFile,
    gettempdir,
    gettempdirb,
    mkdtemp,
    mkstemp,
)


class TestTemporaryFile:
    async def test_temporary_file(self) -> None:
        data = b"temporary file data"
        async with TemporaryFile[bytes]() as af:
            await af.write(data)
            await af.seek(0)
            result = await af.read()

        assert result == data
        assert af.closed


class TestNamedTemporaryFile:
    async def test_named_temporary_file(self) -> None:
        data = b"named temporary file data"
        async with NamedTemporaryFile[bytes]() as af:
            filename = af.name
       
…[6314 chars omitted]…
 ["trio >= 0.32.0"]
47:pytest11 = {anyio = "anyio.pytest_plugin"}
55:    "pytest >= 9.0",
56:    "pytest-mock >= 3.14",
57:    "pytest-timeout >= 2.4.0",
151:[tool.pytest]
158:  "-p", "pytest_mock",
161:  "-p", "no:trio",
200:commands = [["coverage", "run", "-m", "pytest", { replace = "posargs", extend = true }]]
202:extras = ["trio"]
206:commands = [["pytest", { replace = "posargs", extend = true }]]

    async def __aexit__(
        self,
        exc_type: type[BaseException] | None,
        exc_value: BaseException | None,
        traceback: TracebackType | None,
    ) -> None:
        await self._async_file.aclose()


class SpooledTemporaryFile(AsyncFile[AnyStr]):
    """
    An asynchronous spooled temporary file that starts in memory and is spooled to disk.

    This class provides an asynchronous interface to a spooled temporary file, much like
    Python's standard :class:`~tempfile.SpooledTemporary
…[8629 chars omitted]…
iter
    )


def current_default_thread_limiter() -> CapacityLimiter:
    """
    Return the capacity limiter that is used by default to limit the number of
    concurrent threads.

    :return: a capacity limiter object
    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
        current thread

    """
    return get_async_backend().current_default_thread_limiter()

    @classmethod
    def create_semaphore(
        cls,
        initial_value: int,
        *,
        max_value: int | None = None,
        fast_acquire: bool = False,
    ) -> BaseSemaphore:
        return Semaphore(initial_value, max_value=max_value, fast_acquire=fast_acquire)

    @classmethod
    def create_capacity_limiter(cls, total_tokens: float) -> BaseCapacityLimiter:
        return CapacityLimiter(total_tokens)

    @classmethod
    async def run_sync_in_worker_thread(  # type: ignore[return]
        cls,
        func: Callable[[Unpack[PosArgsT]], T_Retval],
        args: tuple[
…[3831 chars omitted]…
[PosArgsT]], Coroutine[Any, Any, T_co]],
        args: tuple[Unpack[PosArgsT]],
        token: object,
    ) -> T_co:
        trio_token = cast("trio.lowlevel.TrioToken | None", token)
        try:
            return trio.from_thread.run(func, *args, trio_token=trio_token)
        except trio.RunFinishedError:
            raise RunFinishedError from None

    @classmethod
    def run_sync_from_thread(

396-        "_pending_uncancellations",
397-        "_shield",
398-        "_tasks",
399-        "_timeout_handle",
400-    )
401-
402-    def __new__(cls, *, deadline: float = math.inf, shield: bool = False) -> Self:
403-        return object.__new__(cls)
404-
405-    def __init__(self, deadline: float = math.inf, shield: bool = False):
406-        if math.isnan(deadline):
407-            raise ValueError("deadline must not be NaN")
408-
409-        self._deadline = deadline
410-        self._shield = shield
411-        self._parent_scop
…[8629 chars omitted]…
ue
315-            return handle
316-        else:
317-            return start_value
<module 'anyio' from '/repo/src/anyio/__init__.py'>
Traceback (most recent call last):
  File "<stdin>", line 3, in <module>
  File "/repo/src/anyio/_lazyimport.py", line 43, in __getattr__
    raise AttributeError(
AttributeError: module 'anyio' has no attribute 'get_async_backend'. Did you mean: 'get_all_backends'?

            _task_states[host_task] = task_state
        else:
            self._parent_scope = task_state.cancel_scope
            task_state.cancel_scope = self
            if self._parent_scope is not None:
                # If using an eager task factory, the parent scope may not even contain
                # the host task
                self._parent_scope._child_scopes.add(self)
                self._parent_scope._tasks.discard(host_task)

        self._timeout
…[8630 chars omitted]…
nly_asyncio]
extras = []

[tool.tox.env.pre-commit]
commands = [["pre-commit", "run", "--all-files"]]
depends = []
allowlist_externals = ["pre-commit"]
package = "skip"

[tool.tox.env.pyright]
deps = ["pyright"]
commands = [["pyright", "--ignoreexternal", "--verifytypes", "anyio"]]

[tool.tox.env.docs]
depends = []
dependency_groups = ["doc"]
commands = [["sphinx-build", "-n", "docs", "build/sphinx"]]

import pytest
import trustme
from _pytest.fixtures import SubRequest
from trustme import CA

from anyio import get_all_backends, get_available_backends
from anyio._core._eventloop import current_async_library

if TYPE_CHECKING:
    from blockbuster import BlockBuster

T = TypeVar("T")
P = ParamSpec("P")

uvloop_marks = []
uvloop_name = "uvloop"
try:
    if platform.system() == "Windows":
        uvloop_name = "winloop"
        import winloop as uvloop
    else:
        import uvloop
except ImportError:
    uvloop_marks.append(pytest.mark.skip(reason=f"{uvloop_name} not available"))
    uvl
…[8630 chars omitted]…
nc: Callable[[Unpack[PosArgsT]], Coroutine[Any, Any, T_co]],
288-        *args: Unpack[PosArgsT],
289-        name: object = None,
290-        return_handle: Literal[False, True] = False,
291-    ) -> Any:
292-        handle: TaskHandle[T_co]
293-
294-        async def run_coro_with_task_status(
295-            *, task_status: trio.TaskStatus[Any]
296-        ) -> None:
297-            nonlocal handle

270-                continue
271-            if task.exception() is not None:
272-                loop.call_exception_handler(
273-                    {
274-                        "message": "unhandled exception during asyncio.run() shutdown",
275-                        "exception": task.exception(),
276-                        "task": task,
277-                    }
278-                )
279-
280-    async def _shutdown_default_executor(loop: AbstractEventLoop) -> None:
281-        """Sch
…[8629 chars omitted]…
 Self:
227-        if self._entered:
228-            raise RuntimeError("TaskGroup cannot be entered more than once")
229-
230-        self._entered = True
231-        self._active = True
232-        self._nursery = await self._nursery_manager.__aenter__()
233-        self.cancel_scope = CancelScope(self._nursery.cancel_scope)
234-        return self
235-
236-    async def __aexit__(
237-        self,

         await self.rollover()
@@ -494,10 +494,13 @@ class TemporaryDirectory(Generic[AnyStr]):
         if sys.version_info >= (3, 12):
             params["delete"] = self.delete
 
-        self._tempdir = await to_thread.run_sync(
-            lambda: tempfile.TemporaryDirectory(**params)
-        )
-        return await to_thread.run_sync(self._tempdir.__enter__)
+        # Keep acquisition shielded so cancel
…[11 chars omitted]…
ot arrive after the directory
+        # has been created but before __aenter__ returns and __aexit__ can clean it up.
+        with CancelScope(shield=True):
+            self._tempdir = await to_thread.run_sync(
+                lambda: tempfile.TemporaryDirectory(**params)
+            )
+            return await to_thread.run_sync(self._tempdir.__enter__)
 
     async def __aexit__(
         self,

         await self.rollover()
@@ -494,10 +494,13 @@ class TemporaryDirectory(Generic[AnyStr]):
         if sys.version_info >= (3, 12):
             params["delete"] = self.delete
 
-        self._tempdir = await to_thread.run_sync(
-            lambda: tempfile.TemporaryDirectory(**params)
-        )
-        return await to_thread.run_sync(self._tempdir.__enter__)
+        # Keep acquisition shielded so cancel
…[11 chars omitted]…
ot arrive after the directory
+        # has been created but before __aenter__ returns and __aexit__ can clean it up.
+        with CancelScope(shield=True):
+            self._tempdir = await to_thread.run_sync(
+                lambda: tempfile.TemporaryDirectory(**params)
+            )
+            return await to_thread.run_sync(self._tempdir.__enter__)
 
     async def __aexit__(
         self,

320 0 
321 37     async def rollover(self) -> None:
486 0 
487 38     async def __aenter__(self) -> str:
488 34         params: dict[str, Any] = {
489 34             "suffix": self.suffix,
490 34             "prefix": self.prefix,
491 28             "dir": self.dir,
492 64             "ignore_cleanup_errors": self.ignore_cleanup_errors,
493 9         }
494 39         if sys.version_info >= (3, 12):
495 42             params["delete"] = self.delete
496 0 
497 85         # Keep acquisition shielde
…[246 chars omitted]…
n_sync(
501 61                 lambda: tempfile.TemporaryDirectory(**params)
502 13             )
503 68             return await to_thread.run_sync(self._tempdir.__enter__)
504 0 
505 24     async def __aexit__(
506 13         self,
507 45         exc_type: type[BaseException] | None,
508 40         exc_value: BaseException | None,
509 40         traceback: TracebackType | None,
510 14     ) -> None:

         await self.rollover()
@@ -494,10 +494,13 @@ class TemporaryDirectory(Generic[AnyStr]):
         if sys.version_info >= (3, 12):
             params["delete"] = self.delete
 
-        self._tempdir = await to_thread.run_sync(
-            lambda: tempfile.TemporaryDirectory(**params)
-        )
-        return await to_thread.run_sync(self._tempdir.__enter__)
+        # Keep acquisition shielded so a pending cancellation is delivered to the body,
+        # allowing __aexit__ to clean up the directory.
+        with CancelScope(shield=True):
+            self._tempdir = await to_thread.run_sync(
+                lambda: tempfile.TemporaryDirectory(**params)
+            )
+            return await to_thread.run_sync(self._tempdir.__enter__)
 
     async def __aexit__(
         self,

    def _effectively_cancelled(self) -> bool:
        cancel_scope: CancelScope | None = self
        while cancel_scope is not None:
            if cancel_scope._cancel_called:
                return True

            if cancel_scope.shield:
                return False

            cancel_scope = cancel_scope._parent_scope

        return False

    @property
    def _parent_cancellation_is_visible_to_us(self) -> bool:
        return (
            self._parent_scope is not None
         
…[4067 chars omitted]…
ncel scope {id(self):x}"
            if task := current_task():
                self._cancel_reason += f" by {task}"

            if reason:
                self._cancel_reason += f"; reason: {reason}"

            if self._host_task is not None:
                self._deliver_cancellation(self)

    @property
    def deadline(self) -> float:
        return self._deadline

df4d438 (HEAD -> master) base

+        if self._rolled or self._max_size == 0 or self._fp.tell() <= self._max_size:
             return
 
         await self.rollover()
@@ -494,10 +494,13 @@ class TemporaryDirectory(Generic[AnyStr]):
         if sys.version_info >= (3, 12):
             params["delete"] = self.delete
 
-        self._tempdir = await to_thread.run_sync(
-            lambda: tempfile.TemporaryDirectory(**
…[112 chars omitted]…
 shielded so a pending cancellation is delivered to the body,
+        # allowing __aexit__ to clean up the directory.
+        with CancelScope(shield=True):
+            self._tempdir = await to_thread.run_sync(
+                lambda: tempfile.TemporaryDirectory(**params)
+            )
+            return await to_thread.run_sync(self._tempdir.__enter__)
 
     async def __aexit__(
         self,