Map: silence about a tile is not the source saying it's empty

A tile fetch that gets no answer was being remembered as one that did.
BasemapSource is careful about the difference — a timeout is never written
to disk, precisely so the next pan can ask again — and both callers then
threw it away, filing every None as "fetched, empty/absent" and never
asking again for the life of the screen. The same latch sat one level up:
_resolve() marked itself done whether or not it had resolved anything, so
one failed TileJSON round-trip made `available` False, and _ensure_tiles
skipped every fetch, for the whole session.

That is a desktop no-op and a PicoCalc bug. The device brings its Wi-Fi up
some forty seconds into the boot, well after an app started alongside it
reaches the menu and warms the tile source — so the map answers "offline"
before the answer can be true and draws the entire session from whatever
the cache already held. JP, 2026-08-18: black tiles at the two highest
zooms, where one z14 tile is the whole screen and a hole is the picture.
VE2RAD_FH_50m's tile (14/4842/5861) was simply absent from the device
cache; nothing there had been written in ten days of using the map, and it
fetched in 1.4s the moment it was asked for.

So: `available` reports what is known and never itself goes to the network
(it is read on the paint path), a failed resolve stands for 30s rather than
for ever, `answered_empty` lets a caller tell the two Nones apart, and a
tile nobody answered about waits out a 20s cooldown instead of a restart.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Jean-Pierre MartineauandClaude Opus 5 committed 2026-08-18 20:28:34 -04:00
1 parent 64d285a986
commit f5d0fb3677
6 files changed
+330 -34

No files matched your search

