OpenGeodeWeb-Back 6.17.0rc1__tar.gz → 6.17.0rc2__tar.gz

{opengeodeweb_back-6.17.0rc1 → opengeodeweb_back-6.17.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.17.0rc1
+Version: 6.17.0rc2
 Summary: OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back
@@ -13,6 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: asgiref==3.*
 Requires-Dist: blinker==1.*
+Requires-Dist: certifi==2026.7.22
 Requires-Dist: click==8.*
 Requires-Dist: defusedxml==0.7.1
 Requires-Dist: flask[async]==3.*
@@ -28,6 +29,7 @@ Requires-Dist: opengeode-geosciencesio==5.13.1
 Requires-Dist: opengeode-inspector==6.12.4
 Requires-Dist: opengeode-inspector-geosciences==1.2.4
 Requires-Dist: opengeode-io==7.11.2
+Requires-Dist: pillow==13.0.0
 Requires-Dist: types-defusedxml==0.7.0.20260504
 Requires-Dist: werkzeug==3.1.8
 Requires-Dist: opengeodeweb-microservice==1.*,>=1.3.2

{opengeodeweb_back-6.17.0rc1 → opengeodeweb_back-6.17.0rc2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenGeodeWeb-Back"
-version = "6.17.0-rc.1"
+version = "6.17.0-rc.2"
 dynamic = ["dependencies"]
 authors = [{ name = "Geode-solutions", email = "team-web@geode-solutions.com" }]
 description = "OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem"
@@ -34,4 +34,5 @@ where = ["src"]
 "opengeodeweb_back.routes.models.schemas" = ["*.json"]
 "opengeodeweb_back.routes.create.schemas" = ["*.json"]
 "opengeodeweb_back.routes.crs.schemas" = ["*.json"]
+"opengeodeweb_back.routes.basemap.schemas" = ["*.json"]
 "opengeodeweb_back" = ["py.typed"]

{opengeodeweb_back-6.17.0rc1 → opengeodeweb_back-6.17.0rc2}/requirements.txt

@@ -8,6 +8,8 @@ asgiref==3.*
     # via flask
 blinker==1.*
     # via flask
+certifi==2026.7.22
+    # via -r requirements.in
 click==8.*
     # via flask
 defusedxml==0.7.1
@@ -62,6 +64,8 @@ opengeode-io==7.11.2
     #   -r requirements.in
     #   geode-viewables
     #   opengeode-geosciencesio
+pillow==13.0.0
+    # via -r requirements.in
 types-defusedxml==0.7.0.20260504
     # via -r requirements.in
 werkzeug==3.1.8

{opengeodeweb_back-6.17.0rc1 → opengeodeweb_back-6.17.0rc2}/src/OpenGeodeWeb_Back.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.17.0rc1
+Version: 6.17.0rc2
 Summary: OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back
@@ -13,6 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: asgiref==3.*
 Requires-Dist: blinker==1.*
+Requires-Dist: certifi==2026.7.22
 Requires-Dist: click==8.*
 Requires-Dist: defusedxml==0.7.1
 Requires-Dist: flask[async]==3.*
@@ -28,6 +29,7 @@ Requires-Dist: opengeode-geosciencesio==5.13.1
 Requires-Dist: opengeode-inspector==6.12.4
 Requires-Dist: opengeode-inspector-geosciences==1.2.4
 Requires-Dist: opengeode-io==7.11.2
+Requires-Dist: pillow==13.0.0
 Requires-Dist: types-defusedxml==0.7.0.20260504
 Requires-Dist: werkzeug==3.1.8
 Requires-Dist: opengeodeweb-microservice==1.*,>=1.3.2

{opengeodeweb_back-6.17.0rc1 → opengeodeweb_back-6.17.0rc2}/src/OpenGeodeWeb_Back.egg-info/SOURCES.txt

@@ -16,6 +16,10 @@ src/opengeodeweb_back/py.typed
 src/opengeodeweb_back/test_utils.py
 src/opengeodeweb_back/typed_route.py
 src/opengeodeweb_back/utils_functions.py
+src/opengeodeweb_back/basemap/__init__.py
+src/opengeodeweb_back/basemap/basemap_mesh.py
+src/opengeodeweb_back/basemap/basemap_providers.py
+src/opengeodeweb_back/basemap/basemap_tiles.py
 src/opengeodeweb_back/crs/__init__.py
 src/opengeodeweb_back/crs/crs_alignment.py
 src/opengeodeweb_back/crs/crs_assignment.py
@@ -58,6 +62,13 @@ src/opengeodeweb_back/geode_objects/geode_triangulated_surface3d.py
 src/opengeodeweb_back/geode_objects/geode_vertex_set.py
 src/opengeodeweb_back/routes/__init__.py
 src/opengeodeweb_back/routes/blueprint_routes.py
+src/opengeodeweb_back/routes/basemap/__init__.py
+src/opengeodeweb_back/routes/basemap/blueprint_basemap.py
+src/opengeodeweb_back/routes/basemap/schemas/__init__.py
+src/opengeodeweb_back/routes/basemap/schemas/build.json
+src/opengeodeweb_back/routes/basemap/schemas/build.py
+src/opengeodeweb_back/routes/basemap/schemas/delete.json
+src/opengeodeweb_back/routes/basemap/schemas/delete.py
 src/opengeodeweb_back/routes/create/__init__.py
 src/opengeodeweb_back/routes/create/blueprint_create.py
 src/opengeodeweb_back/routes/create/schemas/__init__.py
@@ -149,6 +160,7 @@ src/opengeodeweb_back/routes/schemas/vertex_attribute_names.json
 src/opengeodeweb_back/routes/schemas/vertex_attribute_names.py
 src/opengeodeweb_back/routes/schemas/vertex_attribute_range.json
 src/opengeodeweb_back/routes/schemas/vertex_attribute_range.py
+tests/test_basemap.py
 tests/test_create_routes.py
 tests/test_crs_routes.py
 tests/test_events.py

{opengeodeweb_back-6.17.0rc1 → opengeodeweb_back-6.17.0rc2}/src/OpenGeodeWeb_Back.egg-info/requires.txt

@@ -1,5 +1,6 @@
 asgiref==3.*
 blinker==1.*
+certifi==2026.7.22
 click==8.*
 defusedxml==0.7.1
 flask[async]==3.*
@@ -15,6 +16,7 @@ opengeode-geosciencesio==5.13.1
 opengeode-inspector==6.12.4
 opengeode-inspector-geosciences==1.2.4
 opengeode-io==7.11.2
+pillow==13.0.0
 types-defusedxml==0.7.0.20260504
 werkzeug==3.1.8
 opengeodeweb-microservice==1.*,>=1.3.2

{opengeodeweb_back-6.17.0rc1 → opengeodeweb_back-6.17.0rc2}/src/opengeodeweb_back/app.py

@@ -19,6 +19,7 @@ from werkzeug.exceptions import HTTPException
 
 from opengeodeweb_back import app_config, utils_functions
 from opengeodeweb_back.routes import blueprint_routes
+from opengeodeweb_back.routes.basemap import blueprint_basemap
 from opengeodeweb_back.routes.create import blueprint_create
 from opengeodeweb_back.routes.crs import blueprint_crs
 
@@ -177,6 +178,11 @@ def register_ogw_back_blueprints(app: flask.Flask) -> None:
         url_prefix="/opengeodeweb_back/crs",
         name="opengeodeweb_crs",
     )
+    app.register_blueprint(
+        blueprint_basemap.routes,
+        url_prefix="/opengeodeweb_back/basemap",
+        name="opengeodeweb_basemap",
+    )
 
 
 def run_server(app: Flask) -> None:

opengeodeweb_back-6.17.0rc2/src/opengeodeweb_back/basemap/basemap_mesh.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+# Standard library imports
+import math
+from typing import TYPE_CHECKING
+
+# Third party imports
+import opengeode as og
+import opengeode_geosciences as og_geosciences
+
+# Local application imports
+from opengeodeweb_back.basemap.basemap_tiles import HALF_WORLD
+from opengeodeweb_back.crs.crs_functions import convert_xy_corners
+from opengeodeweb_back.geode_objects.geode_triangulated_surface3d import (
+    GeodeTriangulatedSurface3D,
+)
+
+if TYPE_CHECKING:
+    from opengeodeweb_back.basemap.basemap_tiles import TileRange
+
+GRID_SIZE = 32
+MESH_NAME = "basemap"
+UV_ATTRIBUTE = "basemap_uv"
+WEB_MERCATOR = og_geosciences.GeographicCoordinateSystemInfo(
+    "EPSG", "3857", "WGS 84 / Pseudo-Mercator"
+)
+OUTSIDE_MESSAGE = "Area outside the map projection limits"
+
+
+class OutsideProjectionError(Exception):
+    pass
+
+
+def bounds_to_3857(
+    bounds: tuple[float, float, float, float],
+    crs: og_geosciences.GeographicCoordinateSystemInfo,
+) -> tuple[float, float, float, float]:
+    """Bounding box in Web Mercator of the four corners of bounds, given in crs."""
+    try:
+        corners = convert_xy_corners(bounds, crs, WEB_MERCATOR)
+    except RuntimeError as error:  # PROJ rejects coordinates outside either CRS domain
+        raise OutsideProjectionError(OUTSIDE_MESSAGE) from error
+    xs = [x for x, _ in corners]
+    ys = [y for _, y in corners]
+    projected = (min(xs), min(ys), max(xs), max(ys))
+    if any(not abs(value) <= HALF_WORLD for value in projected):  # also rejects NaN
+        raise OutsideProjectionError(OUTSIDE_MESSAGE)
+    return projected
+
+
+def build_mesh(
+    tiles: TileRange,
+    crs: og_geosciences.GeographicCoordinateSystemInfo,
+    z_value: float,
+) -> GeodeTriangulatedSurface3D:
+    """Grid covering the tiles, with texture coordinates, converted from Web Mercator to crs."""
+    x0, y0, x1, y1 = tiles.bounds_3857()
+    mesh = GeodeTriangulatedSurface3D()
+    builder = mesh.builder()
+    builder.set_name(MESH_NAME)
+    attributes = mesh.triangulated_surface.vertex_attribute_manager()
+    values = og.AttributeValuesArrayDouble2()
+    values.default_value = [0.0, 0.0]
+    uv_id = attributes.create_attribute_variable_arraydouble2(
+        UV_ATTRIBUTE, values, og.AttributeProperties()
+    )
+    uv = attributes.find_attribute_variable_arraydouble2(uv_id)
+    last = GRID_SIZE - 1
+    for row in range(GRID_SIZE):
+        for column in range(GRID_SIZE):
+            u, v = column / last, row / last
+            point = og.Point3D([x0 + u * (x1 - x0), y0 + v * (y1 - y0), z_value])
+            uv.set_value(builder.create_point(point), [u, v])
+    for row in range(last):
+        for column in range(last):
+            corner = row * GRID_SIZE + column
+            builder.create_triangle([corner, corner + 1, corner + GRID_SIZE + 1])
+            builder.create_triangle([corner, corner + GRID_SIZE + 1, corner + GRID_SIZE])
+    builder.compute_polygon_adjacencies()
+    mesh.assign_crs(WEB_MERCATOR.authority_code(), WEB_MERCATOR)
+    # Assigning then converting to the same CRS name is rejected by OpenGeode
+    if crs.authority_code() == WEB_MERCATOR.authority_code():
+        return mesh
+    try:
+        mesh.convert_crs(crs.authority_code(), crs)
+    except RuntimeError as error:  # PROJ rejects tiles outside the project CRS domain
+        raise OutsideProjectionError(OUTSIDE_MESSAGE) from error
+    surface = mesh.triangulated_surface
+    for vertex in range(surface.nb_vertices()):
+        point = surface.point(vertex)
+        if not all(math.isfinite(point.value(axis)) for axis in range(3)):
+            raise OutsideProjectionError(OUTSIDE_MESSAGE)
+    return mesh

opengeodeweb_back-6.17.0rc2/src/opengeodeweb_back/basemap/basemap_providers.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+# Standard library imports
+import os
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from collections.abc import Container, Iterable
+
+USER_AGENT = "Vease (+https://geode-solutions.com)"
+# Every source is cut in 256 px Web Mercator tiles: they share one tile grid
+TILE_SIZE = 256
+
+
+@dataclass(frozen=True)
+class Source:
+    url_template: str
+    max_zoom: int
+    attribution: str
+
+
+_GEOPLATEFORME = (
+    "https://data.geopf.fr/wmts?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0&LAYER={layer}"
+    "&STYLE=normal&TILEMATRIXSET=PM&TILEMATRIX={{z}}&TILEROW={{y}}&TILECOL={{x}}&FORMAT={format}"
+)
+_IGN = "© IGN"
+
+SOURCES: dict[str, Source] = {
+    "eox_s2cloudless_2016": Source(
+        "https://tiles.maps.eox.at/wmts/1.0.0/s2cloudless_3857/default/g/{z}/{y}/{x}.jpg",
+        17,
+        "Sentinel-2 cloudless 2016 by EOX IT Services GmbH "
+        "(Contains modified Copernicus Sentinel data 2016)",
+    ),
+    "ign_orthophotos": Source(
+        _GEOPLATEFORME.format(layer="ORTHOIMAGERY.ORTHOPHOTOS", format="image/jpeg"), 19, _IGN
+    ),
+    # Volunteer servers: to be replaced before production, see the basemap design
+    "osm": Source(
+        "https://tile.openstreetmap.org/{z}/{x}/{y}.png", 19, "© OpenStreetMap contributors"
+    ),
+    "ign_plan": Source(
+        _GEOPLATEFORME.format(layer="GEOGRAPHICALGRIDSYSTEMS.PLANIGNV2", format="image/png"),
+        19,
+        _IGN,
+    ),
+    "ign_roads": Source(
+        _GEOPLATEFORME.format(layer="TRANSPORTNETWORKS.ROADS", format="image/png"), 18, _IGN
+    ),
+    "eox_overlay": Source(
+        "https://tiles.maps.eox.at/wmts/1.0.0/overlay_3857/default/g/{z}/{y}/{x}.png",
+        14,
+        "© OpenStreetMap contributors, rendering © EOX",
+    ),
+}
+
+# The layers of each map, from the bottom up. A layer draws the first of its sources serving a
+# tile: the next one is only fetched when it serves none
+MAPS: dict[str, tuple[tuple[str, ...], ...]] = {
+    # The IGN covers the world imagery or map where it has tiles (France)
+    "satellite": (("eox_s2cloudless_2016",), ("ign_orthophotos",)),
+    "plan": (("osm",), ("ign_plan",)),
+    # Transparent: both sources would draw the same roads twice, EOX outside France
+    "routes": (("ign_roads", "eox_overlay"),),
+}
+
+
+def url_template(source: str) -> str:
+    # Local servers for tests: one variable per source, else one for all where {source} is replaced
+    template = os.environ.get(f"BASEMAP_TILE_URL_{source.upper()}")
+    if template is not None:
+        return template
+    shared = os.environ.get("BASEMAP_TILE_URL")
+    if shared is not None:
+        return shared.replace("{source}", source)
+    return SOURCES[source].url_template
+
+
+def sorted_maps(maps: Iterable[str]) -> list[str]:
+    requested = set(maps)
+    return [name for name in MAPS if name in requested]
+
+
+def map_layers(maps: list[str], served: Container[str]) -> dict[str, list[str]]:
+    """The served sources of each sorted map, from the bottom up: maps without any are left out."""
+    layers = {
+        name: [source for layer in MAPS[name] for source in layer if source in served]
+        for name in maps
+    }
+    return {name: sources for name, sources in layers.items() if sources}
+
+
+def max_zoom(sources: Iterable[str]) -> int:
+    # The grid follows the finest source: coarser ones are overzoomed
+    return max(SOURCES[source].max_zoom for source in sources)
+
+
+def attribution(sources: Iterable[str]) -> str:
+    return " | ".join(dict.fromkeys(SOURCES[source].attribution for source in sources))

opengeodeweb_back-6.17.0rc2/src/opengeodeweb_back/basemap/basemap_tiles.py

@@ -0,0 +1,312 @@
+from __future__ import annotations
+
+# Standard library imports
+import contextlib
+import hashlib
+import http.client
+import io
+import math
+import os
+import ssl
+import tempfile
+import threading
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from concurrent.futures import ThreadPoolExecutor, wait
+from dataclasses import dataclass
+from http import HTTPStatus
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+# Third party imports
+import certifi
+from PIL import Image
+
+# Local application imports
+from opengeodeweb_back import geode_functions
+from opengeodeweb_back.basemap.basemap_providers import (
+    SOURCES,
+    TILE_SIZE,
+    USER_AGENT,
+    url_template,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+# Folder of a basemap data holding its tiles: only basemaps have one
+TILES_FOLDER = "tiles"
+HALF_WORLD = 20037508.342789244
+DEFAULT_MAX_PIXELS = 2048
+PNG_SIGNATURE = b"\x89PNG"
+JPEG_QUALITY = 90
+# Cached in place of a tile the server does not have, so it is not asked again
+MISSING_TILE = b"missing"
+FETCH_WORKERS = 8
+MAX_REQUESTS_PER_HOST = 8
+FETCH_TIMEOUT_SECONDS = 10
+# Whole download of a build: a hanging server must not hold the request for minutes
+FETCH_DEADLINE_SECONDS = 30
+# IncompleteRead and other HTTPException are not OSError
+DOWNLOAD_ERRORS = (OSError, http.client.HTTPException)
+# Packaged binaries ship their own OpenSSL, which may not find the system certificates
+SSL_CONTEXT = ssl.create_default_context(cafile=certifi.where())
+
+
+_HOST_LIMITS: dict[str, threading.Semaphore] = {}
+_HOST_LIMITS_LOCK = threading.Lock()
+
+
+def _host_limit(url: str) -> threading.Semaphore:
+    # Sources fetched in parallel share the connections their server accepts
+    host = urllib.parse.urlparse(url).netloc
+    with _HOST_LIMITS_LOCK:
+        return _HOST_LIMITS.setdefault(host, threading.Semaphore(MAX_REQUESTS_PER_HOST))
+
+
+def _tile_span(z: int) -> float:
+    return 2 * HALF_WORLD / (1 << z)
+
+
+@dataclass(frozen=True)
+class TileRange:
+    z: int
+    x_min: int
+    x_max: int
+    y_min: int
+    y_max: int
+
+    def bounds_3857(self) -> tuple[float, float, float, float]:
+        span = _tile_span(self.z)
+        # Tile rows grow southward from the north edge of the world
+        return (
+            -HALF_WORLD + self.x_min * span,
+            HALF_WORLD - (self.y_max + 1) * span,
+            -HALF_WORLD + (self.x_max + 1) * span,
+            HALF_WORLD - self.y_min * span,
+        )
+
+    def tiles(self) -> list[tuple[int, int]]:
+        return [
+            (x, y)
+            for x in range(self.x_min, self.x_max + 1)
+            for y in range(self.y_min, self.y_max + 1)
+        ]
+
+
+def _range_at(bounds_3857: tuple[float, float, float, float], z: int) -> TileRange:
+    span = _tile_span(z)
+    last = (1 << z) - 1
+    x_min, y_min, x_max, y_max = bounds_3857
+
+    def column(x: float) -> int:
+        return min(last, max(0, math.floor((x + HALF_WORLD) / span)))
+
+    def row(y: float) -> int:
+        return min(last, max(0, math.floor((HALF_WORLD - y) / span)))
+
+    return TileRange(z, column(x_min), column(x_max), row(y_max), row(y_min))
+
+
+def tile_range(
+    bounds_3857: tuple[float, float, float, float],
+    max_zoom: int,
+    max_pixels: int = DEFAULT_MAX_PIXELS,
+) -> TileRange:
+    """Most detailed tile range whose mosaic side stays within max_pixels."""
+    best = _range_at(bounds_3857, 0)
+    for z in range(1, max_zoom + 1):
+        candidate = _range_at(bounds_3857, z)
+        columns = candidate.x_max - candidate.x_min + 1
+        rows = candidate.y_max - candidate.y_min + 1
+        if max(columns, rows) * TILE_SIZE > max_pixels:
+            break
+        best = candidate
+    return best
+
+
+def _cache_folder() -> Path:
+    default = Path(tempfile.gettempdir()) / "opengeodeweb_basemap_cache"
+    return Path(os.environ.get("BASEMAP_CACHE_FOLDER", str(default)))
+
+
+def _is_image(content: bytes) -> bool:
+    # Error pages come back as HTTP 200 with a text body
+    return content.startswith((PNG_SIGNATURE, b"\xff\xd8"))
+
+
+def _read_cache(cached: Path) -> bytes | None:
+    try:
+        content = cached.read_bytes()
+    except OSError:
+        return None
+    # A file broken by a crash or a disk error is downloaded again
+    return content if content == MISSING_TILE or _is_image(content) else None
+
+
+def _write_cache(cached: Path, content: bytes) -> None:
+    # Best effort: a tile that cannot be cached is still used
+    try:
+        cached.parent.mkdir(parents=True, exist_ok=True)
+        descriptor, temporary = tempfile.mkstemp(dir=cached.parent, prefix=f".{cached.name}.")
+    except OSError:
+        return
+    try:
+        with os.fdopen(descriptor, "wb") as file:
+            file.write(content)
+        # Atomic: a concurrent build never reads a half-written tile
+        Path(temporary).replace(cached)
+    except OSError:
+        with contextlib.suppress(OSError):
+            Path(temporary).unlink()
+
+
+def _fetch_tile(source: str, z: int, x: int, y: int) -> bytes | None:
+    # The template hash keeps tiles of an overridden URL apart
+    template = url_template(source)
+    template_hash = hashlib.sha256(template.encode()).hexdigest()[:12]
+    cached = _cache_folder() / source / template_hash / str(z) / str(x) / str(y)
+    cached_content = _read_cache(cached)
+    if cached_content is not None:
+        return None if cached_content == MISSING_TILE else cached_content
+    # Open tile servers ask every application to name itself
+    url = template.format(z=z, x=x, y=y)
+    request = urllib.request.Request(  # noqa: S310 URL from the source table or the environment
+        url, headers={"User-Agent": USER_AGENT}
+    )
+    try:
+        with (
+            _host_limit(url),
+            urllib.request.urlopen(  # noqa: S310
+                request, timeout=FETCH_TIMEOUT_SECONDS, context=SSL_CONTEXT
+            ) as response,
+        ):
+            content: bytes = response.read()
+    except urllib.error.HTTPError as error:
+        error.close()
+        # Outside its area (the IGN outside France) a server answers 404: unlike a timeout or a
+        # network error, asking again would give the same answer
+        if error.code == HTTPStatus.NOT_FOUND:
+            _write_cache(cached, MISSING_TILE)
+        return None
+    except DOWNLOAD_ERRORS:
+        return None
+    if not _is_image(content):
+        return None
+    _write_cache(cached, content)
+    return content
+
+
+def _overzoomed(
+    parent: bytes | None, depth: int, children: list[tuple[int, int]]
+) -> dict[tuple[int, int], bytes | None]:
+    """The sub-squares of a parent tile covering its children, `depth` zooms deeper."""
+    if parent is None:
+        return dict.fromkeys(children)
+    side = TILE_SIZE >> depth
+    images: dict[tuple[int, int], bytes | None] = {}
+    try:
+        # Decoded once for all its children
+        with Image.open(io.BytesIO(parent)) as opened:
+            transparent = opened.mode in ("RGBA", "LA", "PA") or "transparency" in opened.info
+            # Palette and bilevel modes ignore BILINEAR: they become true colour first
+            image = opened.convert("RGBA" if transparent else "RGB")
+        # Opaque tiles stay JPEG: smaller and faster to encode than PNG, which ignores the quality
+        image_format = "PNG" if transparent else "JPEG"
+        for x, y in children:
+            left = (x % (1 << depth)) * side
+            top = (y % (1 << depth)) * side
+            part = image.crop((left, top, left + side, top + side)).resize(
+                (TILE_SIZE, TILE_SIZE), Image.Resampling.BILINEAR
+            )
+            output = io.BytesIO()
+            part.save(output, format=image_format, quality=JPEG_QUALITY)
+            images[(x, y)] = output.getvalue()
+    except OSError:  # UnidentifiedImageError included
+        return dict.fromkeys(children)
+    return images
+
+
+@contextlib.contextmanager
+def _downloads(workers: int) -> Iterator[ThreadPoolExecutor]:
+    executor = ThreadPoolExecutor(workers)
+    try:
+        yield executor
+    finally:
+        # Past the deadline the requests still running end on their own: the build does not wait
+        executor.shutdown(wait=False, cancel_futures=True)
+
+
+def _source_tiles(
+    source: str, tiles: TileRange, downloads: ThreadPoolExecutor, deadline: float
+) -> dict[tuple[int, int], bytes | None]:
+    # Past its max zoom a source has no tile: its parent tiles are enlarged instead
+    depth = max(0, tiles.z - SOURCES[source].max_zoom)
+    z = tiles.z - depth
+    children: dict[tuple[int, int], list[tuple[int, int]]] = {}
+    for x, y in tiles.tiles():
+        children.setdefault((x >> depth, y >> depth), []).append((x, y))
+    futures = {parent: downloads.submit(_fetch_tile, source, z, *parent) for parent in children}
+    done, _ = wait(futures.values(), timeout=max(0.0, deadline - time.monotonic()))
+    images: dict[tuple[int, int], bytes | None] = {}
+    for parent, future in futures.items():
+        # An unfinished tile counts as missing
+        content = future.result() if future in done else None
+        if depth == 0:
+            images[parent] = content
+        else:
+            images |= _overzoomed(content, depth, children[parent])
+    return images
+
+
+def fetch_tiles(source: str, tiles: TileRange) -> dict[tuple[int, int], bytes | None]:
+    with _downloads(FETCH_WORKERS) as downloads:
+        return _source_tiles(source, tiles, downloads, time.monotonic() + FETCH_DEADLINE_SECONDS)
+
+
+def _first_served(
+    layer: tuple[str, ...], tiles: TileRange, downloads: ThreadPoolExecutor, deadline: float
+) -> tuple[str, dict[tuple[int, int], bytes | None]] | None:
+    for source in layer:
+        images = _source_tiles(source, tiles, downloads, deadline)
+        if any(images.values()):
+            return source, images
+    return None
+
+
+def fetch_layers(
+    layers: list[tuple[str, ...]], tiles: TileRange
+) -> dict[str, dict[tuple[int, int], bytes | None]]:
+    """The tiles of the first source serving any in each layer, by source.
+
+    Every layer at once: the slowest server sets the wait, not the sum of them.
+    """
+    deadline = time.monotonic() + FETCH_DEADLINE_SECONDS
+    with (
+        _downloads(FETCH_WORKERS * max(1, len(layers))) as downloads,
+        ThreadPoolExecutor(max(1, len(layers))) as executor,
+    ):
+        served = executor.map(
+            lambda layer: _first_served(layer, tiles, downloads, deadline), layers
+        )
+        return dict(item for item in served if item is not None)
+
+
+def _extension(content: bytes) -> str:
+    # The viewer picks its image reader from the file extension
+    return "png" if content.startswith(PNG_SIGNATURE) else "jpg"
+
+
+def save_tiles(tiles: TileRange, images: dict[tuple[int, int], bytes | None], folder: Path) -> None:
+    """Writes each tile as <column>_<row>.<ext>, counted from the north-west corner."""
+    folder.mkdir(parents=True, exist_ok=True)
+    for (x, y), content in images.items():
+        if content is not None:
+            name = f"{x - tiles.x_min}_{y - tiles.y_min}.{_extension(content)}"
+            (folder / name).write_bytes(content)
+
+
+def is_basemap(data_id: str) -> bool:
+    return Path(geode_functions.data_file_path(data_id, TILES_FOLDER)).is_dir()