zeroconf 0.149.4__tar.gz → 0.149.6__tar.gz

{zeroconf-0.149.4 → zeroconf-0.149.6}/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 <!-- version list -->
 
+## v0.149.6 (2026-05-18)
+
+### Bug Fixes
+
+- Bound _seen_logs and stop retaining exc_info
+  ([#1717](https://github.com/python-zeroconf/python-zeroconf/pull/1717),
+  [`95561e2`](https://github.com/python-zeroconf/python-zeroconf/commit/95561e28b24922358f1991e38e3a86d70d72dcec))
+
+
+## v0.149.5 (2026-05-18)
+
+### Bug Fixes
+
+- Bound DNS compression-pointer chain depth in DNSIncoming
+  ([#1719](https://github.com/python-zeroconf/python-zeroconf/pull/1719),
+  [`f9e2359`](https://github.com/python-zeroconf/python-zeroconf/commit/f9e23592137f30fdf7ef710dba065da31c79b1cf))
+
+### Testing
+
+- Cap helper get_service_info timeout in suppression test (~3.0s → ~1.85s)
+  ([#1708](https://github.com/python-zeroconf/python-zeroconf/pull/1708),
+  [`ee3c7d7`](https://github.com/python-zeroconf/python-zeroconf/commit/ee3c7d74ff45327a3a6d520b86a691e21e2bc219))
+
+- Drop ZeroconfServiceTypes.find() timeouts from 500ms to 200ms on loopback
+  ([#1710](https://github.com/python-zeroconf/python-zeroconf/pull/1710),
+  [`64d143d`](https://github.com/python-zeroconf/python-zeroconf/commit/64d143d2ee7874ee1d9cef0dd2799c008b4aa791))
+
+- Eliminate test_get_info_single race by injecting from the send mock
+  ([#1716](https://github.com/python-zeroconf/python-zeroconf/pull/1716),
+  [`963d3d7`](https://github.com/python-zeroconf/python-zeroconf/commit/963d3d70e1cde056967eba0d8747ddcd247ae707))
+
+- Fix race in test_register_and_lookup_type_by_uppercase_name
+  ([#1712](https://github.com/python-zeroconf/python-zeroconf/pull/1712),
+  [`91aa21d`](https://github.com/python-zeroconf/python-zeroconf/commit/91aa21d52a0873f5fc12d43675b1b521dfe20519))
+
+- Speed up service-info request tests with quick_request_timing fixture
+  ([#1709](https://github.com/python-zeroconf/python-zeroconf/pull/1709),
+  [`4bae30a`](https://github.com/python-zeroconf/python-zeroconf/commit/4bae30a2ed0910ee7c4f1d0f92f2c400a7b10f31))
+
+
 ## v0.149.4 (2026-05-17)
 
 ### Bug Fixes

{zeroconf-0.149.4 → zeroconf-0.149.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zeroconf
-Version: 0.149.4
+Version: 0.149.6
 Summary: A pure python implementation of multicast DNS service discovery
 License-Expression: LGPL-2.1-or-later
 License-File: COPYING

{zeroconf-0.149.4 → zeroconf-0.149.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "zeroconf"
-version = "0.149.4"
+version = "0.149.6"
 license = "LGPL-2.1-or-later"
 description = "A pure python implementation of multicast DNS service discovery"
 readme = "README.rst"

{zeroconf-0.149.4 → zeroconf-0.149.6}/setup.py

@@ -19,7 +19,7 @@ install_requires = \
 
 setup_kwargs = {
     'name': 'zeroconf',
-    'version': '0.149.4',
+    'version': '0.149.6',
     'description': 'A pure python implementation of multicast DNS service discovery',
     'long_description': 'python-zeroconf\n===============\n\n.. image:: https://github.com/python-zeroconf/python-zeroconf/workflows/CI/badge.svg\n   :target: https://github.com/python-zeroconf/python-zeroconf?query=workflow%3ACI+branch%3Amaster\n\n.. image:: https://img.shields.io/pypi/v/zeroconf.svg\n    :target: https://pypi.python.org/pypi/zeroconf\n\n.. image:: https://codecov.io/gh/python-zeroconf/python-zeroconf/branch/master/graph/badge.svg\n   :target: https://codecov.io/gh/python-zeroconf/python-zeroconf\n\n.. image:: https://img.shields.io/endpoint?url=https://codspeed.io/badge.json\n   :target: https://codspeed.io/python-zeroconf/python-zeroconf\n   :alt: Codspeed.io status for python-zeroconf\n\n.. image:: https://readthedocs.org/projects/python-zeroconf/badge/?version=latest\n    :target: https://python-zeroconf.readthedocs.io/en/latest/?badge=latest\n    :alt: Documentation Status\n\n`Documentation <https://python-zeroconf.readthedocs.io/en/latest/>`_.\n\nThis is fork of pyzeroconf, Multicast DNS Service Discovery for Python,\noriginally by Paul Scott-Murphy (https://github.com/paulsm/pyzeroconf),\nmodified by William McBrine (https://github.com/wmcbrine/pyzeroconf).\n\nThe original William McBrine\'s fork note::\n\n    This fork is used in all of my TiVo-related projects: HME for Python\n    (and therefore HME/VLC), Network Remote, Remote Proxy, and pyTivo.\n    Before this, I was tracking the changes for zeroconf.py in three\n    separate repos. I figured I should have an authoritative source.\n\n    Although I make changes based on my experience with TiVos, I expect that\n    they\'re generally applicable. This version also includes patches found\n    on the now-defunct (?) Launchpad repo of pyzeroconf, and elsewhere\n    around the net -- not always well-documented, sorry.\n\nCompatible with:\n\n* Bonjour\n* Avahi\n\nCompared to some other Zeroconf/Bonjour/Avahi Python packages, python-zeroconf:\n\n* isn\'t tied to Bonjour or Avahi\n* doesn\'t use D-Bus\n* doesn\'t force you to use particular event loop or Twisted (asyncio is used under the hood but not required)\n* is pip-installable\n* has PyPI distribution\n* has an optional cython extension for performance (pure python is supported as well)\n\nPython compatibility\n--------------------\n\n* CPython 3.10+\n* PyPy 3.10+\n\nVersioning\n----------\n\nThis project uses semantic versioning.\n\nStatus\n------\n\nThis project is actively maintained.\n\nTraffic Reduction\n-----------------\n\nBefore version 0.32, most traffic reduction techniques described in https://datatracker.ietf.org/doc/html/rfc6762#section-7\nwhere not implemented which could lead to excessive network traffic.  It is highly recommended that version 0.32 or later\nis used if this is a concern.\n\nIPv6 support\n------------\n\nIPv6 support is relatively new and currently limited, specifically:\n\n* `InterfaceChoice.All` is an alias for `InterfaceChoice.Default` on non-POSIX\n  systems.\n* Dual-stack IPv6 sockets are used, which may not be supported everywhere (some\n  BSD variants do not have them).\n* Listening on localhost (`::1`) does not work. Help with understanding why is\n  appreciated.\n\nHow to get python-zeroconf?\n===========================\n\n* PyPI page https://pypi.org/project/zeroconf/\n* GitHub project https://github.com/python-zeroconf/python-zeroconf\n\nThe easiest way to install python-zeroconf is using pip::\n\n    pip install zeroconf\n\n\n\nHow do I use it?\n================\n\nHere\'s an example of browsing for a service:\n\n.. code-block:: python\n\n    from zeroconf import ServiceBrowser, ServiceListener, Zeroconf\n\n\n    class MyListener(ServiceListener):\n\n        def update_service(self, zc: Zeroconf, type_: str, name: str) -> None:\n            print(f"Service {name} updated")\n\n        def remove_service(self, zc: Zeroconf, type_: str, name: str) -> None:\n            print(f"Service {name} removed")\n\n        def add_service(self, zc: Zeroconf, type_: str, name: str) -> None:\n            info = zc.get_service_info(type_, name)\n            print(f"Service {name} added, service info: {info}")\n\n\n    zeroconf = Zeroconf()\n    listener = MyListener()\n    browser = ServiceBrowser(zeroconf, "_http._tcp.local.", listener)\n    try:\n        input("Press enter to exit...\\n\\n")\n    finally:\n        zeroconf.close()\n\n.. note::\n\n    Discovery and service registration use *all* available network interfaces by default.\n    If you want to customize that you need to specify ``interfaces`` argument when\n    constructing ``Zeroconf`` object (see the code for details).\n\nIf you don\'t know the name of the service you need to browse for, try:\n\n.. code-block:: python\n\n    from zeroconf import ZeroconfServiceTypes\n    print(\'\\n\'.join(ZeroconfServiceTypes.find()))\n\nSee examples directory for more.\n\nChangelog\n=========\n\n`Changelog <CHANGELOG.md>`_\n\nLicense\n=======\n\nLGPL, see COPYING file for details.\n',
     'author': 'Paul Scott-Murphy',

{zeroconf-0.149.4 → zeroconf-0.149.6}/src/zeroconf/__init__.py

@@ -88,7 +88,7 @@ from ._utils.time import (  # noqa # import needed for backwards compat
 
 __author__ = "Paul Scott-Murphy, William McBrine"
 __maintainer__ = "Jakub Stasiak <jakub@stasiak.at>"
-__version__ = "0.149.4"
+__version__ = "0.149.6"
 __license__ = "LGPL"
 
 

zeroconf-0.149.6/src/zeroconf/_logger.py

@@ -0,0 +1,111 @@
+"""Multicast DNS Service Discovery for Python, v0.14-wmcbrine
+    )
+Copyright 2003 Paul Scott-Murphy, 2014 William McBrine
+
+This module provides a framework for the use of DNS Service Discovery
+using IP multicast.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+USA
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Any
+
+log = logging.getLogger(__name__.split(".", maxsplit=1)[0])
+log.addHandler(logging.NullHandler())
+
+
+def set_logger_level_if_unset() -> None:
+    if log.level == logging.NOTSET:
+        log.setLevel(logging.WARN)
+
+
+set_logger_level_if_unset()
+
+
+_MAX_SEEN_LOGS = 512
+_seen_logs: dict[str, None] = {}
+
+
+def _evict_oldest(seen: dict[str, None]) -> bool:
+    """Pop the oldest entry from ``seen``; return False if it raced.
+
+    Individual dict ops (``pop`` with a default, ``next``) are atomic
+    on the free-threaded build, but the compound ``iter`` → ``next``
+    used to pick the FIFO victim can raise ``RuntimeError`` if
+    another thread mutates the dict between the two ops. The caller
+    breaks its drain loop on False so concurrent mutation can't make
+    it spin.
+    """
+    try:
+        seen.pop(next(iter(seen)), None)
+    except (RuntimeError, StopIteration):
+        return False
+    return True
+
+
+def _mark_seen(seen: dict[str, None], key: str) -> bool:
+    """Record ``key`` in ``seen`` and return True if it was newly added.
+
+    Bounds the dict so callers passing attacker-influenced keys (peer
+    addresses, packet offsets) cannot grow it without bound. Evicts
+    the oldest entries on overflow (dict preserves insertion order on
+    Python 3.7+), so ``_MAX_SEEN_LOGS`` is a recency window.
+
+    The dict is shared across all ``Zeroconf`` instances in the
+    process; on the free-threaded build (3.14t) and under multi-
+    instance sync use, callers can race the ``len < cap`` check and
+    both insert, leaving the dict transiently above the cap. The
+    drain loop runs on every call (steady-state-at-cap hits are a
+    single ``len`` + compare past the membership check because the
+    helper short-circuits) so a contention burst is corrected by the
+    next caller regardless of whether it's a hit or a miss.
+    """
+    inserting = key not in seen
+    # Hit (``inserting`` is False): drain only if drifted above cap.
+    # Miss (``inserting`` is True): drain to ``cap - 1`` to make room
+    # for the new key. Bool subtracts as 0/1 to pick the right limit.
+    while len(seen) > _MAX_SEEN_LOGS - inserting and _evict_oldest(seen):
+        pass
+    if inserting:
+        seen[key] = None
+    return inserting
+
+
+class QuietLogger:
+    @classmethod
+    def log_exception_warning(cls, *logger_data: Any) -> None:
+        first_time = _mark_seen(_seen_logs, str(sys.exc_info()[1]))
+        logger = log.warning if first_time else log.debug
+        logger(*(logger_data or ["Exception occurred"]), exc_info=True)
+
+    @classmethod
+    def log_exception_debug(cls, *logger_data: Any) -> None:
+        first_time = _mark_seen(_seen_logs, str(sys.exc_info()[1]))
+        log.debug(*(logger_data or ["Exception occurred"]), exc_info=first_time)
+
+    @classmethod
+    def log_warning_once(cls, *args: Any) -> None:
+        logger = log.warning if _mark_seen(_seen_logs, args[0]) else log.debug
+        logger(*args)
+
+    @classmethod
+    def log_exception_once(cls, exc: Exception, *args: Any) -> None:
+        logger = log.warning if _mark_seen(_seen_logs, args[0]) else log.debug
+        logger(*args, exc_info=exc)

{zeroconf-0.149.4 → zeroconf-0.149.6}/src/zeroconf/_protocol/incoming.pxd

@@ -83,7 +83,7 @@ cdef class DNSIncoming:
         link_py_int=object,
         linked_labels=cython.list
     )
-    cdef unsigned int _decode_labels_at_offset(self, unsigned int off, cython.list labels, cython.set seen_pointers)
+    cdef unsigned int _decode_labels_at_offset(self, unsigned int off, cython.list labels, cython.set seen_pointers, unsigned int depth)
 
     @cython.locals(offset="unsigned int")
     cdef void _read_header(self)

{zeroconf-0.149.4 → zeroconf-0.149.6}/src/zeroconf/_protocol/incoming.py

@@ -37,7 +37,7 @@ from .._dns import (
     DNSText,
 )
 from .._exceptions import IncomingDecodeError
-from .._logger import log
+from .._logger import _mark_seen, log
 from .._utils.time import current_time_millis
 from ..const import (
     _FLAGS_QR_MASK,
@@ -60,10 +60,10 @@ DNS_COMPRESSION_POINTER_LEN = 2
 MAX_DNS_LABELS = 128
 MAX_NAME_LENGTH = 253
 
-DECODE_EXCEPTIONS = (IndexError, struct.error, IncomingDecodeError)
+DECODE_EXCEPTIONS = (IndexError, struct.error, IncomingDecodeError, RecursionError)
 
 
-_seen_logs: dict[str, int | tuple] = {}
+_seen_logs: dict[str, None] = {}
 _str = str
 _int = int
 
@@ -182,13 +182,7 @@ class DNSIncoming:
 
     @classmethod
     def _log_exception_debug(cls, *logger_data: Any) -> None:
-        log_exc_info = False
-        exc_info = sys.exc_info()
-        exc_str = str(exc_info[1])
-        if exc_str not in _seen_logs:
-            # log the trace only on the first time
-            _seen_logs[exc_str] = exc_info
-            log_exc_info = True
+        log_exc_info = _mark_seen(_seen_logs, str(sys.exc_info()[1]))
         log.debug(*(logger_data or ["Exception occurred"]), exc_info=log_exc_info)
 
     def answers(self) -> list[DNSRecord]:
@@ -409,7 +403,7 @@ class DNSIncoming:
         labels: list[str] = []
         seen_pointers: set[int] = set()
         original_offset = self.offset
-        self.offset = self._decode_labels_at_offset(original_offset, labels, seen_pointers)
+        self.offset = self._decode_labels_at_offset(original_offset, labels, seen_pointers, 0)
         self._name_cache[original_offset] = labels
         name = ".".join(labels) + "."
         if len(name) > MAX_NAME_LENGTH:
@@ -418,8 +412,14 @@ class DNSIncoming:
             )
         return name
 
-    def _decode_labels_at_offset(self, off: _int, labels: list[str], seen_pointers: set[int]) -> int:
+    def _decode_labels_at_offset(
+        self, off: _int, labels: list[str], seen_pointers: set[int], depth: _int
+    ) -> int:
         # This is a tight loop that is called frequently, small optimizations can make a difference.
+        if depth > MAX_DNS_LABELS:
+            raise IncomingDecodeError(
+                f"DNS compression pointer chain exceeds {MAX_DNS_LABELS} at {off} from {self.source}"
+            )
         view = self.view
         while off < self._data_len:
             length = view[off]
@@ -457,7 +457,7 @@ class DNSIncoming:
             if not linked_labels:
                 linked_labels = []
                 seen_pointers.add(link_py_int)
-                self._decode_labels_at_offset(link, linked_labels, seen_pointers)
+                self._decode_labels_at_offset(link, linked_labels, seen_pointers, depth + 1)
                 self._name_cache[link_py_int] = linked_labels
             labels.extend(linked_labels)
             if len(labels) > MAX_DNS_LABELS:

{zeroconf-0.149.4 → zeroconf-0.149.6}/tests/__init__.py

@@ -35,6 +35,20 @@ from zeroconf._history import QuestionHistory
 
 _MONOTONIC_RESOLUTION = time.get_clock_info("monotonic").resolution
 
+# get_service_info / async_request timeout for tests using the
+# `quick_request_timing` fixture. The fixture cuts the initial-query
+# delay to ~15ms (10ms _LISTENER_TIME + 1-5ms jitter), so 50ms is
+# ample headroom for tests that only need to observe the first one
+# or two queries.
+QUICK_REQUEST_TIMEOUT_MS = 50
+
+# Timeout for ZeroconfServiceTypes.find() / AsyncZeroconfServiceTypes.async_find()
+# in loopback integration tests. `find()` is just `time.sleep(timeout)` —
+# it doesn't short-circuit on the first matching response — so the
+# timeout becomes a lower bound on the test runtime. On loopback the
+# registrar's response lands within a few ms; 200ms is ~50x headroom.
+LOOPBACK_FIND_TIMEOUT = 0.2
+
 
 class QuestionHistoryWithoutSuppression(QuestionHistory):
     def suppresses(self, question: DNSQuestion, now: float, known_answers: set[DNSRecord]) -> bool:

zeroconf-0.149.6/tests/benchmarks/test_mark_seen.py

@@ -0,0 +1,39 @@
+"""Benchmark for _logger._mark_seen."""
+
+from __future__ import annotations
+
+from pytest_codspeed import BenchmarkFixture
+
+from zeroconf._logger import _MAX_SEEN_LOGS, _mark_seen
+
+
+def test_mark_seen_hit(benchmark: BenchmarkFixture) -> None:
+    """Benchmark the cache-hit path (same key repeated)."""
+    seen: dict[str, None] = {"warm": None}
+
+    @benchmark
+    def _hit() -> None:
+        for _ in range(1000):
+            _mark_seen(seen, "warm")
+
+
+def test_mark_seen_fill(benchmark: BenchmarkFixture) -> None:
+    """Benchmark filling from empty up to the cap (no evictions)."""
+    keys = [f"key-{i}" for i in range(_MAX_SEEN_LOGS)]
+
+    @benchmark
+    def _fill() -> None:
+        seen: dict[str, None] = {}
+        for k in keys:
+            _mark_seen(seen, k)
+
+
+def test_mark_seen_churn(benchmark: BenchmarkFixture) -> None:
+    """Benchmark sustained eviction (every call past the cap drops oldest)."""
+    keys = [f"churn-{i}" for i in range(_MAX_SEEN_LOGS * 4)]
+
+    @benchmark
+    def _churn() -> None:
+        seen: dict[str, None] = {}
+        for k in keys:
+            _mark_seen(seen, k)

{zeroconf-0.149.4 → zeroconf-0.149.6}/tests/conftest.py

@@ -10,6 +10,7 @@ import pytest
 
 from zeroconf import _core, const
 from zeroconf._handlers import query_handler
+from zeroconf._services import info as service_info
 
 
 @pytest.fixture(autouse=True)
@@ -59,3 +60,21 @@ def quick_timing() -> Generator[None]:
         patch.object(_core, "_UNREGISTER_TIME", 10),
     ):
         yield
+
+
+@pytest.fixture
+def quick_request_timing() -> Generator[None]:
+    """Shorten the initial-query delay used by AsyncServiceInfo.async_request.
+
+    The 200ms `_LISTENER_TIME` and 20-120ms random jitter (RFC 6762
+    §5.2) help spread queries from multiple clients on real networks.
+    On loopback they're pure overhead — get_service_info-style tests
+    wait ~250ms before the first query even fires. Opt in by adding
+    `quick_request_timing` to a test's argument list, then drop the
+    test's own timeouts (which had to accommodate that delay).
+    """
+    with (
+        patch.object(service_info, "_LISTENER_TIME", 10),
+        patch.object(service_info, "_AVOID_SYNC_DELAY_RANDOM_INTERVAL", (1, 5)),
+    ):
+        yield

{zeroconf-0.149.4 → zeroconf-0.149.6}/tests/services/test_info.py

@@ -23,7 +23,7 @@ from zeroconf._services.info import ServiceInfo
 from zeroconf._utils.net import IPVersion
 from zeroconf.asyncio import AsyncZeroconf
 
-from .. import _inject_response, has_working_ipv6
+from .. import QUICK_REQUEST_TIMEOUT_MS, _inject_response, has_working_ipv6
 
 log = logging.getLogger("zeroconf")
 original_logging_level = logging.NOTSET
@@ -430,9 +430,9 @@ class TestServiceInfo(unittest.TestCase):
 
                 return r.DNSIncoming(generated.packets()[0])
 
-            def get_service_info_helper(zc, type, name):
+            def get_service_info_helper(zc, type, name, timeout):
                 nonlocal service_info
-                service_info = zc.get_service_info(type, name)
+                service_info = zc.get_service_info(type, name, timeout)
                 service_info_event.set()
 
             try:
@@ -453,9 +453,14 @@ class TestServiceInfo(unittest.TestCase):
                 for question in seed_history_questions:
                     zc.question_history.add_question_at_time(question, far_future, set())
 
+                # No answers ever come back (all queries are suppressed),
+                # so cap the helper at the worst-case sum of the three
+                # phase waits below plus margin instead of the 3000ms
+                # default. Phase 3 waits ~1.6s (the 999ms QM gap plus
+                # jitter and 500ms buffer); 1500ms covers it.
                 helper_thread = threading.Thread(
                     target=get_service_info_helper,
-                    args=(zc, service_type, service_name),
+                    args=(zc, service_type, service_name, 1500),
                 )
                 helper_thread.start()
                 wait_time = (const._LISTENER_TIME + info._AVOID_SYNC_DELAY_RANDOM_INTERVAL[1] + 500) / 1000
@@ -506,6 +511,7 @@ class TestServiceInfo(unittest.TestCase):
                 zc.remove_all_service_listeners()
                 zc.close()
 
+    @pytest.mark.usefixtures("quick_request_timing")
     def test_get_info_single(self):
         zc = r.Zeroconf(interfaces=["127.0.0.1"])
 
@@ -516,91 +522,88 @@ class TestServiceInfo(unittest.TestCase):
         service_address = "10.0.1.2"
 
         service_info = None
-        send_event = Event()
         service_info_event = Event()
 
-        last_sent: r.DNSOutgoing | None = None
+        ttl = 120
+        response_records = [
+            r.DNSText(
+                service_name,
+                const._TYPE_TXT,
+                const._CLASS_IN | const._CLASS_UNIQUE,
+                ttl,
+                service_text,
+            ),
+            r.DNSService(
+                service_name,
+                const._TYPE_SRV,
+                const._CLASS_IN | const._CLASS_UNIQUE,
+                ttl,
+                0,
+                0,
+                80,
+                service_server,
+            ),
+            r.DNSAddress(
+                service_server,
+                const._TYPE_A,
+                const._CLASS_IN | const._CLASS_UNIQUE,
+                ttl,
+                socket.inet_pton(socket.AF_INET, service_address),
+            ),
+        ]
 
-        def send(out, addr=const._MDNS_ADDR, port=const._MDNS_PORT, v6_flow_scope=()):
-            """Sends an outgoing packet."""
-            nonlocal last_sent
+        def mock_incoming_msg(records: Iterable[r.DNSRecord]) -> r.DNSIncoming:
+            generated = r.DNSOutgoing(const._FLAGS_QR_RESPONSE)
+            for record in records:
+                generated.add_answer_at_time(record, 0)
+            return r.DNSIncoming(generated.packets()[0])
 
-            last_sent = out
-            send_event.set()
+        sent_queries: list[r.DNSOutgoing] = []
+
+        def send(out, addr=const._MDNS_ADDR, port=const._MDNS_PORT, v6_flow_scope=()):
+            """Capture each query and, on the first one, fill the cache
+            inline so the next iteration of `async_request` finds
+            `_is_complete=True` and exits without sending another query.
+
+            Running the inject from inside `send` keeps it on the event
+            loop thread and atomic with the first send — eliminating the
+            test-thread → `run_coroutine_threadsafe` race that flaked
+            under PyPy + use_cython when `quick_request_timing` shortens
+            the inter-iteration delay to ~15ms.
+            """
+            sent_queries.append(out)
+            if len(sent_queries) == 1:
+                zc.record_manager.async_updates_from_response(mock_incoming_msg(response_records))
+
+        def get_service_info_helper(zc, type, name):
+            nonlocal service_info
+            service_info = zc.get_service_info(type, name)
+            service_info_event.set()
 
         # patch the zeroconf send
         with patch.object(zc, "async_send", send):
-
-            def mock_incoming_msg(records: Iterable[r.DNSRecord]) -> r.DNSIncoming:
-                generated = r.DNSOutgoing(const._FLAGS_QR_RESPONSE)
-
-                for record in records:
-                    generated.add_answer_at_time(record, 0)
-
-                return r.DNSIncoming(generated.packets()[0])
-
-            def get_service_info_helper(zc, type, name):
-                nonlocal service_info
-                service_info = zc.get_service_info(type, name)
-                service_info_event.set()
-
             try:
-                ttl = 120
                 helper_thread = threading.Thread(
                     target=get_service_info_helper,
                     args=(zc, service_type, service_name),
                 )
                 helper_thread.start()
-                wait_time = 1
 
-                # Expect query for SRV, TXT, A, AAAA
-                send_event.wait(wait_time)
-                assert last_sent is not None
-                assert len(last_sent.questions) == 4
-                assert r.DNSQuestion(service_name, const._TYPE_SRV, const._CLASS_IN) in last_sent.questions
-                assert r.DNSQuestion(service_name, const._TYPE_TXT, const._CLASS_IN) in last_sent.questions
-                assert r.DNSQuestion(service_name, const._TYPE_A, const._CLASS_IN) in last_sent.questions
-                assert r.DNSQuestion(service_name, const._TYPE_AAAA, const._CLASS_IN) in last_sent.questions
-                assert service_info is None
-
-                # Expect no further queries
-                last_sent = None
-                send_event.clear()
-                _inject_response(
-                    zc,
-                    mock_incoming_msg(
-                        [
-                            r.DNSText(
-                                service_name,
-                                const._TYPE_TXT,
-                                const._CLASS_IN | const._CLASS_UNIQUE,
-                                ttl,
-                                service_text,
-                            ),
-                            r.DNSService(
-                                service_name,
-                                const._TYPE_SRV,
-                                const._CLASS_IN | const._CLASS_UNIQUE,
-                                ttl,
-                                0,
-                                0,
-                                80,
-                                service_server,
-                            ),
-                            r.DNSAddress(
-                                service_server,
-                                const._TYPE_A,
-                                const._CLASS_IN | const._CLASS_UNIQUE,
-                                ttl,
-                                socket.inet_pton(socket.AF_INET, service_address),
-                            ),
-                        ]
-                    ),
-                )
-                send_event.wait(wait_time)
-                assert last_sent is None
+                # Helper should complete promptly — the inline inject in
+                # `send` populates the cache before the request loop's
+                # next iteration.
+                service_info_event.wait(1)
                 assert service_info is not None
 
+                # First (and only) query: QU for SRV/TXT/A/AAAA.
+                assert len(sent_queries) == 1
+                first_sent = sent_queries[0]
+                assert len(first_sent.questions) == 4
+                assert r.DNSQuestion(service_name, const._TYPE_SRV, const._CLASS_IN) in first_sent.questions
+                assert r.DNSQuestion(service_name, const._TYPE_TXT, const._CLASS_IN) in first_sent.questions
+                assert r.DNSQuestion(service_name, const._TYPE_A, const._CLASS_IN) in first_sent.questions
+                assert r.DNSQuestion(service_name, const._TYPE_AAAA, const._CLASS_IN) in first_sent.questions
+
             finally:
                 helper_thread.join()
                 zc.remove_all_service_listeners()
@@ -980,7 +983,7 @@ def test_serviceinfo_accepts_bytes_or_string_dict():
     assert info_service.dns_text().text == b"\x0epath=/~paulsm/"
 
 
-def test_asking_qu_questions():
+def test_asking_qu_questions(quick_request_timing):
     """Verify explicitly asking QU questions."""
     type_ = "_quservice._tcp.local."
     zeroconf = r.Zeroconf(interfaces=["127.0.0.1"])
@@ -999,12 +1002,14 @@ def test_asking_qu_questions():
 
     # patch the zeroconf send
     with patch.object(zeroconf, "async_send", send):
-        zeroconf.get_service_info(f"name.{type_}", type_, 500, question_type=r.DNSQuestionType.QU)
+        zeroconf.get_service_info(
+            f"name.{type_}", type_, QUICK_REQUEST_TIMEOUT_MS, question_type=r.DNSQuestionType.QU
+        )
         assert first_outgoing.questions[0].unicast is True  # type: ignore[union-attr]
         zeroconf.close()
 
 
-def test_asking_qm_questions():
+def test_asking_qm_questions(quick_request_timing):
     """Verify explicitly asking QM questions."""
     type_ = "_quservice._tcp.local."
     zeroconf = r.Zeroconf(interfaces=["127.0.0.1"])
@@ -1023,7 +1028,9 @@ def test_asking_qm_questions():
 
     # patch the zeroconf send
     with patch.object(zeroconf, "async_send", send):
-        zeroconf.get_service_info(f"name.{type_}", type_, 500, question_type=r.DNSQuestionType.QM)
+        zeroconf.get_service_info(
+            f"name.{type_}", type_, QUICK_REQUEST_TIMEOUT_MS, question_type=r.DNSQuestionType.QM
+        )
         assert first_outgoing.questions[0].unicast is False  # type: ignore[union-attr]
         zeroconf.close()