+61 -7
View File
@@ -20,7 +20,10 @@ costs only the decode it was saving.
The default source is **OpenFreeMap** (openfreemap.org) — full-planet OpenStreetMap vector
tiles, free and requiring no API key. Everything here is best-effort: with no network and no
cached tiles the loader simply returns ``None`` and the map falls back to plotting nodes on a
blank grid, never raising into the UI.
blank grid, never raising into the UI. Best-effort, and **never given up on**: neither a
failed tile fetch nor a failed metadata resolve is remembered as a verdict on the source,
because the app can perfectly well open before the device it runs on has finished bringing
its network up (see :meth:`BasemapSource._resolve`).
**Only tiles that decode to real geometry are ever written to disk.** A cache is a memory,
and the one thing it must not remember is a lie: on a flaky link (the PicoCalc's Wi-Fi, most
@@ -41,6 +44,7 @@ import json
import logging
import os
import threading
import time
import urllib.error
import urllib.request
from collections import OrderedDict
@@ -76,6 +80,13 @@ _PRUNE_AFTER_BYTES = 8 * 1024 * 1024
#: has 100 MB of RAM in total and decoded layers are not small.
_MEMO_TILES = 24
#: How long a failed TileJSON resolve stands before the source will ask again. The PicoCalc
#: brings its Wi-Fi up some 40 seconds into the boot, well after the app it was started
#: alongside can reach the menu — so "offline" asked once at open is a verdict on the
#: *device's boot order*, not on the network, and latching it costs the whole session's
#: basemap. Long enough that a genuinely offline session isn't retrying into a void.
_RESOLVE_RETRY_SECONDS = 30.0
_log = logging.getLogger(__name__)
@@ -137,7 +148,9 @@ class BasemapSource:
self._stamp = "all" if layers is None else ",".join(sorted(layers)) # type: ignore[arg-type]
self._template: Optional[str] = None
self._max_zoom: Optional[int] = None
self._resolved = False # whether we've tried (success or offline) this session
# When the source may next try to resolve its template. Zero means "now";
# a success sets the template and this is never consulted again.
self._resolve_after = 0.0
# Tiles the source answered "nothing here" for this session. Held in memory rather
# than on disk so the claim expires with the process: a blank tile is cheap to
# re-ask about, and a stale one on disk is a permanent hole in the map.
@@ -155,10 +168,30 @@ class BasemapSource:
return self.cache_dir / "tilejson.json"
def _resolve(self) -> None:
"""Resolve and cache the tile-URL template and max zoom (best-effort, once)."""
if self._resolved:
"""Resolve and cache the tile-URL template and max zoom (best-effort, retried).
Latched on **success only**. A failed resolve is the absence of an answer, exactly
as a failed tile fetch is (see :class:`_Response`), and remembering it as "this
source is offline" is the same lie in a costlier place: it is asked once, seconds
after the app opens, and its verdict then governs every tile for the rest of the
session. On the PicoCalc the Wi-Fi associates some forty seconds into the boot, so
an app started with it answers that question before the answer can be true and
draws the whole session's map from whatever was already on disk — which is exactly
a scatter of black tiles at the zooms whose ground the cache happens not to hold.
So a failure only stands for :data:`_RESOLVE_RETRY_SECONDS`, and the next caller
past that asks again. The deadline is claimed *before* the round-trip, so the
several worker threads a map frame puts through here don't all make the same call.
Blocking, and called from worker threads (a tile fetch, the menu's warm) — never
from the paint path, which reads :attr:`available` instead.
"""
if self._template is not None:
return
self._resolved = True
now = time.monotonic()
if now < self._resolve_after:
return
self._resolve_after = now + _RESOLVE_RETRY_SECONDS
# Prefer a freshly fetched TileJSON (the template is versioned and rotates), but fall
# back to a previously cached copy so a session started offline can still use disk
# tiles and even re-fetch if the template is still valid.
@@ -194,10 +227,31 @@ class BasemapSource:
@property
def available(self) -> bool:
"""Whether a tile-URL template is known (network reachable, or one was cached)."""
self._resolve()
"""Whether a tile-URL template is already known — asking nothing to find out.
Read on the paint path (the map's title, the mini-map's caption), so it must never
be the thing that goes to the network: a resolve is a blocking round-trip, and one
answered from a repaint would stall the UI for its whole timeout. Touching
:attr:`max_zoom` — which every map surface does, off the loop, before it opens —
is what resolves; a tile fetch resolves too, in its own thread. This only reports.
False therefore means "no template *yet*", not "give up": a caller that skips its
fetches on it will never let one happen (see
:meth:`meshterm.ui.map_screen.MapScreen._ensure_tiles`, which asks regardless).
"""
return self._template is not None
def answered_empty(self, z: int, x: int, y: int) -> bool:
"""Whether the source *answered* that there is no tile at these coordinates.
The one way to tell the two ``None`` returns of :meth:`load_tile` apart: a tile the
source served as absent (a 404, or bytes holding no layer at all) will never
become anything else, while a tile we simply got no answer about is worth asking
again. Callers that cache the ``None`` need the difference — see
:meth:`meshterm.ui.map_screen.MapScreen._load`.
"""
return (z, x, y) in self._blank
# -- tiles ------------------------------------------------------------------
def _tile_path(self, z: int, x: int, y: int) -> Path:
+56 -11
View File
@@ -32,6 +32,7 @@ from __future__ import annotations
import asyncio
import math
from collections import OrderedDict
from time import monotonic
from typing import TYPE_CHECKING, Callable, Optional
from ..core.geo import DEFAULT_VIEW_FRACTION, EARTH_RADIUS_KM, Viewport, clamp_lat
@@ -87,6 +88,12 @@ _TILE_CACHE_SCREENS = 2
#: history for a pan away and back to be instant.
_MIN_TILE_CACHE = 8
#: How long a tile the source gave no answer about is left alone before it is asked for
#: again. Long enough that a genuinely offline map isn't retrying every visible tile on a
#: loop, short enough that a Wi-Fi blip costs a few seconds of missing streets rather than
#: the rest of the session (see :meth:`MapScreen._load`).
_TILE_RETRY_SECONDS = 20.0
#: The zoom a frame homes in at when the matches set no extent of their own — a
#: single node (or several at one spot) has nothing to frame, so ^Enter zooms to this
#: street-level closeness rather than the fit's neutral default. Capped at the tile
@@ -199,10 +206,13 @@ class MapScreen(Screen):
# :meth:`consume_edge_scrub`). Seeded ``True`` so the first braille frame's edge is
# cleaned even before the first pan.
self._needs_scrub = True
# Decoded tiles keyed by (z, x, y); a stored ``None`` means "fetched, empty/absent".
# Decoded tiles, least-recently-shown first — see :meth:`_trim_tiles`.
# Decoded tiles, least-recently-shown first — see :meth:`_trim_tiles`. A stored
# ``None`` is the source's own answer that there is nothing at those coordinates.
self._tiles: OrderedDict[tuple[int, int, int], Optional[list[Layer]]] = OrderedDict()
self._pending: set[tuple[int, int, int]] = set()
# Tiles the source gave no answer about, and when each may be asked for again —
# a cooldown, not a verdict (see :meth:`_load`).
self._unanswered: dict[tuple[int, int, int], float] = {}
# The last finished ground frame and what it was drawn for — see :meth:`render_body`.
# Rasterizing a downtown view is ~0.5-1 s of pure Python (tens of thousands of
# vector features), far too slow to sit on a keystroke, so it happens off the paint
@@ -487,29 +497,47 @@ class MapScreen(Screen):
# --- tiles ---------------------------------------------------------------
def _ensure_tiles(self, vp: Viewport) -> None:
"""Schedule background fetches for any visible tiles not yet loaded or pending."""
"""Schedule background fetches for any visible tile we don't have and aren't owed.
Asked on every paint, and deliberately **not** gated on
:attr:`~meshterm.services.basemap.BasemapSource.available`: that only reports
whether a template is known *yet*, and skipping the fetch while it isn't is how a
map that opened a moment too early stays empty for the rest of the session. The
fetch resolves the source itself, in its own thread, so asking is what un-sticks it.
A tile the source never answered about waits out :data:`_TILE_RETRY_SECONDS` in
:attr:`_unanswered` and is then asked for again — see :meth:`_load` for why that
isn't the same as a tile it answered "nothing here" about.
"""
wanted = vp.tiles(self._max_tile_zoom)
for t in wanted:
if t in self._tiles:
self._tiles.move_to_end(t) # on screen now, so last in line to be dropped
self._trim_tiles(len(wanted))
if not self._source.available: # offline (resolved at open time) — nodes only
return
if not _loop_running(): # nothing to fetch onto — a static render draws what it has
return
self._expire_cooldowns()
for t in wanted:
if t in self._tiles or t in self._pending:
if t in self._tiles or t in self._pending or t in self._unanswered:
continue
self._pending.add(t)
asyncio.ensure_future(self._load(t))
def _expire_cooldowns(self) -> None:
"""Forget the silences that have served their time, so a long pan can't hoard them."""
if not self._unanswered:
return
now = monotonic()
self._unanswered = {t: at for t, at in self._unanswered.items() if at > now}
def _trim_tiles(self, in_view: int) -> None:
"""Release the least recently shown tiles once the view's budget is exceeded.
Only tiles holding geometry are counted or dropped. An entry whose value is
``None`` is the memory of having *asked* — the tile was absent, or the source
never answered — and it costs a dict slot rather than a megabyte, so it stays;
dropping it would only buy a pointless re-request on the next repaint.
``None`` is the source's word that the tile is absent — a settled answer costing a
dict slot rather than a megabyte, so it stays; dropping it would only buy a
pointless re-request on the next repaint. A tile we got no answer about isn't here
at all: it waits out its cooldown in :attr:`_unanswered` and is asked for again.
Args:
in_view: How many tiles the current viewport needs, which sets the budget.
@@ -527,13 +555,30 @@ class MapScreen(Screen):
loaded -= 1
async def _load(self, t: tuple[int, int, int]) -> None:
"""Fetch+decode one tile off the event loop, then repaint."""
"""Fetch+decode one tile off the event loop, then repaint.
What comes back is filed under the same distinction the tile source keeps (see
:class:`~meshterm.services.basemap._Response`), because this is where forgetting it
costs a picture. Geometry, or the source's own word that there is nothing at those
coordinates, is an answer: it goes in :attr:`_tiles` and is never asked about
again. Silence — offline, a timeout, a body the Wi-Fi cut short — is *not* an
answer, and filing it as one turns one bad moment into a black square that stays
black until the app is restarted. It goes in :attr:`_unanswered` instead, which is
a cooldown rather than a verdict.
That distinction is only visible on a link that actually drops. On the PicoCalc it
is the difference between a map and a map with holes in it (JP, 2026-08-18: tiles
black at the two highest zooms, where one z14 tile is the whole screen).
"""
try:
layers = await asyncio.to_thread(self._source.load_tile, *t)
except Exception: # noqa: BLE001 - a failed tile is just an absent one
layers = None
self._tiles[t] = layers
self._pending.discard(t)
if layers is not None or self._source.answered_empty(*t):
self._tiles[t] = layers
else:
self._unanswered[t] = monotonic() + _TILE_RETRY_SECONDS
self._session.invalidate()
# --- input ---------------------------------------------------------------
+47 -10
View File
@@ -18,6 +18,7 @@ calls :meth:`render` from its own ``render_body`` and forwards nothing back.
from __future__ import annotations
import asyncio
from time import monotonic
from typing import TYPE_CHECKING, Optional
from ..core.geo import Viewport, clamp_lat
@@ -32,6 +33,26 @@ if TYPE_CHECKING: # pragma: no cover - typing only
#: (blurred) basemap rather than blank tiles.
_OVERZOOM = 2
#: How long a tile the source gave no answer about is left alone before the preview asks
#: for it again — the big map's cooldown, for the same reason (see
#: :meth:`meshterm.ui.map_screen.MapScreen._load`).
_TILE_RETRY_SECONDS = 20.0
def _loop_running() -> bool:
"""Whether there is an event loop to hand background work to.
Asked *before* building a coroutine, not after: ``ensure_future`` without a loop
raises, but by then the coroutine exists and never gets awaited, which Python reports
as a resource warning on a path that is otherwise perfectly correct (a screen rendered
in a test, or a one-shot CLI draw).
"""
try:
asyncio.get_running_loop()
except RuntimeError:
return False
return True
class MiniMap:
"""A fixed, non-interactive slippy-map region drawn into a host screen's body.
@@ -74,13 +95,20 @@ class MiniMap:
self._center_lon = center_lon
self._zoom = max(2, min(int(zoom), max_tile_zoom + _OVERZOOM))
self._markers = markers
# Decoded tiles keyed by (z, x, y); a stored ``None`` means "fetched, empty/absent".
# Decoded tiles keyed by (z, x, y); a stored ``None`` is the source's own word that
# there is no tile there. Silence is not that answer and is not stored here.
self._tiles: dict[tuple[int, int, int], Optional[list[Layer]]] = {}
self._pending: set[tuple[int, int, int]] = set()
# Tiles we got no answer about, and when each may be asked for again.
self._unanswered: dict[tuple[int, int, int], float] = {}
@property
def has_basemap(self) -> bool:
"""Whether the source can serve a basemap at all (network reachable, or cached)."""
"""Whether the source has resolved a basemap to draw from — not yet is not never.
The preview keeps asking either way (see :meth:`_ensure_tiles`); this is for a
host that wants to caption the wait.
"""
return self._source.available
@property
@@ -112,17 +140,23 @@ class MiniMap:
return render_map(viewport, tiles, self._markers)
def _ensure_tiles(self, viewport: Viewport) -> None:
"""Schedule background fetches for any visible tiles not yet loaded or pending."""
if not self._source.available: # offline (resolved at open time) — markers only
"""Schedule background fetches for any visible tile we don't have and aren't owed.
Not gated on :attr:`~meshterm.services.basemap.BasemapSource.available`, and a
tile the source gave no answer about is asked for again once its cooldown runs
out — the big map's rules, and for its reasons (see
:meth:`meshterm.ui.map_screen.MapScreen._ensure_tiles`).
"""
if not _loop_running(): # nothing to fetch onto — draw whatever is already here
return
if self._unanswered: # the silences that have served their time
now = monotonic()
self._unanswered = {t: at for t, at in self._unanswered.items() if at > now}
for t in viewport.tiles(self._max_tile_zoom):
if t in self._tiles or t in self._pending:
if t in self._tiles or t in self._pending or t in self._unanswered:
continue
self._pending.add(t)
try:
asyncio.ensure_future(self._load(t))
except RuntimeError: # pragma: no cover - no running loop (non-interactive)
self._pending.discard(t)
asyncio.ensure_future(self._load(t))
async def _load(self, t: tuple[int, int, int]) -> None:
"""Fetch+decode one tile off the event loop, then repaint the host screen."""
@@ -130,6 +164,9 @@ class MiniMap:
layers = await asyncio.to_thread(self._source.load_tile, *t)
except Exception: # noqa: BLE001 - a failed tile is just an absent one
layers = None
self._tiles[t] = layers
self._pending.discard(t)
if layers is not None or self._source.answered_empty(*t):
self._tiles[t] = layers # an answer, settled for the session
else:
self._unanswered[t] = monotonic() + _TILE_RETRY_SECONDS # silence — ask again
self._session.invalidate()
+3
View File
@@ -186,6 +186,9 @@ class _StubSource:
def load_tile(self, z: int, x: int, y: int):
return None
def answered_empty(self, z: int, x: int, y: int) -> bool:
return False # offline is silence, never the source saying "nothing there"
def _picker(markers=None, initial=None):
from meshterm.ui.map_screen import LocationPickScreen
+3
View File
@@ -190,6 +190,9 @@ class _StubTileSource:
def load_tile(self, z: int, x: int, y: int): # noqa: ANN001
return None
def answered_empty(self, z: int, x: int, y: int) -> bool: # noqa: ANN001
return False # offline is silence, never the source saying "nothing there"
def _map(cols: int, rows: int) -> Screen:
session = _GallerySession(cols, rows)
+160 -6
View File
@@ -8,10 +8,12 @@ against the :class:`MockDevice` simulator with the basemap disabled (no network
from __future__ import annotations
import asyncio
import io
import os
import re
from pathlib import Path
from time import monotonic
import pytest
from rich.cells import cell_len
@@ -25,6 +27,7 @@ from meshterm.core.models import (
)
from meshterm.core.mvt import GEOM_LINE, GEOM_POLYGON, Layer, decode_tile
from meshterm.tools.map import MapTool
from meshterm.ui.map_screen import _TILE_RETRY_SECONDS as _TILE_RETRY
from meshterm.ui.mapcanvas import MapCanvas, parse_hex
_FIXTURE = Path(__file__).parent / "fixtures" / "tile_14_4843_5861.mvt"
@@ -681,8 +684,7 @@ def test_basemap_source_never_caches_an_unanswered_fetch(tmp_path: Path) -> None
# The same, with the source resolved and the *fetch* the thing that fails — the flaky
# link the PicoCalc lives on. The tile stays unknown, so the next pan asks again.
src = _offline_source(cache)
src._template = "http://tiles.invalid/{z}/{x}/{y}.pbf"
src._resolved = True
src._template = "http://tiles.invalid/{z}/{x}/{y}.pbf" # resolved: the fetch is what fails
calls: list[str] = []
def _get(url: str):
@@ -696,6 +698,54 @@ def test_basemap_source_never_caches_an_unanswered_fetch(tmp_path: Path) -> None
assert list(cache.rglob("*.pbf")) == []
def test_basemap_source_asks_again_after_a_failed_resolve(tmp_path: Path) -> None:
"""Offline at open is a moment, not a verdict — the PicoCalc's Wi-Fi lands after boot.
Latching the first failure meant an app started alongside the device's network drew
every tile of every session from whatever the cache already held (JP, 2026-08-18).
"""
from meshterm.services import basemap as basemap_mod
src = _offline_source(tmp_path / "cache")
assert src.available is False
assert src.max_zoom == 14 # the default, because nothing was resolved
doc = b'{"tiles": ["http://tiles.invalid/{z}/{x}/{y}.pbf"], "maxzoom": 14}'
src._http_get = lambda url: basemap_mod._Response(True, doc) # type: ignore[method-assign]
src._resolve_after = 0.0 # the cooldown, stepped over rather than slept through
assert src.max_zoom == 14
assert src.available is True, "the source never asked again"
def test_basemap_source_holds_a_failed_resolve_for_its_cooldown(tmp_path: Path) -> None:
"""Asking again is not asking constantly: a genuinely offline map isn't a retry loop."""
from meshterm.services import basemap as basemap_mod
src = _offline_source(tmp_path / "cache")
calls: list[str] = []
src._http_get = lambda url: ( # type: ignore[method-assign]
calls.append(url), basemap_mod._Response(False, b"")
)[1]
for _ in range(5):
assert src.available is False
assert calls == [] # the constructor's own failed resolve still stands
def test_basemap_source_tells_an_empty_answer_from_silence(tmp_path: Path) -> None:
"""The two ``None`` returns of ``load_tile``, told apart — a caching caller needs it."""
from meshterm.services import basemap as basemap_mod
src = _offline_source(tmp_path / "cache")
src._template = "http://tiles.invalid/{z}/{x}/{y}.pbf"
src._http_get = lambda url: basemap_mod._Response(False, b"") # type: ignore[method-assign]
assert src.load_tile(14, 4843, 5861) is None
assert src.answered_empty(14, 4843, 5861) is False # no answer — worth asking again
src._http_get = lambda url: basemap_mod._Response(True, b"") # type: ignore[method-assign]
assert src.load_tile(14, 1, 1) is None
assert src.answered_empty(14, 1, 1) is True # the source said so; that settles it
def test_basemap_source_prunes_a_blank_cached_tile(tmp_path: Path) -> None:
"""A zero-byte entry (an older build's failure marker) is dropped rather than drawn."""
cache = tmp_path / "cache"
@@ -1080,6 +1130,9 @@ class _StubSource:
def load_tile(self, z: int, x: int, y: int):
return None
def answered_empty(self, z: int, x: int, y: int) -> bool:
return False # offline is silence, never the source saying "nothing there"
def _loaded_tile() -> list[Layer]:
"""A stand-in for a decoded tile: truthy, which is all the budget cares about."""
@@ -1398,7 +1451,6 @@ def test_map_frame_chip_lights_only_with_matches_to_frame() -> None:
def test_map_screen_find_filters_frames_and_clears() -> None:
"""Typing builds the query; ^Enter frames matches; Enter/Esc drop it; Esc then leaves."""
import asyncio
from meshterm.ui.map_render import MapMarker
from meshterm.ui.map_screen import MapScreen
@@ -1584,7 +1636,6 @@ def test_map_screen_scrubs_right_edge_after_move() -> None:
def test_map_screen_escape_dismisses() -> None:
"""Esc resolves the screen's future with None (backs out to the menu)."""
import asyncio
from meshterm.ui.map_render import MapMarker
from meshterm.ui.map_screen import MapScreen
@@ -1640,6 +1691,104 @@ def test_render_map_find_matches_still_label_white() -> None:
assert _glyph_color(lines, "TARGET") == (255, 255, 255)
# --- a tile nobody answered about is asked for again ----------------------------------
def _map_over(source) -> "MapScreen": # noqa: ANN001
"""A map screen fetching from ``source``, with an event loop it can hand work to."""
from meshterm.ui.map_render import MapMarker
from meshterm.ui.map_screen import MapScreen
return MapScreen(
_StubSession(80, 24), [MapMarker("A", 45.5, -73.6)], source, 14
)
class _SilentSource(_StubSource):
"""A source that never answers — the flaky Wi-Fi, not an empty planet."""
def __init__(self) -> None:
self.asked: list[tuple[int, int, int]] = []
def load_tile(self, z: int, x: int, y: int):
self.asked.append((z, x, y))
return None
class _EmptySource(_SilentSource):
"""A source that answers, and the answer is that there is nothing at those tiles."""
def answered_empty(self, z: int, x: int, y: int) -> bool:
return True
def test_map_asks_again_for_a_tile_it_got_no_answer_about(monkeypatch) -> None: # noqa: ANN001
"""One Wi-Fi blip must not black out that ground until the app is restarted.
On the PicoCalc a missing z14 tile *is* the picture at the two highest zooms, where
one tile covers the whole screen many times over (JP, 2026-08-18).
"""
from meshterm.ui import map_screen as ms
source = _SilentSource()
screen = _map_over(source)
async def drive() -> None:
screen.render_body(80)
while screen._pending:
await asyncio.sleep(0)
first = len(source.asked)
assert first, "no tile was ever asked for"
screen.render_body(80) # still inside the cooldown
await asyncio.sleep(0)
assert len(source.asked) == first, "the source is being hammered"
monkeypatch.setattr(ms, "monotonic", lambda: monotonic() + _TILE_RETRY + 1)
screen.render_body(80)
while screen._pending:
await asyncio.sleep(0)
assert len(source.asked) > first, "the unanswered tile was written off for good"
asyncio.run(drive())
def test_map_takes_the_sources_word_that_a_tile_is_empty(monkeypatch) -> None: # noqa: ANN001
"""An answer settles it: ocean tiles must not be re-requested for ever."""
from meshterm.ui import map_screen as ms
source = _EmptySource()
screen = _map_over(source)
async def drive() -> None:
screen.render_body(80)
while screen._pending:
await asyncio.sleep(0)
asked = len(source.asked)
monkeypatch.setattr(ms, "monotonic", lambda: monotonic() + _TILE_RETRY * 10)
screen.render_body(80)
await asyncio.sleep(0)
assert len(source.asked) == asked, "a settled answer was asked about again"
asyncio.run(drive())
def test_map_fetches_before_the_source_has_resolved(monkeypatch) -> None: # noqa: ANN001
"""``available`` says "not yet", never "don't bother" — a fetch is what resolves it."""
source = _SilentSource()
assert source.available is False # nothing has reached the network at open time
screen = _map_over(source)
async def drive() -> None:
screen.render_body(80)
while screen._pending:
await asyncio.sleep(0)
assert source.asked, "the map wrote the source off instead of asking it"
asyncio.run(drive())
# --- the ground raster runs off the paint path ---------------------------------------
@@ -1677,18 +1826,23 @@ def test_map_paints_without_waiting_for_the_ground(monkeypatch) -> None: # noqa
assert screen._drawing is not None, "no background raster was scheduled"
def _rasters(started: list) -> list:
"""Just the ground-rasterizing coroutines — a pan also schedules its tile fetches."""
return [c for c in started[0] if "_draw_ground" in c.__qualname__]
def test_map_keeps_one_raster_in_flight_while_panning(monkeypatch) -> None: # noqa: ANN001
"""A held arrow key must not queue a second of thread work per keypress."""
started: list = []
screen = _async_map(monkeypatch, started)
screen.render_body(80)
scheduled = len(started[0])
scheduled = len(_rasters(started))
for _ in range(8):
screen.handle("right")
screen.render_body(80)
assert len(started[0]) == scheduled, "a second raster started before the first finished"
assert len(_rasters(started)) == scheduled, "a second raster started before the first finished"
assert screen._wanted is not None, "the newest view was not remembered for next"