agronholm-anyio-1279-1223

total 28
drwxr-xr-x 1 root root 4096 Nov  4 21:32 .
drwxr-xr-x 1 root root 4096 Nov  4 21:32 ..
drwxr-xr-x 1 root root 4096 Nov  4 21:32 .git
drwxr-xr-x 1 root root 4096 Nov  4 21:32 .github
-rw-r--r-- 1 root root  183 Nov  4 21:32 .gitignore
-rw-r--r-- 1 root root 1399 Nov  4 21:32 .pre-commit-config.yaml
-rw-r--r-- 1 root root  312 Nov  4 21:32 .readthedocs.yml
-rw-r--r-- 1 root root 3923 Nov  4 21:32 AGENTS.md
-rw-r--r-- 1 root root   11 Nov  4 21:32 CLAUDE.md
-rw-r--r-- 1 root root 1081 Nov  4 21:32 LICENSE
-rw-r--r-- 1 root root 3272 Nov  4 21:32 README.rst

drwxr-xr-x 1 root root 4096 Nov  4 21:32 docs
-rw-r--r-- 1 root root 5229 Nov  4 21:32 pyproject.toml
drwxr-xr-x 1 root root 4096 Nov  4 21:33 src
drwxr-xr-x 1 root root 4096 Nov  4 21:32 tests
b6e3d9b base

# AGENTS.md — Guidelines for AI Agents working on anyio

## Project Overview

AnyIO is a high-level asynchronous concurrency and networking library for Python that works on top of both **asyncio** and **Trio**. Source code lives in `src/`, tests in `tests/`.

## Building & Testing

- **Python**: Check the minimum Python version by looking at the `requires-python` field in `pyproject.toml`.
- **Install the project and test dependencies**: `pip install --group test -e .`.
- **Run tests**: `pytest` (runs from the `tests/` directory automatically via `pyproject.toml` config). Tests run against all supported backends by default.
- **Linting**: The project uses **pre-commit** for linting, formatting and static type checking. Run `pre-commit run -a` to check everything.

## Code Style

- Follow the existing code style — the project enforces it via Ruff (see `[tool.ruff]` in `pyproject.toml`)
…[4548 chars omitted]…
y
src/anyio/to_thread.py
src/anyio/_backends/_asyncio.py:2050:class CapacityLimiter(BaseCapacityLimiter):
src/anyio/_backends/_trio.py:845:class CapacityLimiter(BaseCapacityLimiter):
src/anyio/_core/_synchronization.py:35:class CapacityLimiterStatistics:
src/anyio/_core/_synchronization.py:534:class CapacityLimiter:
src/anyio/_core/_synchronization.py:652:class CapacityLimiterAdapter(CapacityLimiter):

self._owner_task = task
            fut.set_result(None)
            return

        self._owner_task = None

    def statistics(self) -> LockStatistics:
        task_info = AsyncIOTaskInfo(self._owner_task) if self._owner_task else None
        return LockStatistics(self.locked(), task_info, len(self._waiters))


class Semaphore(BaseSemaphore):

    __slots__ = "_fast_acquire", "_max_value", "_value", "_waiters"

    def __new__(
        cls,
        initial_value: int,
        *,
        max_value: int | None = None,
        fast_acquire: bool = False,
    ) -> Self:
        return object.__new__(cls)

    def __init__(
        self,
        initial_value: int,
        *,
        max_value: int | None = None,
        fast_acquire: bool = False,
    ):
        super().__init__(initial_value, max_value=max_value)
        self._value = initial_value
        self._max_value 
…[6236 chars omitted]…
ls] = set()

    def _deliver(self, signum: Signals) -> None:
        self._signal_queue.append(signum)
        if not self._future.done():
            self._future.set_result(None)

    def __enter__(self) -> Self:
        for sig in set(self._signals):
            self._loop.add_signal_handler(sig, self._deliver, sig)
            self._handled_signals.add(sig)

        return self

    def __exit__(

def __init__(
        self,
        initial_value: int,
        *,
        max_value: int | None = None,
        fast_acquire: bool = False,
    ) -> None:
        super().__init__(initial_value, max_value=max_value, fast_acquire=fast_acquire)
        self.__original = trio.Semaphore(initial_value, max_value=max_value)

    async def acquire(self) -> None:
        if not self._fast_acquire:

            await self.__original.acquire()
            return

        # This is the "fast path" where we don't let other tasks run
        await trio.lowlevel.checkpoint_if_cancelled()
        try:
            self.__original.acquire_nowait()
        except trio.WouldBlock:
            await self.__original._lot.park()

    def acquire_nowait(self) -> None:
        try:
            self.__original.acquire_nowait()
        except trio.WouldBlock:
            raise WouldBlock from None

    @p
…[8628 chars omitted]…
ait()

    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
        self._limiter.acquire_on_behalf_of_nowait(borrower)

    async def acquire(self) -> None:
        await self._limiter.acquire()

    async def acquire_on_behalf_of(self, borrower: object) -> None:
        await self._limiter.acquire_on_behalf_of(borrower)

    def release(self) -> None:
        self._limiter.release()

254:                self._loop.call_soon_threadsafe(lambda: None)
286:                loop.call_soon_threadsafe(future.set_result, None)
288:                loop.call_soon_threadsafe(future.set_exception, ex)
983:class WorkerThread(Thread):
989:        workers: set[WorkerThread],
990:        idle_workers: deque[WorkerThread],
1046:                        self.loop.call_soon_threadsafe(
1065:_threadpool_idle_workers: RunVar[deque[WorkerThread]] = RunVar(
1068:_threadpool_workers: RunVar[set[WorkerThread]] = RunVar("_threadpool_workers")
2587:    async def run_sync_in_worker_thread(  # type: ignore[return]
2612:                    worker = WorkerThread(root_task, workers, idle_workers)
2625:                            < WorkerThread.MAX_IDLE_TIME

2716:        loop.call_soon_threadsafe(wrapper)

except BaseException:
            if handle.status is TaskHandle.Status.PENDING:
                # Cancel the task and wait for it to exit before returning
                handle.cancel()
                with CancelScope(shield=True):
                    await handle.wait()

            raise

        if return_handle:
            handle._start_value = future.result()
            return handle

        else:
            return future.result()


#
# Threads
#

_Retval_Queue_Type = tuple[T_Retval | None, BaseException | None]


class WorkerThread(Thread):
    MAX_IDLE_TIME = 10  # seconds

    def __init__(
        self,
        root_task: asyncio.Task,
        workers: set[WorkerThread],
        idle_workers: deque[WorkerThread],
    ):
        kwargs: dict[str, Any] = {}
        if sys.version_info >= (3, 14):
            kwargs["context"] = Context()

        super().__init__(
…[8628 chars omitted]…
path(command)

        # Use loop.subprocess_shell()/subprocess_exec() rather than their
        # asyncio.create_subprocess_*() counterparts to get access to
        # transport/protocol.
        loop = asyncio.get_running_loop()
        if isinstance(command, (str, bytes)):
            transport, protocol = await loop.subprocess_shell(
                _ProcessStreamProtocol,
                command,

31:    "exceptiongroup >= 1.0.2; python_version < '3.11'",
33:    "typing_extensions >= 4.16.0; python_version < '3.15'",
35:dynamic = ["version"]
39:Changelog = "https://anyio.readthedocs.io/en/stable/versionhistory.html"
51:    "blockbuster >= 1.5.23; python_version < '3.15'",
62:    and platform_system != 'Windows' and python_version < '3.15' \
71:    "Sphinx ~= 8.2; python_version >= '3.11'",
78:version_scheme = "post-release"
117:python_version = "3.14"
Version history
===============

This library adheres to `Semantic Versioning 2.0 <http://semver.org/>`_.

**UNRELEASED**

- 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+)
  * ``newline``
…[7106 chars omitted]…

  when an async test raise an outcome exception (e.g., ``pytest.skip()``, ``pytest.xfail()``,
  or ``pytest.fail()``)
  (`#1179 <https://github.com/agronholm/anyio/issues/1179>`_; PR by @EmmanuelNiyonshuti)
- Fixed ``CapacityLimiter.total_tokens`` rejecting a value of ``0`` when the limiter was
  instantiated outside of an event loop, contradicting the documented behavior of
  allowing 0 total tokens

tests/test_synchronization.py:12:    CapacityLimiter,
tests/test_synchronization.py:708:class TestCapacityLimiter:
tests/test_synchronization.py:710:        pytest.raises(TypeError, CapacityLimiter, 1.0).match(
tests/test_synchronization.py:711:            "total_tokens must be an int or math.inf"
tests/test_synchronization.py:715:        pytest.raises(ValueError, CapacityLimiter, -1).match(
tests/test_synchronization.py:716:            "total_tokens must be >= 0"
tests/test_synchronization.py:720:        limiter = CapacityLimiter(0)
tests/test_synchronization.py:721:        assert limiter.total_tokens == 0
tests/test_synchronization.py:724:        limiter = CapacityLimiter(2)
tests/test_synchronization.py:725:        assert limiter.total_tokens == 2
tests/test_synchronization.py:729:            assert limiter.total_tokens == 2
tests/test_synchronization.py:745:        limiter = Capac

…[3220 chars omitted]…
ization.py:1007:        assert limiter.borrowed_tokens <= limiter.total_tokens
tests/test_to_thread.py:18:    CapacityLimiter,
tests/test_to_thread.py:80:    limiter = CapacityLimiter(3)
tests/test_to_thread.py:287:    Test that raising StopIteration in a worker thread raises a RuntimeError on the
tests/test_to_thread.py:295:    with pytest.raises(RuntimeError, match="coroutine raised StopIteration"):

run(
            use_semaphore,
            backend=anyio_backend_name,
            backend_options=anyio_backend_options,
        )


class TestCapacityLimiter:
    async def test_bad_init_type(self) -> None:
        pytest.raises(TypeError, CapacityLimiter, 1.0).match(
            "total_tokens must be an int or math.inf"
        )

    async def test_bad_init_value(self) -> None:
        pytest.raises(ValueError, CapacityLimiter, -1).match(
            "total_tokens must be >= 0"
        )

    async def test_zero_tokens(self) -> None:
        limiter = CapacityLimiter(0)
        assert limiter.total_tokens == 0

    async def test_borrow(self) -> None:
        limiter = CapacityLimiter(2)
        assert limiter.total_tokens == 2
        assert limiter.available_tokens == 2
        assert limiter.borrowed_tokens == 0
        async with limiter:
            assert limiter.t
…[8629 chars omitted]…
ies to find the top most parent task by traversing the cancel
    scope tree, or failing that, uses the current task to set up a shutdown callback.

    """

    async def run_in_thread() -> None:
        try:
            await to_thread.run_sync(time.sleep, 0)
        finally:
            asyncio_event_loop.call_soon(asyncio_event_loop.stop)

    task = asyncio_event_loop.create_task(run_in_thread())

limiter.total_tokens = float("inf")
        assert limiter.total_tokens == math.inf

    async def test_total_tokens_as_kwarg(self) -> None:
        # Regression test for #515
        limiter = CapacityLimiter(total_tokens=1)
        assert limiter.total_tokens == 1

    async def test_acquire_cancelled(self) -> None:
        # Regression test for #947
        limiter = CapacityLimiter(1)

        async def borrower(
            event: Event, *, task_status: TaskStatus[CancelScope]
        ) -> None:
            with CancelScope() as scope:
                task_status.started(scope)
                async with limiter:
                    event.set()
                    await checkpoint()

        async with create_task_group() as tg:
            async with limiter:
                event1 = Event()
                scope1 = await tg.start(borrower, event1)
                event2
…[8557 chars omitted]…
() -> None:
        pass

    async def main() -> weakref.ref[object]:
        # Exercising to_thread.run_sync() triggers find_root_task(), which caches
        # the root task (and thus the loop) in the run-vars mapping.
        await to_thread.run_sync(thread_worker)
        return weakref.ref(asyncio.get_running_loop())

    loop_ref = anyio.run(main)

    gc.collect()
    assert loop_ref() is None

* master
/repo/src/anyio/__init__.py 
Name: anyio
Version: 4.0.0
Summary: High-level concurrency and networking framework on top of asyncio or Trio
Home-page: 
Author: 
Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
License-Expression: MIT
Location: /usr/local/lib/python3.12/site-packages
Editable project location: /repo
Requires: idna, typing_extensions

Required-by:

return self._semaphore.value

    @property
    def max_value(self) -> int | None:
        return self._max_value

    def statistics(self) -> SemaphoreStatistics:
        if self._internal_semaphore is None:
            return SemaphoreStatistics(tasks_waiting=0)

        return self._semaphore.statistics()

class CapacityLimiter:
    __slots__ = ("__weakref__",)

    def __new__(cls, total_tokens: float) -> CapacityLimiter:
        try:
            return get_async_backend().create_capacity_limiter(total_tokens)
        except NoEventLoopError:
            return CapacityLimiterAdapter(total_tokens)

    async def __aenter__(self) -> None:
        raise NotImplementedError

    async def __aexit__(
        self,
        exc_type: type[BaseException] | None,
        exc_val: BaseException | None,
        exc_tb: TracebackType | None,
    ) -> None:
        raise NotImplemen
…[2974 chars omitted]…
total_tokens: float) -> None:
        self._internal_limiter: CapacityLimiter | None = None
        self.total_tokens = total_tokens

    @property
    def _limiter(self) -> CapacityLimiter:
        if self._internal_limiter is None:
            self._internal_limiter = get_async_backend().create_capacity_limiter(
                self._total_tokens
            )

        return self._internal_limiter

timeout: failed to run command ‘curl’: No such file or directory

<class 'urllib.error.URLError'> <urlopen error [Errno -3] Temporary failure in name resolution>

tests/conftest.py:39:    if hasattr(asyncio.AbstractEventLoop, "shutdown_default_executor") and not hasattr(
tests/conftest.py:40:        uvloop.loop.Loop, "shutdown_default_executor"
tests/conftest.py:44:                reason=f"{uvloop_name} is missing shutdown_default_executor()"
tests/conftest.py:172:    loop.close()
tests/streams/test_buffered.py:29:    send_stream.close()
tests/streams/test_buffered.py:30:    receive_stream.close()
tests/streams/test_buffered.py:37:    await send_stream.aclose()
tests/streams/test_buffered.py:41:    send_stream.close()
tests/streams/test_buffered.py:42:    receive_stream.close()
tests/streams/test_buffered.py:59:    send_stream.close()
tests/streams/test_buffered.py:60:    receive_stream.close()
tests/streams/test_buffered.py:67:    await send_stream.aclose()

tests/streams/test_buffered.py:73:    send_stream.close()
tests/streams/test_buffered.p
…[8629 chars omitted]…
y:1657:            client.close()
tests/test_sockets.py:1673:                client.shutdown(socket.SHUT_WR)
tests/test_sockets.py:1722:        await stream.aclose()
tests/test_sockets.py:1757:                    await stream.aclose()
tests/test_sockets.py:1798:            await udp.aclose()
tests/test_sockets.py:1893:            await udp.aclose()
tests/test_sockets.py:1909:        await udp.aclose()

from __future__ import annotations

import asyncio
import gc
import sys
import threading
import time
import weakref
from concurrent.futures import Future, ThreadPoolExecutor
from contextvars import ContextVar
from functools import partial
from typing import Any, NoReturn

import pytest

import anyio.to_thread
from anyio import (
    CapacityLimiter,
    Event,
    create_task_group,
    from_thread,
    to_thread,
    wait_all_tasks_blocked,
)
from anyio._core._eventloop import current_async_library
from anyio.from_thread import BlockingPortalProvider
from anyio.lowlevel import checkpoint

from .conftest import asyncio_params, no_other_refs


async def test_run_in_thread_cancelled() -> None:
    state = 0

    def thread_worker() -> None:
        nonlocal state
        state = 2

    async def worker() -> None:
        nonlocal state
        state = 1
        await to_thread.run_sync(
…[8629 chars omitted]…
io")

        def worker() -> str:
            sniffio.current_async_library_cvar.set("something invalid for async_func")
            return from_thread.run_sync(sniffio.current_async_library)

        assert await to_thread.run_sync(worker) == anyio_backend_name


class TestBlockingPortal:
    class AsyncCM:
        def __init__(self, ignore_error: bool):
            self.ignore_error = ignore_error

await to_thread.run_sync(
            from_thread.run, async_time_bomb, abandon_on_cancel=True
        )

    assert cancel_scope.cancelled_caught
    host_cancelled_event.set()
    with fail_after(3):
        await completed_event.wait()


class TestRunAsyncFromThread:
    async def test_run_corofunc_from_thread(self) -> None:

        result = await to_thread.run_sync(thread_worker_async, async_add, 1, 2)
        assert result == 3

    async def test_run_asyncgen_from_thread(self) -> None:
        gen = asyncgen_add(1, 2)
        try:
            result = await to_thread.run_sync(thread_worker_async, gen.__anext__)
            assert result == 3
        finally:
            await gen.aclose()

    async def test_run_sync_from_thread(self) -> None:
        result = await to_thread.run_sync(thread_worker_sync, sync_add, 1, 2)
        assert result == 3

    async def test_run_
…[6682 chars omitted]…
p()
    else:
        loop = asyncio.new_event_loop()

    yield loop

    loop.close()


if sys.version_info >= (3, 14):

    def no_other_refs() -> list[object]:
        return [sys._getframe(1).f_generator]

elif sys.version_info >= (3, 11):

    def no_other_refs() -> list[object]:
        return []
else:

    def no_other_refs() -> list[object]:
        return [sys._getframe(1)]


@pytest.fixture

Refused: `find /` walks the whole container FS. Scope under /repo.

total 12
drwxr-xr-x 3 root root 4096 Nov  4 21:33 .
drwx------ 1 root root 4096 Nov  4 21:33 ..
drwxr-xr-x 5 root root 4096 Nov  4 21:33 pip
/root/.cache/pip/selfcheck/fe300af6f7d708c14827daac3afc81fbb8306b73de8dd6e3f1f8ea3b
__editable__.anyio-4.0.0.pth
anyio-4.0.0.dist-info

b6e3d9b refs/heads/master@{0}: commit (initial): base
b6e3d9b HEAD@{0}: commit (initial): base
count: 129
size: 624
in-pack: 0
packs: 0
size-pack: 0
prune-packable: 0
garbage: 0
size-garbage: 0

21:from asyncio.base_events import _run_until_complete_cb  # type: ignore[attr-defined]
165:                loop.run_until_complete(loop.shutdown_asyncgens())
167:                    loop.run_until_complete(loop.shutdown_default_executor())
169:                    loop.run_until_complete(_shutdown_default_executor(loop))
182:        def run(self, coro: Coroutine[T_Retval], *, context=None) -> T_Retval:
216:                return self._loop.run_until_complete(task)
266:        loop.run_until_complete(tasks.gather(*to_cancel, return_exceptions=True))
308:_root_task: RunVar[asyncio.Task[Any] | None] = RunVar("_root_task")
311:def find_root_task() -> asyncio.Task:
312:    root_task = _root_task.get(None)
313:    if root_task is not None and not root_task.done():
314:        return root_task

316:    # Look for a task that has been started via run_until_complete()
321:                    cb
…[8629 chars omitted]…
eturn self._cancel_called

    @property
    def cancelled_caught(self) -> bool:
        return self._cancelled_caught

    @property
    def shield(self) -> bool:
        return self._shield

    @shield.setter
    def shield(self, value: bool) -> None:
        if self._shield != value:
            self._shield = value
            if not value:
                self._restart_cancellation_in_parent()

from __future__ import annotations

import array
import asyncio
import concurrent.futures
import math
import os
import socket
import sys
import threading
import weakref
from asyncio import (

    AbstractEventLoop,
    CancelledError,
    all_tasks,
    create_task,
    current_task,
    get_running_loop,
    sleep,
)
from asyncio.base_events import _run_until_complete_cb  # type: ignore[attr-defined]
from collections import OrderedDict, deque
from collections.abc import (
    AsyncGenerator,
    AsyncIterator,
    Awaitable,
    Callable,
    Collection,
    Coroutine,
    Iterable,
    Sequence,
)
from concurrent.futures import Future
from contextlib import AbstractContextManager
from contextvars import Context, copy_context
from dataclasses import dataclass, field
from functools import partial, wraps
from inspect import (
    CORO_RUNNING,
    CORO_SUSPENDED,
    getcoroutinestate,

…[8629 chars omitted]…
o.Task, cancel_scope._host_task)

    return task


def _task_started(task: asyncio.Task) -> bool:
    """Return ``True`` if the task has been started and has not finished."""
    # The task coro should never be None here, as we never add finished tasks to the
    # task list
    coro = task.get_coro()
    assert coro is not None
    return getcoroutinestate(coro) in (CORO_RUNNING, CORO_SUSPENDED)


#

# loop is re-entered during async generator fixture teardown.
            if self._runner_task is not None and not self._runner_task.done():
                self._runner_task.cancel()
                self._send_stream.close()
                try:
                    self.get_loop().run_until_complete(self._runner_task)
                except CancelledError:
                    pass
                finally:
                    self._runner_task = None
            raise
        self._raise_async_exceptions()

class _ProcessStreamProtocol(asyncio.subprocess.SubprocessStreamProtocol):
    """
    A subprocess protocol that allows us to be notified of ``process_exited``

    asyncio's own ``Process.wait()`` only resolves once every pipe transport has
    disconnected so to get same semantics as on trio and uvloop we need this.
    """

    def __init__(self) -> None:
        #
…[6098 chars omitted]…
    transport.pause_reading()
        return SocketStream(transport, protocol)

    @classmethod
    async def connect_unix(cls, path: str | bytes) -> abc.UNIXSocketStream:
        await cls.checkpoint()
        loop = get_running_loop()
        raw_socket = socket.socket(socket.AF_UNIX)
        raw_socket.setblocking(False)
        while True:
            try:
                raw_socket.connect(path)

45:from queue import Queue
299:            thread.join()
836:        def task_done(_task: asyncio.Task) -> None:
910:        task.add_done_callback(task_done)
1001:        self.queue: Queue[
1028:                item = self.queue.get()
1052:                self.queue.task_done()
1057:        self.queue.put_nowait(None)
1249:    read_queue: deque[bytes]
1256:        self.read_queue = deque()
1271:        self.read_queue.append(bytes(data))
1287:    read_queue: deque[tuple[bytes, IPSockAddrType]]

1294:        self.read_queue = deque(maxlen=100)  # arbitrary value
1307:        self.read_queue.append((data, addr))
1349:                chunk = self._protocol.read_queue.popleft()
1361:                self._protocol.read_queue.appendleft(leftover)
1363:            # If the read queue is empty, clear the flag so that the next call will
1365:            if not self._protocol.read_queue:
1696: 
…[1565 chars omitted]…
/_asyncio.py:1065:_threadpool_idle_workers: RunVar[deque[WorkerThread]] = RunVar(
src/anyio/_backends/_asyncio.py:1068:_threadpool_workers: RunVar[set[WorkerThread]] = RunVar("_threadpool_workers")
src/anyio/_backends/_asyncio.py:2612:                    worker = WorkerThread(root_task, workers, idle_workers)
src/anyio/_backends/_asyncio.py:2625:                            < WorkerThread.MAX_IDLE_TIME

initial CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('A', 'B'), tasks_waiting=1) 0
reduced CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=1, borrowers=('A', 'B'), tasks_waiting=1) -1
raised CapacityLimiterStatistics(borrowed_tokens=3, total_tokens=2, borrowers=('A', 'C', 'B'), tasks_waiting=0) -1
after wait CapacityLimiterStatistics(borrowed_tokens=3, total_tokens=2, borrowers=('A', 'C', 'B'), tasks_waiting=0) -1 event True
  + Exception Group Traceback (most recent call last):
  |   File "/tmp/repro_capacity.py", line 34, in <module>
  |     anyio.run(main, backend="asyncio")
  |   File "/repo/src/anyio/_core/_eventloop.py", line 83, in run
  |     return async_backend.run(func, args, {}, backend_options)
  |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |   File "/repo/src/anyio/_backends/_asyncio.py", line 2485, in run
  |    

…[843 chars omitted]…
1 sub-exception)
  +-+---------------- 1 ----------------
    | Traceback (most recent call last):
    |   File "/tmp/repro_capacity.py", line 24, in main
    |     assert limiter.borrowed_tokens <= limiter.total_tokens, (limiter.borrowed_tokens, limiter.total_tokens)
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    | AssertionError: (3, 2)
    +------------------------------------

grep: src/anyio/_backends/__pycache__/_asyncio.cpython-312.pyc: binary file matches
src/anyio/_backends/_asyncio.py:254:                self._loop.call_soon_threadsafe(lambda: None)
src/anyio/_backends/_asyncio.py:286:                loop.call_soon_threadsafe(future.set_result, None)
src/anyio/_backends/_asyncio.py:288:                loop.call_soon_threadsafe(future.set_exception, ex)
src/anyio/_backends/_asyncio.py:1045:                    if not self.loop.is_closed():
src/anyio/_backends/_asyncio.py:1046:                        self.loop.call_soon_threadsafe(
src/anyio/_backends/_asyncio.py:2681:        if loop.is_closed():
src/anyio/_backends/_asyncio.py:2712:        if loop.is_closed():
src/anyio/_backends/_asyncio.py:2716:        loop.call_soon_threadsafe(wrapper)
src/anyio/_core/_asyncio_selector_thread.py:146:                        loop.call_soon_threadsafe(callback)
src/anyio/_core/_asyncio_selector_thread.py:154:                        loop.call_soon_threadsafe(callback)

diff --git a/src/anyio/_backends/_asyncio.py b/src/anyio/_backends/_asyncio.py
index 726cfb9..56b6777 100644
--- a/src/anyio/_backends/_asyncio.py
+++ b/src/anyio/_backends/_asyncio.py
@@ -1042,10 +1042,16 @@ class WorkerThread(Thread):
                     finally:
                         del threadlocals.current_cancel_scope
 
-                    if not self.loop.is_closed():
+                    try:
                         self.loop.call_soon_threadsafe(
                             self._report_result, future, result, exception

                         )
+                    except RuntimeError:
+                        # The event loop was closed while the result was being
+                        # reported. There is no longer any task waiting for the
+                        # result, so just let the worker thread shut down.
+                        if not self.loop.is_clos
…[69 chars omitted]…
esult, exception
 
@@ -2082,7 +2088,7 @@ class CapacityLimiter(BaseCapacityLimiter):
         if value < 0:
             raise ValueError("total_tokens must be >= 0")
 
-        waiters_to_notify = max(value - self._total_tokens, 0)
+        waiters_to_notify = max(value - len(self._borrowers), 0)
         self._total_tokens = value
 
         # Notify waiting tasks that they have acquired the limiter

uvloop ModuleSpec(name='uvloop', loader=<_frozen_importlib_external.SourceFileLoader object at 0x7f1a91ee7080>, origin='/usr/local/lib/python3.12/site-packages/uvloop/__init__.py', submodule_search_locations=['/usr/local/lib/python3.12/site-packages/uvloop'])
trio ModuleSpec(name='trio', loader=<_frozen_importlib_external.SourceFileLoader object at 0x7f1a91ee5b20>, origin='/usr/local/lib/python3.12/site-packages/trio/__init__.py', submodule_search_locations=['/usr/local/lib/python3.12/site-packages/trio'])
initial CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('A', 'B'), tasks_waiting=1) 0
reduced CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=1, borrowers=('A', 'B'), tasks_waiting=1) -1
raised CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('A', 'B'), tasks_waiting=1) 0
after wait CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('A', 'B'), tasks_waiting=1) 0 event False
after release CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('C', 'B'), tasks_waiting=0) 0 event True
OK

179:def claim_worker_thread(

def get_cancelled_exc_class() -> type[BaseException]:
    """
    Return the current async library's cancellation exception class.

    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
        current thread

    """
    return get_async_backend().cancelled_exception_class()


#

# Private API
#


@contextmanager
def claim_worker_thread(
    backend_class: type[AsyncBackend], token: object
) -> Generator[Any, None, None]:
    from ..lowlevel import EventLoopToken

    threadlocals.current_token = EventLoopToken(backend_class, token)
    try:
        yield
    finally:
        del threadlocals.current_token


def get_async_backend(asynclib_name: str | None = None) -> type[AsyncBackend]:
    if asynclib_name is None:
        asynclib_name = current_async_library()
        if not asynclib_name:
            raise NoEventLoopError(
                f"Not 
…[873 chars omitted]…
or:
            pass
    else:
        try:
            return sniffio.current_async_library()
        except sniffio.AsyncLibraryNotFoundError:
            pass

    return None


def set_current_async_library(asynclib_name: str | None) -> Token | None:
    # no-op if sniffio is not installed
    if sniffio is None:
        return None

    return sniffio.current_async_library_cvar.set(asynclib_name)

Traceback (most recent call last):
  File "/tmp/repro_worker.py", line 15, in <module>
    worker = WorkerThread(Root(), workers, idle_workers)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/anyio/_backends/_asyncio.py", line 1004, in __init__
    self.idle_since = AsyncIOBackend.current_time()
                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/anyio/_backends/_asyncio.py", line 2499, in current_time
    return get_running_loop().time()
           ^^^^^^^^^^^^^^^^^^
RuntimeError: no running event loop

alive: False
thread exceptions: []
OK

Exception in thread AnyIO worker thread:
Traceback (most recent call last):
  File "/usr/local/lib/python3.12/threading.py", line 1075, in _bootstrap_inner
    self.run()
  File "/repo/src/anyio/_backends/_asyncio.py", line 1046, in run
    self.loop.call_soon_threadsafe(
  File "/tmp/repro_worker.py", line 33, in close_then_schedule
    return original_call_soon_threadsafe(callback, *args, **kwargs)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/asyncio/base_events.py", line 844, in call_soon_threadsafe
    self._check_closed()
  File "/usr/local/lib/python3.12/asyncio/base_events.py", line 545, in _check_closed

    raise RuntimeError('Event loop is closed')
RuntimeError: Event loop is closed
alive: False
thread exceptions: [RuntimeError('Event loop is closed')]
Traceback (most recent call last):
  File "/tmp/repro_worker.py", line 45, in <module>
    assert not thread_exceptions
           ^^^^^^^^^^^^^^^^^^^^^
AssertionError

........................................................................ [ 50%]
......................................................................   [100%]

closed True
<class 'RuntimeError'> RuntimeError('Event loop is closed')

tests/test_eventloop.py:89:    monkeypatch.setattr("anyio._core._eventloop.BACKENDS", ("asyncio", "somebackend"))

........................................................................ [ 13%]
........................................................................ [ 26%]
........................................................................ [ 40%]
........................................................................ [ 53%]
........................................................................ [ 67%]
........................................................................ [ 80%]
........................................................................ [ 94%]
..............ssss.......x....                                           [100%]
=========================== short test summary info ============================
SKIPPED [4] tests/test_from_thread.py:744: This test is known to hang often on CI
529 passed, 4 skipped, 1 xfailed in 33.15s

For variant 'global', will try loading '/etc/xdg/pip/pip.conf'
For variant 'global', will try loading '/etc/pip.conf'
For variant 'user', will try loading '/root/.pip/pip.conf'
For variant 'user', will try loading '/root/.config/pip/pip.conf'
For variant 'site', will try loading '/usr/local/pip.conf'
/opt:
/root/.cache/pip/selfcheck/fe300af6f7d708c14827daac3afc81fbb8306b73de8dd6e3f1f8ea3b
/root/.cache/pip/wheels/eb/1b/4e/1720775f695118457d0692cea72b8be2b8af2a7bae46611e93/origin.json
/root/.cache/pip/wheels/eb/1b/4e/1720775f695118457d0692cea72b8be2b8af2a7bae46611e93/forbiddenfruit-0.1.4-py3-none-any.whl
/root/.cache/pip/http-v2/1/6/2/f/0/162f02b59107f7f8725a208a8de4172a22557991b6f4dc5cc182b640
/root/.cache/pip/http-v2/1/6/2/f/0/162f02b59107f7f8725a208a8de4172a22557991b6f4dc5cc182b640.body
/root/.cache/pip/http-v2/1/9/3/d/2/193d2b14cf4cd704ac983a718ec8edac2afad38c2e26f3f739d3d911.body

/
…[917 chars omitted]…
8a6dd43d688fbb4aa1959.body
/root/.cache/pip/http-v2/b/c/9/7/8/bc978b74c647a5f4011ebd1fe3778a9c54d8a6dd43d688fbb4aa1959
/root/.cache/pip/http-v2/b/8/e/6/d/b8e6d5935f9ced55635d32bdf46f328b37f77b0474abe35d0a0dbc83.body
/root/.cache/pip/http-v2/b/8/e/6/d/b8e6d5935f9ced55635d32bdf46f328b37f77b0474abe35d0a0dbc83
/root/.cache/pip/http-v2/0/1/b/7/d/01b7d4043eec23dae6770db5094ffe5a6ba4bcc9773c36321eaf057a.body

bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found

bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found
bash: line 25: file: command not found

…[6117 chars omitted]…
t/.cache/pip/http-v2/4/4/e/5/b/44e5b11a6caa92636d8ccfe658d420ba4ed8f67f7f4e835b214255aa.body
14382  /root/.cache/pip/http-v2/f/e/4/6/9/fe4691faa9e2488e2ca672e8bdbe67679ace3c7631712569df6f3d05.body
13647  /root/.cache/pip/http-v2/4/0/9/d/e/409de3089c23a2d9bdfcf659da8819657f68822c4230bb8354ab0a1a.body
12284  /root/.cache/pip/http-v2/a/5/8/9/5/a58953210230b599c79eba773cad2f5b2551514be1c7ca153952a2ac.body

50628 /root/.cache/pip/http-v2/1/9/3/d/2/193d2b14cf4cd704ac983a718ec8edac2afad38c2e26f3f739d3d911.body TGZ? invalid header
129956 /root/.cache/pip/http-v2/b/1/1/9/0/b11909f451f61fb29636217082b1c638b177c59eac335e0200a136e6.body ZIP packaging/__init__.py, packaging/_elffile.py, packaging/_manylinux.py
67548 /root/.cache/pip/http-v2/b/1/4/e/c/b14ec1286f8ec83b268f9c52cdccd1001d22496d6e01ba5b4fd8aeb4.body ZIP attr/__init__.py, attr/__init__.pyi, attr/_cmp.py
62600 /root/.cache/pip/http-v2/b/4/d/c/4/b4dc47ae9d349a950bbc69678b6f001f8a20486e60aee5a2e1823fed.body ZIP pycparser/__init__.py, pycparser/_ast_gen.py, pycparser/_c_ast.cfg
155560 /root/.cache/pip/http-v2/b/5/0/1/6/b50161ce80a3ddd3f50977d5414a93660648823b703e10f65f16eeeb.body ZIP psutil/, psutil/__init__.py, psutil/_common.py
942910 /root/.cache/pip/http-v2/b/c/9/7/8/bc978b74c647a5f4011ebd1fe3778a9c54d8a6dd43d688fbb4aa1959.body TGZ? i
…[7077 chars omitted]…
4/b/d/f/74bdf372f3d845193f395b9ba4ed91510cd09dc32621fc25fe02568d.body TGZ? invalid header
22817 /root/.cache/pip/http-v2/7/a/5/f/7/7a5f717e7b3fb99ec006f4d173aad55224eb063005c662c586ba0518.body TGZ? invalid header
43756 /root/.cache/pip/http-v2/7/9/9/3/b/7993b93da9e60a77ea15f912f32e4e3694911b17b768dfdd65b60495.body TGZ forbiddenfruit-0.1.4, forbiddenfruit-0.1.4/COPYING, forbiddenfruit-0.1.4/COPYING.mit

===/usr/lib/python3
===/usr/local/lib/python3.12
/usr/local/lib/python3.12/site-packages/trio/_core/_thread_cache.py
===/opt
===/root
===/tmp

alive: False
thread exceptions: []
OK
initial CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('B', 'A'), tasks_waiting=1) 0
reduced CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=1, borrowers=('B', 'A'), tasks_waiting=1) -1
raised CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('B', 'A'), tasks_waiting=1) 0
after wait CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('B', 'A'), tasks_waiting=1) 0 event False
after release CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('B', 'C'), tasks_waiting=0) 0 event True
OK
 src/anyio/_backends/_asyncio.py | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

/usr/local/bin/python: No module named ruff
/usr/local/bin/python: No module named ruff

330:111:                    # Register a callback to break the task -> loop -> _run_var[loop][_root_task] -> task cycle
332:91:                    # We can't use RunVar.reset() here since these are called synchronously
333:96:                    # and thus lowlevel.current_token() (which RunVar.reset() depends on) fails.
495:89:            # directly as exc_val or inside an exception group and there are no cancelled
790:89:                                # Shield the scope against further cancellation attempts,
796:91:                                # previously unset. However, we should not replace a native
797:90:                                # cancellation exception with one raise by a cancel scope.
806:89:                    # If there are no child tasks to wait on, run at least one checkpoint
1210:91:    child_watcher: asyncio.AbstractChildWatcher | None = None  # type: ignore[name-defined]
2426:100:            # A BaseException (e.g. KeyboardInterrupt, SystemExit) interrupted the event loop before
2427:90:            # the test completed. Cancel _runner_task so it does not resume when the event
2784:94:            partial(_forcibly_shutdown_process_pool_on_exit, workers)  # type:ignore[arg-type]

reduced CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=1, borrowers=('B', 'A'), tasks_waiting=1) -1
raised CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('B', 'A'), tasks_waiting=1) 0
after wait CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('B', 'A'), tasks_waiting=1) 0 event False
after release CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('B', 'C'), tasks_waiting=0) 0 event True
OK
initial CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('B', 'A'), tasks_waiting=1) 0
reduced CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=1, borrowers=('B', 'A'), tasks_waiting=1) -1
raised CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('B', 'A'), tasks_waiting=1) 0
after wait CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('B', 'A'), tasks_waiting=1) 0 event False
after release CapacityLimiterStatistics(borrowed_tokens=2, total_tokens=2, borrowers=('C', 'B'), tasks_waiting=0) 0 event True
OK

diff --git a/src/anyio/_backends/_asyncio.py b/src/anyio/_backends/_asyncio.py
index 726cfb9..0ba71ab 100644
--- a/src/anyio/_backends/_asyncio.py
+++ b/src/anyio/_backends/_asyncio.py
@@ -1043,9 +1043,17 @@ class WorkerThread(Thread):
                         del threadlocals.current_cancel_scope
 
                     if not self.loop.is_closed():
-                        self.loop.call_soon_threadsafe(
-                            self._report_result, future, result, exception
-                        )
+                        try:

+                            self.loop.call_soon_threadsafe(
+                                self._report_result, future, result, exception
+                            )
+                        except RuntimeError:
+                            # The event loop was closed after the check above but
+                            # before the callback cou
…[333 chars omitted]…
,7 @@ class CapacityLimiter(BaseCapacityLimiter):
         if value < 0:
             raise ValueError("total_tokens must be >= 0")
 
-        waiters_to_notify = max(value - self._total_tokens, 0)
+        waiters_to_notify = max(value - len(self._borrowers), 0)
         self._total_tokens = value
 
         # Notify waiting tasks that they have acquired the limiter
 M src/anyio/_backends/_asyncio.py

FAILED tests/test_sockets.py::TestUDPSocket::test_close_during_receive[asyncio+eager-ipv6]
FAILED tests/test_sockets.py::TestUDPSocket::test_close_during_receive[trio-ipv4]
FAILED tests/test_sockets.py::TestUDPSocket::test_close_during_receive[trio-ipv6]
FAILED tests/test_sockets.py::TestUDPSocket::test_receive_after_close[asyncio-ipv4]
FAILED tests/test_sockets.py::TestUDPSocket::test_receive_after_close[asyncio-ipv6]
FAILED tests/test_sockets.py::TestUDPSocket::test_receive_after_close[asyncio+uvloop-ipv4]
FAILED tests/test_sockets.py::TestUDPSocket::test_receive_after_close[asyncio+uvloop-ipv6]
FAILED tests/test_sockets.py::TestUDPSocket::test_receive_after_close[asyncio+eager-ipv4]
FAILED tests/test_sockets.py::TestUDPSocket::test_receive_after_close[asyncio+eager-ipv6]
FAILED tests/test_sockets.py::TestUDPSocket::test_receive_after_close[trio-ipv4]
FAILED tests/test_sockets.py::T
…[5806 chars omitted]…

[trio-ipv6]
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, 3886 passed, 110 skipped, 5 xfailed in 388.59s (0:06:28)

[end of output]
  
  note: This error originates from a subprocess, and is likely not a problem with pip.
error: subprocess-exited-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 ============================
SKIPPED [1] tests/test_debugging.py:104: Generator based coroutines have been removed in Python 3.11

SKIPPED [1] tests/test_eventloop.py:134: winloop not installed
SKIPPED [1] tests/test_fileio.py:202: Drive only makes sense on Windows
SKIPPED [1] tests/test_fileio.py:247: Only makes sense on Windows
SKIPPED [8] tests/test_fileio.py:259: Path.from_uri() is only available on Python 3.13+
SKIPPED [4] tests/test_fileio.py:317: Could not find a suitable block device

…[1610 chars omitted]…
[6] tests/test_taskgroups.py:2145: Requires Python 3.14
SKIPPED [4] tests/test_to_interpreter.py:27: requires Python 3.13+
SKIPPED [4] tests/test_to_interpreter.py:42: requires Python 3.13+
SKIPPED [4] tests/test_to_interpreter.py:48: requires Python 3.13+
FAILED tests/test_lazyimport.py::test_sourceless_install - subprocess.CalledP...
1 failed, 2817 passed, 110 skipped, 5 xfailed in 240.32s (0:04:00)

+ Exception Group Traceback (most recent call last):
  |   File "/tmp/check_capacity_sequences.py", line 43, in <module>
  |     anyio.run(main, backend="asyncio")
  |   File "/repo/src/anyio/_core/_eventloop.py", line 83, in run
  |     return async_backend.run(func, args, {}, backend_options)
  |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |   File "/repo/src/anyio/_backends/_asyncio.py", line 2493, in run
  |     return runner.run(wrapper())
  |            ^^^^^^^^^^^^^^^^^^^^^
  |   File "/usr/local/lib/python3.12/asyncio/runners.py", line 118, in run
  |     return self._loop.run_until_complete(task)
  |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  |   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", li
…[626 chars omitted]…
heck_capacity_sequences.py", line 29, in scenario
    |     assert limiter.borrowed_tokens <= limiter.total_tokens, (v, limiter.statistics())
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    | AssertionError: (2, CapacityLimiterStatistics(borrowed_tokens=3, total_tokens=2, borrowers=('borrower0', 'borrower2', 'borrower1'), tasks_waiting=3))
    +------------------------------------

OK

commit b6e3d9bf5ca88155e723216790f62e468c92aef4
Author:     benchgen <sandbox@benchgen>
AuthorDate: Wed Nov 4 21:32:40 2026 +0000
Commit:     benchgen <sandbox@benchgen>
CommitDate: Wed Nov 4 21:32:40 2026 +0000

    base
6:**UNRELEASED**
7-
8-- Added support for the newer keyword-only arguments on ``anyio.Path`` methods to match
9-  the standard library ``pathlib.Path``:

tests/test_eventloop.py:10:from unittest.mock import AsyncMock
tests/test_eventloop.py:23:def fake_sleep() -> Generator[AsyncMock, None, None]:
tests/test_eventloop.py:28:        mock.patch("anyio._core._eventloop.sleep", AsyncMock()) as v,
tests/test_eventloop.py:33:async def test_sleep_until(fake_sleep: AsyncMock) -> None:
tests/test_eventloop.py:39:async def test_sleep_until_in_past(fake_sleep: AsyncMock) -> None:
tests/test_eventloop.py:45:async def test_sleep_forever(fake_sleep: AsyncMock) -> None:
tests/test_eventloop.py:85:def test_run_known_but_uninstalled_backend(monkeypatch: MonkeyPatch) -> None:
tests/test_eventloop.py:89:    monkeypatch.setattr("anyio._core._eventloop.BACKENDS", ("asyncio", "somebackend"))
tests/test_eventloop.py:102:    def test_debug_via_env(self, monkeypatch: MonkeyPatch) -> None:
tests/test_eventloop.py:106:        monkeypatch.setenv("PYTHONASYNCIODEBU
…[390 chars omitted]…
ts.cpython-312-pytest-9.2.0.pyc: binary file matches

grep: tests/__pycache__/test_subprocesses.cpython-312-pytest-9.2.0.pyc: binary file matches
grep: tests/__pycache__/test_taskgroups.cpython-312-pytest-9.2.0.pyc: binary file matches
grep: tests/__pycache__/test_to_process.cpython-312-pytest-9.2.0.pyc: binary file matches
grep: tests/__pycache__/test_to_process.cpython-312.pyc: binary file matches
23

# Generated by Docker Engine.
# This file can be edited; Docker Engine will not make further changes once it
# has been modified.

nameserver 192.168.65.7

# Based on host file: '/etc/resolv.conf' (legacy)
# Overrides: []

def call_soon_threadsafe(self, callback, *args, context=None):
        """Like call_soon(), but thread-safe."""
        self._check_closed()
        if self._debug:
            self._check_callback(callback, 'call_soon_threadsafe')
        handle = self._call_soon(callback, args, context)
        if handle._source_traceback:
            del handle._source_traceback[-1]
        self._write_to_self()
        return handle

    def _check_callback(self, callback, method):

        if (coroutines.iscoroutine(callback) or
                coroutines.iscoroutinefunction(callback)):
            raise TypeError(
                f"coroutines cannot be used with {method}()")
        if not callable(callback):
            raise TypeError(
                f'a callable object was expected by {method}(), '
                f'got {callback!r}')

def _call_soon(self, callback, args, context):
        handle = events.Handle(callback, args, self, context)
        if handle._source_traceback:
            del handle._source_traceback[-1]
        self._ready.append(handle)
        return handle

alive: False
thread exceptions: []
OK
 src/anyio/_backends/_asyncio.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

alive: False exceptions: []
OK

........................................................................ [ 20%]
........................................................................ [ 40%]
........................................................................ [ 61%]
........................................................................ [ 81%]
..................................................ssss.......x....       [100%]
=========================== short test summary info ============================
SKIPPED [4] tests/test_from_thread.py:744: This test is known to hang often on CI
349 passed, 4 skipped, 1 xfailed in 22.05s

alive: False exceptions: []
OK

M src/anyio/_backends/_asyncio.py

total 68
drwxr-xr-x   1 root root 4096 Nov  4 21:32 .
drwxr-xr-x   1 root root 4096 Nov  4 21:32 ..
-rwxr-xr-x   1 root root    0 Nov  4 21:32 .dockerenv
lrwxrwxrwx   1 root root    7 Jul  4 09:05 bin -> usr/bin
drwxr-xr-x   2 root root 4096 Jul  4 09:05 boot
drwxr-xr-x   5 root root  340 Nov  4 21:32 dev
drwxr-xr-x   1 root root 4096 Nov  4 21:33 etc
drwxr-xr-x   2 root root 4096 Jul  4 09:05 home
lrwxrwxrwx   1 root root    7 Jul  4 09:05 lib -> usr/lib
lrwxrwxrwx   1 root root    9 Jul  4 09:05 lib64 -> usr/lib64
drwxr-xr-x   2 root root 4096 Aug  3 00:00 media

drwxr-xr-x   2 root root 4096 Aug  3 00:00 mnt
drwxr-xr-x   2 root root 4096 Aug  3 00:00 opt
dr-xr-xr-x 319 root root    0 Nov  4 21:32 proc
drwxr-xr-x   1 root root 4096 Nov  4 21:36 repo
drwx------   1 root root 4096 Nov  4 21:33 root
drwxr-xr-x   1 root root 4096 Nov  4 21:33 run
lrwxrwxrwx   1 root root    8 Jul  4 09:0
…[372 chars omitted]…
 1657 Nov  4 21:48 check_capacity_sequences.py
-rw-r--r-- 1 root root    0 Nov  4 21:33 install.log
drwx------ 4 root root 4096 Nov  4 21:44 pytest-of-root
-rw-r--r-- 1 root root 1485 Nov  4 21:37 repro_capacity.py
-rw-r--r-- 1 root root 1334 Nov  4 21:35 repro_worker.py
-rw-r--r-- 1 root root  815 Nov  4 21:50 repro_worker_closed_before.py
-rw-r--r-- 1 root root  974 Nov  4 21:49 repro_worker_mock.py

diff --git a/src/anyio/_backends/_asyncio.py b/src/anyio/_backends/_asyncio.py
index 726cfb9..9b81655 100644
--- a/src/anyio/_backends/_asyncio.py
+++ b/src/anyio/_backends/_asyncio.py
@@ -1043,9 +1043,16 @@ class WorkerThread(Thread):
                         del threadlocals.current_cancel_scope
 
                     if not self.loop.is_closed():
-                        self.loop.call_soon_threadsafe(
-                            self._report_result, future, result, exception
-                        )
+                        try:

+                            self.loop.call_soon_threadsafe(
+                                self._report_result, future, result, exception
+                            )
+                        except RuntimeError:
+                            # The event loop was closed after the check above but
+                            # before the callback cou
…[2461 chars omitted]…
lf._total_tokens = value

        # Notify waiting tasks that they have acquired the limiter
        while self._wait_queue and waiters_to_notify:
            borrower, event = self._wait_queue.popitem(last=False)
            self._borrowers.add(borrower)
            event.set()
            waiters_to_notify -= 1

    @property
    def borrowed_tokens(self) -> int:
        return len(self._borrowers)

…[353 chars omitted]…
imiter and to_thread/from_thread test suites (349 passed), and the broader suite (only pre-existing environment-related socket/DNS and lazy-import install failures)."}
submitted.

/repo
total 28
drwxr-xr-x 1 root root 4096 Nov  2 07:14 .
drwxr-xr-x 1 root root 4096 Nov  2 07:14 ..
drwxr-xr-x 1 root root 4096 Nov  2 07:14 .git
drwxr-xr-x 1 root root 4096 Nov  2 07:13 .github
-rw-r--r-- 1 root root  183 Nov  2 07:13 .gitignore
-rw-r--r-- 1 root root 1399 Nov  2 07:13 .pre-commit-config.yaml
-rw-r--r-- 1 root root  312 Nov  2 07:13 .readthedocs.yml
-rw-r--r-- 1 root root 3923 Nov  2 07:13 AGENTS.md
-rw-r--r-- 1 root root   11 Nov  2 07:13 CLAUDE.md
-rw-r--r-- 1 root root 1081 Nov  2 07:13 LICENSE

-rw-r--r-- 1 root root 3272 Nov  2 07:13 README.rst
drwxr-xr-x 1 root root 4096 Nov  2 07:13 docs
-rw-r--r-- 1 root root 5229 Nov  2 07:13 pyproject.toml
drwxr-xr-x 1 root root 4096 Nov  2 07:14 src
drwxr-xr-x 1 root root 4096 Nov  2 07:13 tests
.git/COMMIT_EDITMSG
.git/config
.git/description
.git/HEAD
.git/index
.github/dependabot.yml
.github/FUNDING.yml
.github/pull_re
…[779 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

src/anyio/abc/_eventloop.py:198:    def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter:
src/anyio/abc/_eventloop.py:203:    async def run_sync_in_worker_thread(
src/anyio/abc/_eventloop.py:229:    def run_sync_from_thread(
src/anyio/from_thread.py:8:    "run_sync",
src/anyio/from_thread.py:96:def run_sync(
src/anyio/from_thread.py:119:    return token.backend_class.run_sync_from_thread(
src/anyio/from_thread.py:256:                    run_sync(
src/anyio/from_thread.py:303:        run_sync(
src/anyio/from_thread.py:578:        :func:`.to_thread.run_sync`
src/anyio/streams/file.py:40:        await to_thread.run_sync(self._file.close)
src/anyio/streams/file.py:78:        file = await to_thread.run_sync(Path(path).open, "rb")
src/anyio/streams/file.py:86:            data = await to_thread.run_sync(self._file.read, max_bytes)

src/anyio/streams/file.py:111:        ret
…[8630 chars omitted]…
ad.py:296:        await to_thread.run_sync(raise_stopiteration)
tests/test_to_thread.py:379:async def test_run_sync_worker_cyclic_references() -> None:
tests/test_to_thread.py:390:    await to_thread.run_sync(foo, arg)
tests/test_to_thread.py:412:        # Exercising to_thread.run_sync() triggers find_root_task(), which caches
tests/test_to_thread.py:414:        await to_thread.run_sync(thread_worker)

6:**UNRELEASED**
81:- Fixed ``CapacityLimiter.total_tokens`` rejecting ``float("inf")`` when the limiter was
96:- Fixed ``CapacityLimiter.acquire_nowait()`` and
97:  ``CapacityLimiter.acquire_nowait_on_behalf_of()`` raising ``trio.WouldBlock`` instead
100:- Fixed ``CapacityLimiter`` on the asyncio backend over-granting tokens
118:- Fixed ``CapacityLimiter.total_tokens`` rejecting a value of ``0`` when the limiter was
175:  * ``anyio.CapacityLimiter``
182:  ``check_cancelled()`` in a worker thread
266:- Added the ability to set the token count of a ``CapacityLimiter`` to zero
370:- Fixed an edge case in ``CapacityLimiter`` on asyncio where a task, waiting to acquire
594:- Fixed passing ``total_tokens`` to ``anyio.CapacityLimiter()`` as a keyword argument
616:- Enabled the ``Event`` and ``CapacityLimiter`` classes to be instantiated outside an

648:- Fixed adjusting the total number of t
…[1201 chars omitted]…
ask is running a worker thread on
29:requires-python = ">= 3.10"
47:pytest11 = {anyio = "anyio.pytest_plugin"}
55:    "pytest >= 9.0",
56:    "pytest-mock >= 3.14",
57:    "pytest-timeout >= 2.4.0",
123:[tool.pytest]
130:  "-p", "pytest_mock",
172:commands = [["coverage", "run", "-m", "pytest", { replace = "posargs", extend = true }]]
178:commands = [["pytest", { replace = "posargs", extend = true }]]

threading.current_thread() is threading.main_thread()
                and signal.getsignal(signal.SIGINT) is signal.default_int_handler
            ):
                sigint_handler = partial(self._on_sigint, main_task=task)
                try:
                    signal.signal(signal.SIGINT, sigint_handler)
                except ValueError:
                    # `signal.signal` may throw if `threading.main_thread` does
                    # not support signals (e.g. embedded interpreter with signals
                    # not registered - see gh-91880)
                    sigint_handler = None
            else:

                sigint_handler = None

            self._interrupt_count = 0
            try:
                return self._loop.run_until_complete(task)
            except exceptions.CancelledError:
                if self._interrupt_count > 0:
               
…[8630 chars omitted]…
ded support for custom capacity limiters in async path and file I/O
  functions and classes
- Added the ``create_task()`` task group method for easier asyncio migration (returns a
  ``TaskHandle``)
  (`#1098 <https://github.com/agronholm/anyio/pull/1098>`_)
- Changed ``TaskGroup.start_soon()`` to return a ``TaskHandle``
- Added an option for ``TaskGroup.start()`` to return a ``TaskHandle`` (which then

future.set_exception(exc)
            else:
                future.set_result(result)

    def run(self) -> None:
        with claim_worker_thread(AsyncIOBackend, self.loop):
            while True:
                item = self.queue.get()
                if item is None:
                    # Shutdown command received
                    return

                context, func, args, future, cancel_scope = item
                if not future.cancelled():
                    result = None
                    exception: BaseException | None = None
                    threadlocals.current_cancel_scope = cancel_scope
                    try:
                        result = context.run(func, *args)
                    except BaseException as exc:
                        exception = exc
                    finally:
                        del threadlocals.current_cancel_scope
…[8629 chars omitted]…
arTuple, Unpack
else:
    import contextvars
    import enum
    import signal
    from asyncio import coroutines, events, exceptions, tasks

    from exceptiongroup import BaseExceptionGroup
    from typing_extensions import Self, TypeVarTuple, Unpack

    class _State(enum.Enum):
        CREATED = "created"
        INITIALIZED = "initialized"
        CLOSED = "closed"

    class Runner:
60564ae base

Version history
===============

This library adheres to `Semantic Versioning 2.0 <http://semver.org/>`_.

**UNRELEASED**

- 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+)
  * ``newline`` on ``read_text()`` (Python 3.13+)

  (`#1286 <https://github.com/agronholm/anyio/pull/1286>`_; PR by @jaideeppyne)
- Added ``amap``, ``gather``, and ``as_completed`` utility functions to simplify common
  patterns (`#1173 <https://github.com/agronholm/anyio/pull/1173>`_; PR by @Graeme22)
- Added ``--anyio-mode`` command-line option as an alternative to the ``anyio_mode``
  ini setting, and fix the pytest plugin's auto mode detection to recognize the mode
  w
…[6251 chars omitted]…
cio.py:1065:_threadpool_idle_workers: RunVar[deque[WorkerThread]] = RunVar(
./src/anyio/_backends/_asyncio.py:1068:_threadpool_workers: RunVar[set[WorkerThread]] = RunVar("_threadpool_workers")
./src/anyio/_backends/_asyncio.py:2612:                    worker = WorkerThread(root_task, workers, idle_workers)
./src/anyio/_backends/_asyncio.py:2625:                            < WorkerThread.MAX_IDLE_TIME

before: CapacityLimiterStatistics(borrowed_tokens=3, total_tokens=3, borrowers=(<object object at 0x7a0c147fcb80>, <object object at 0x7a0c147fcb90>, <object object at 0x7a0c147fcba0>), tasks_waiting=2) entered: []
after raise: CapacityLimiterStatistics(borrowed_tokens=5, total_tokens=3, borrowers=(<Task pending name='__main__.main.<locals>.waiter' coro=<TaskHandle._run_coro() running at /repo/src/anyio/_core/_tasks.py:324> wait_for=<Future pending cb=[Task.task_wakeup()]> cb=[TaskGroup._spawn.<locals>.task_done() at /repo/src/anyio/_backends/_asyncio.py:836]>, <object object at 0x7a0c147fcb80>, <object object at 0x7a0c147fcb90>, <object object at 0x7a0c147fcba0>, <Task pending name='__main__.main.<locals>.waiter' coro=<TaskHandle._run_coro() running at /repo/src/anyio/_core/_tasks.py:324> wait_for=<Future pending cb=[Task.task_wakeup()]> cb=[TaskGroup._spawn.<locals>.task_done() at /repo/src/anyio/_backends/_asyncio.py:836]>), tasks_waiting=0) entered: [1, 2]

src/anyio/_core/_eventloop.py:179:def claim_worker_thread(
src/anyio/_backends/_asyncio.py:983:class WorkerThread(Thread):
src/anyio/_backends/_asyncio.py:1874:    def statistics(self) -> EventStatistics:
src/anyio/_backends/_asyncio.py:1957:    def statistics(self) -> LockStatistics:
src/anyio/_backends/_asyncio.py:2046:    def statistics(self) -> SemaphoreStatistics:
src/anyio/_backends/_asyncio.py:2153:    def release_on_behalf_of(self, borrower: object) -> None:
src/anyio/_backends/_asyncio.py:2163:    def statistics(self) -> CapacityLimiterStatistics:
                    self._notify_next_waiter()

                raise
        else:
            try:

                await AsyncIOBackend.cancel_shielded_checkpoint()
            except BaseException:
                self.release()
                raise

    def release(self) -> None:
        self.release_on_behalf_of(current_task()
…[1043 chars omitted]…
ctEventLoop, None, None]:
    if sys.version_info >= (3, 13):
        loop = asyncio.EventLoop()
    else:
        loop = asyncio.new_event_loop()

    yield loop

    loop.close()


if sys.version_info >= (3, 14):

    def no_other_refs() -> list[object]:
        return [sys._getframe(1).f_generator]

elif sys.version_info >= (3, 11):

    def no_other_refs() -> list[object]:
        return []
else:

src/anyio/_backends/_asyncio.py:182:        def run(self, coro: Coroutine[T_Retval], *, context=None) -> T_Retval:
src/anyio/_backends/_asyncio.py:1025:    def run(self) -> None:
src/anyio/_backends/_asyncio.py:2454:    def run(
src/anyio/_core/_eventloop.py:38:def run(
            loop = get_running_loop()
            if loop.time() >= self._deadline:
                self.cancel("deadline exceeded")
            else:
                self._timeout_handle = loop.call_at(self._deadline, self._timeout)

    def _deliver_cancellation(self, origin: CancelScope) -> bool:
        """

        Deliver cancellation to directly contained tasks and nested cancel scopes.

        Schedule another run at the end if we still have tasks eligible for
        cancellation.

        :param origin: the cancel scope that originated the cancellation
        :return: ``True`` if the delivery needs to be ret
…[8136 chars omitted]…
       await threads_started.wait()
        assert len(active_threads) == 3
        assert limiter.borrowed_tokens == 3
        event.set()

    assert len(active_threads) == 0
    assert max_active_threads == 3


@pytest.mark.parametrize(
    "abandon_on_cancel, expected_last_active",
    [
        pytest.param(False, "task", id="noabandon"),
        pytest.param(True, "thread", id="abandon"),
    ],

"""
    A subprocess protocol that allows us to be notified of ``process_exited``

    asyncio's own ``Process.wait()`` only resolves once every pipe transport has
    disconnected so to get same semantics as on trio and uvloop we need this.
    """

    def __init__(self) -> None:
        # Match the standard factory for asyncio.create_process
        super().__init__(limit=2**16, loop=asyncio.get_running_loop())
        self.exited = asyncio.Event()

    def process_exited(self) -> None:
        super().process_exited()
        self.exited.set()


class AsyncIOBackend(AsyncBackend):
    @classmethod
    def run(
        cls,
        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
        args: tuple[Unpack[PosArgsT]],
        kwargs: dict[str, Any],
        options: dict[str, Any],
    ) -> T_Retval:
        @wraps(func)
        async def wrapper() -> T_Retval:
        
…[4194 chars omitted]…
e the current task for the specified duration.

    :param delay: the duration, in seconds

    """
    return await get_async_backend().sleep(delay)


async def sleep_forever() -> None:
    """
    Pause the current task until it's cancelled.

    This is a shortcut for ``sleep(math.inf)``.

    .. versionadded:: 3.1

    """
    await sleep(math.inf)


async def sleep_until(deadline: float) -> None:

(command exceeded 600s)

bash: line 6: ps: command not found
Python 3.12.13

/usr/bin/timeout
/usr/local/bin/pytest
<class 'asyncio.unix_events._UnixSelectorEventLoop'> True

controller waitrun

main run
worker not reporting
exit=124

main
Traceback (most recent call last):
  File "<stdin>", line 9, in <module>
  File "/usr/local/lib/python3.12/asyncio/base_events.py", line 691, in run_until_complete
    return future.result()
           ^^^^^^^^^^^^^^^
  File "<stdin>", line 7, in main
  File "/repo/src/anyio/_lazyimport.py", line 41, in __getattr__
    raise AttributeError(
AttributeError: module 'anyio' has no attribute 'to_thread'
exit=1

loop stopped; reporting= True task done= False
worker exception: RuntimeError('Event loop is closed')
worker alive= False
exceptions= ["RuntimeError('Event loop is closed')"]
exit=0

diff --git a/src/anyio/_backends/_asyncio.py b/src/anyio/_backends/_asyncio.py
index 726cfb9..4115de0 100644
--- a/src/anyio/_backends/_asyncio.py
+++ b/src/anyio/_backends/_asyncio.py
@@ -1043,9 +1043,13 @@ class WorkerThread(Thread):
                         del threadlocals.current_cancel_scope
 
                     if not self.loop.is_closed():
-                        self.loop.call_soon_threadsafe(
-                            self._report_result, future, result, exception
-                        )
+                        try:

+                            self.loop.call_soon_threadsafe(
+                                self._report_result, future, result, exception
+                            )
+                        except RuntimeError:
+                            if not self.loop.is_closed():
+                                raise
 
                     del result, exception
 
@@ -2082,7 +2086,7 @@ class CapacityLimiter(BaseCapacityLimiter):
         if value < 0:
             raise ValueError("total_tokens must be >= 0")
 
-        waiters_to_notify = max(value - self._total_tokens, 0)
+        waiters_to_notify = max(value - len(self._borrowers), 0)
         self._total_tokens = value
 
         # Notify waiting tasks that they have acquired the limiter

async def _shutdown_default_executor(loop: AbstractEventLoop) -> None:
        """Schedule the shutdown of the default executor."""

        def _do_shutdown(future: asyncio.futures.Future) -> None:
            try:
                loop._default_executor.shutdown(wait=True)  # type: ignore[attr-defined]
                loop.call_soon_threadsafe(future.set_result, None)
            except Exception as ex:
                loop.call_soon_threadsafe(future.set_exception, ex)

        loop._executor_shutdown_called = True
        if loop._default_executor is None:

            return
        future = loop.create_future()
        thread = threading.Thread(target=_do_shutdown, args=(future,))
        thread.start()
        try:
            await future
        finally:
            thread.join()


T_Retval = TypeVar("T_Retval")
T_co = TypeVar("T_co", covariant=True)
T_contra = TypeVar("T_c
…[3382 chars omitted]…
   new_exc = RuntimeError("coroutine raised StopIteration")
                    new_exc.__cause__ = exc
                    exc = new_exc

                future.set_exception(exc)
            else:
                future.set_result(result)

    def run(self) -> None:
2619:                    root_task.add_done_callback(worker.stop, context=Context())
2637:                        expired_worker.stop()

capacity limiter reproducer passed

Traceback (most recent call last):
  File "<stdin>", line 45, in <module>
AssertionError

loop stopped; task done= False
Traceback (most recent call last):
  File "<stdin>", line 39, in <module>
  File "/repo/src/anyio/lowlevel.py", line 178, in get
    return self._current_vars[self]
           ^^^^^^^^^^^^^^^^^^
  File "/repo/src/anyio/lowlevel.py", line 153, in _current_vars
    native_token = current_token().native_token
                   ^^^^^^^^^^^^^^^
  File "/repo/src/anyio/lowlevel.py", line 94, in current_token
    backend_class = get_async_backend()
                    ^^^^^^^^^^^^^^^^^^^

  File "/repo/src/anyio/_core/_eventloop.py", line 195, in get_async_backend
    raise NoEventLoopError(
anyio._core._exceptions.NoEventLoopError: Not currently running on any asynchronous event loop. Available async backends: asyncio, trio
worker exception: RuntimeError('test timeout')

worker result delivery reproducer passed

.................................................................        [100%]
65 passed in 6.12s

........................................................................ [  1%]
........................................................................ [  3%]
........................................................................ [  5%]
........................................................................ [  6%]
........................................................................ [  8%]
........................................................................ [ 10%]
......................s..............................s.................. [ 11%]
............................................................s........... [ 13%]
...................s.ssssssss..........................ssss............. [ 15%]
.......ssssssssssss...................ssssssssssssssssssssssssssssssss.. [ 17%]
..............ssssssss................ssssssss................s......... [ 18%]
ssss.............

…[8631 chars omitted]…
[trio-ipv6]
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, 3886 passed, 110 skipped, 5 xfailed in 323.07s (0:05:23)

FF
=================================== FAILURES ===================================
___________________________ test_sourceless_install ____________________________
tests/test_lazyimport.py:44: in test_sourceless_install
    subprocess.run([interpreter_path, "-m", "pip", "install", project_root], check=True)
/usr/local/lib/python3.12/subprocess.py:571: in run
    raise CalledProcessError(retcode, process.args,
E   subprocess.CalledProcessError: Command '[PosixPath('/tmp/pytest-of-root/pytest-1/test_sourceless_install0/bin/python'), '-m', 'pip', 'install', PosixPath('/repo')]' returned non-zero exit status 1.
----------------------------- Captured stdout call -----------------------------
Processing /repo
  Installing build dependencies: started
  Installing build dependencies: finished with status 'error'

----------------------------- Captured stderr call -----------------------------
…[3443 chars omitted]…
ket.gaierror: [Errno -3] Temporary failure in name resolution
=========================== short test summary info ============================
FAILED tests/test_lazyimport.py::test_sourceless_install - subprocess.CalledP...
FAILED tests/test_sockets.py::test_getaddrinfo[asyncio] - socket.gaierror: [E...
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 2 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
2 failed in 10.26s

721:        assert limiter.total_tokens == 0
725:        assert limiter.total_tokens == 2
729:            assert limiter.total_tokens == 2
788:            limiter.total_tokens = 2
795:        assert limiter.total_tokens == 40
803:        assert limiter.statistics().total_tokens == 1
873:            limiter.total_tokens = 3
890:        limiter.total_tokens = 2
893:            limiter.total_tokens = "2"  # type: ignore[assignment]
896:            limiter.total_tokens = 3.0
898:        assert limiter.total_tokens == 2
901:        assert statistics.total_tokens == 2

916:        limiter.total_tokens = 0
917:        assert limiter.total_tokens == 0
918:        assert CapacityLimiter(0).total_tokens == 0
926:        assert CapacityLimiter(float("inf")).total_tokens == math.inf
927:        assert CapacityLimiter(math.inf).total_tokens == math.inf
930:        limiter.total_tokens = float("inf"
…[1020 chars omitted]…
esult, exception
 
@@ -2082,7 +2086,7 @@ class CapacityLimiter(BaseCapacityLimiter):
         if value < 0:
             raise ValueError("total_tokens must be >= 0")
 
-        waiters_to_notify = max(value - self._total_tokens, 0)
+        waiters_to_notify = max(value - len(self._borrowers), 0)
         self._total_tokens = value
 
         # Notify waiting tasks that they have acquired the limiter

changelog insertion point not found
bash: line 410: ruff: command not found
 M src/anyio/_backends/_asyncio.py
diff --git a/src/anyio/_backends/_asyncio.py b/src/anyio/_backends/_asyncio.py
index 726cfb9..4115de0 100644
--- a/src/anyio/_backends/_asyncio.py
+++ b/src/anyio/_backends/_asyncio.py
@@ -1043,9 +1043,13 @@ class WorkerThread(Thread):
                         del threadlocals.current_cancel_scope
 
                     if not self.loop.is_closed():
-                        self.loop.call_soon_threadsafe(

-                            self._report_result, future, result, exception
-                        )
+                        try:
+                            self.loop.call_soon_threadsafe(
+                                self._report_result, future, result, exception
+                            )
+                        except RuntimeError:
+                         
…[100 chars omitted]…
esult, exception
 
@@ -2082,7 +2086,7 @@ class CapacityLimiter(BaseCapacityLimiter):
         if value < 0:
             raise ValueError("total_tokens must be >= 0")
 
-        waiters_to_notify = max(value - self._total_tokens, 0)
+        waiters_to_notify = max(value - len(self._borrowers), 0)
         self._total_tokens = value
 
         # Notify waiting tasks that they have acquired the limiter

task group complete
worker alive= False exceptions= []
worker result delivery reproducer passed
exit=0

(`#1267 <https://github.com/agronholm/anyio/issues/1267>`_; PR by @alloutflo)$
- Fixed the pytest plugin importing the deprecated ``_pytest.python.CallSpec2`` alias,$
  which triggers ``PytestRemovedIn10Warning`` on ``pytest>=9.2`` and crashes pytest at$
  startup when ``filterwarnings = error`` is configured$
  (`#1271 <https://github.com/agronholm/anyio/issues/1271>`_; PR by @matthewfeickert)$
$
**4.14.2**$
$
- Changed ``ByteReceiveStream.receive()`` implementations to raise a ``ValueError`` when$
  ``max_bytes`` is not a positive integer$
  (`#1191 <https://github.com/agronholm/anyio/pull/1191>`_)$
- Fixed ``CapacityLimiter.total_tokens`` rejecting ``float("inf")`` when the limiter was$

  instantiated outside of an event loop. The adapter setter checked for infinity by$
  identity (``value is math.inf``), so only the exact ``math.inf`` singleton was accepted,$
  while every backe
…[1009 chars omitted]…
CapacityLimiter.acquire_nowait_on_behalf_of()`` raising ``trio.WouldBlock`` instead$
  of ``anyio.WouldBlock`` on the ``trio`` backend when there are no tokens available$
  (`#1218 <https://github.com/agronholm/anyio/pull/1218>`_)$
- Fixed ``CapacityLimiter`` on the asyncio backend over-granting tokens$
 src/anyio/_backends/_asyncio.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

- Fixed ``anyio.Path.with_stem()`` silently producing a wrong path (e.g.
  ``Path(".txt")``) instead of raising ``ValueError`` when given an empty stem on a
  path with a non-empty suffix, unlike :meth:`pathlib.PurePath.with_stem`
  (`#1200 <https://github.com/agronholm/anyio/pull/1200>`_; PR by @Sanjays2402)
- Fixed ``UNIXSocketStream.aclose()`` raising ``asyncio.InvalidStateError`` when a
  concurrent receive or send operation had just been cancelled on the asyncio backend
  (`#1267 <https://github.com/agronholm/anyio/issues/1267>`_; PR by @alloutflo)
- Fixed the pytest plugin importing the deprecated ``_pytest.python.CallSpec2`` alias,
  which triggers ``PytestRemovedIn10Warning`` on ``pytest>=9.2`` and crashes pytest at
  startup when ``filterwarnings = error`` is configured
  (`#1271 <https://github.com/agronholm/anyio/issues/1271>`_; PR by @matthewfeickert)

- Fixed asyncio ``Ca
…[769 chars omitted]…
while every backend setter (using ``math.isinf()``) accepts any positive infinity
  (`#1189 <https://github.com/agronholm/anyio/pull/1189>`_; PR by @greymoth-jp).
- Fixed ``to_process.run_sync()`` deadlocking when the worker function writes enough data
  to ``sys.stderr`` to fill the (undrained) pipe buffer. The worker process now redirects
 M docs/versionhistory.rst
 M src/anyio/_backends/_asyncio.py

diff --git a/docs/versionhistory.rst b/docs/versionhistory.rst
index 7ad3020..034b2e4 100644
--- a/docs/versionhistory.rst
+++ b/docs/versionhistory.rst
@@ -72,6 +72,10 @@ This library adheres to `Semantic Versioning 2.0 <http://semver.org/>`_.
   which triggers ``PytestRemovedIn10Warning`` on ``pytest>=9.2`` and crashes pytest at
   startup when ``filterwarnings = error`` is configured
   (`#1271 <https://github.com/agronholm/anyio/issues/1271>`_; PR by @matthewfeickert)
+- Fixed asyncio ``CapacityLimiter`` over-granting waiters when its total token count is
+  raised after having been temporarily reduced below the number of borrowers
+- Fixed ``to_thread.run_sync()`` worker threads raising ``RuntimeError`` if the event loop
+  closes while the result-delivery callback is being scheduled

 
 **4.14.2**
 
diff --git a/src/anyio/_backends/_asyncio.py b/src/anyio/_backends/_asyncio.py
in
…[951 chars omitted]…
esult, exception
 
@@ -2082,7 +2088,7 @@ class CapacityLimiter(BaseCapacityLimiter):
         if value < 0:
             raise ValueError("total_tokens must be >= 0")
 
-        waiters_to_notify = max(value - self._total_tokens, 0)
+        waiters_to_notify = max(value - len(self._borrowers), 0)
         self._total_tokens = value
 
         # Notify waiting tasks that they have acquired the limiter

........................................................................ [ 22%]
........................................................................ [ 44%]
........................................................................ [ 67%]
........................................................................ [ 89%]
..................................                                       [100%]
322 passed in 24.67s
 M docs/versionhistory.rst
 M src/anyio/_backends/_asyncio.py
diff --git a/docs/versionhistory.rst b/docs/versionhistory.rst
index 7ad3020..034b2e4 100644
--- a/docs/versionhistory.rst
+++ b/docs/versionhistory.rst

@@ -72,6 +72,10 @@ This library adheres to `Semantic Versioning 2.0 <http://semver.org/>`_.
   which triggers ``PytestRemovedIn10Warning`` on ``pytest>=9.2`` and crashes pytest at
   startup when ``filterwarnings = error`` is configured
   (`#1271 <https://gith
…[1434 chars omitted]…
esult, exception
 
@@ -2082,7 +2088,7 @@ class CapacityLimiter(BaseCapacityLimiter):
         if value < 0:
             raise ValueError("total_tokens must be >= 0")
 
-        waiters_to_notify = max(value - self._total_tokens, 0)
+        waiters_to_notify = max(value - len(self._borrowers), 0)
         self._total_tokens = value
 
         # Notify waiting tasks that they have acquired the limiter

1038:  24                     try:
1039:  57                         result = context.run(func, *args)
1040:  48                     except BaseException as exc:
1041:  39                         exception = exc
1042:  28                     finally:
1043:  61                         del threadlocals.current_cancel_scope
1044:   0 
1045:  49                     if not self.loop.is_closed():
1046:  28                         try:
1047:  59                             self.loop.call_soon_threadsafe(
1048:  78                                 self._report_result, future, result, exception
1049:  29                             )

1050:  44                         except RuntimeError:
1051:  85                             # The loop could have been closed between the check above
1052:  57                             # and call_soon_threadsafe().
1053:  57                             if not s
…[856 chars omitted]…
s = value
2093:   0 
2094:  66         # Notify waiting tasks that they have acquired the limiter
2095:  53         while self._wait_queue and waiters_to_notify:
2096:  66             borrower, event = self._wait_queue.popitem(last=False)
2097:  41             self._borrowers.add(borrower)
2098:  23             event.set()
2099:  34             waiters_to_notify -= 1
2100:   0 
2101:  13     @property

submitted.