xvrt 0.1.0__py3-none-any.whl

xvrt/__init__.py

@@ -0,0 +1,16 @@
+"""xvrt: write GDAL multidimensional VRT from xarray Datasets and STAC catalogues.
+
+A pure-Python writer. ``write_mdim_vrt`` takes an ``xarray.Dataset`` plus the
+source files and emits a GDAL multidim VRT; ``from_stac`` builds one from
+STAC catalogue fields alone. Output validates against GDAL's ``gdalvrt.xsd``.
+
+Documentation: https://hypertidy.github.io/xvrt/
+"""
+from __future__ import annotations
+
+from ._writer import write_mdim_vrt, encode_datetime_coord
+from ._errors import VrtWriterError
+from ._stac import from_stac
+
+__all__ = ["write_mdim_vrt", "from_stac", "encode_datetime_coord", "VrtWriterError"]
+__version__ = "0.1.0"

xvrt/_coords.py

@@ -0,0 +1,90 @@
+"""Coord value carrier dispatch.
+
+Three carriers, per the plan:
+
+- ``<RegularlySpacedValues start= increment=/>`` when uniform spacing is
+  detected within a tolerance
+- ``<InlineValuesWithValueElement><Value>...</Value>...</InlineValuesWithValueElement>``
+  for small non-regular coords
+- ``<Source>...</Source>`` pointing at a coord variable in one of the source
+  files, for large coords (typical 2D lon/lat grids)
+
+The ``coord_mode`` argument on :func:`xvrt.write_mdim_vrt` selects policy:
+
+- ``"auto"``: regular-spacing detection, else inline below threshold, else
+  source-ref
+- ``"inline"``: always inline (errors if coord exceeds XML practicality)
+- ``"source"``: always source-ref (caller promises the coord is in the source)
+- ``dict``: per-coord override, e.g. ``{"time": "inline", "lat": "source"}``
+"""
+from __future__ import annotations
+
+from typing import Literal, Mapping
+
+import numpy as np
+
+from ._errors import VrtWriterError
+
+
+CoordMode = Literal["auto", "inline", "source"]
+
+_DEFAULT_INLINE_THRESHOLD = 10_000
+_REGULAR_RTOL = 1e-9
+_REGULAR_ATOL = 1e-15
+
+
+def detect_regular(values: np.ndarray) -> tuple[float, float] | None:
+    """Return (start, increment) if the values are uniformly spaced, else None.
+
+    Uses :func:`numpy.isclose` with tight tolerances — suitable for real-world
+    coord axes (daily time stamps, regular lat/lon grids) but strict enough
+    that float drift in concatenated chunks won't be misidentified.
+
+    Empty or single-element arrays are not regular.
+    """
+    if values.ndim != 1 or values.size < 2:
+        return None
+    # Float-safe: require all diffs equal to within tolerance.
+    diffs = np.diff(values.astype(np.float64))
+    if diffs.size == 0:
+        return None
+    first = diffs[0]
+    if not np.all(np.isclose(diffs, first, rtol=_REGULAR_RTOL, atol=_REGULAR_ATOL)):
+        return None
+    # Reject zero increment — degenerate.
+    if first == 0:
+        return None
+    # Increment from the end points, not the first difference: the first
+    # difference of decoded floats carries rounding noise (0.01 comes back as
+    # 0.010000000000005116), and the end-point estimate averages it away.
+    v = values.astype(np.float64)
+    return float(v[0]), float((v[-1] - v[0]) / (v.size - 1))
+
+
+def resolve_mode(
+    coord_name: str,
+    values: np.ndarray,
+    mode: CoordMode | Mapping[str, CoordMode],
+    threshold: int = _DEFAULT_INLINE_THRESHOLD,
+) -> CoordMode:
+    """Resolve the coord-mode for a specific coord.
+
+    ``mode`` may be a scalar policy or a per-coord dict. ``"auto"`` chooses
+    between inline and source based on ``values.size`` and ``threshold``;
+    regular-spacing detection is applied *before* this dispatch in
+    :func:`xvrt._writer`.
+    """
+    if isinstance(mode, Mapping):
+        chosen = mode.get(coord_name, "auto")
+    else:
+        chosen = mode
+
+    if chosen not in ("auto", "inline", "source"):
+        raise VrtWriterError(
+            f"coord_mode for {coord_name!r}: expected 'auto'|'inline'|'source', "
+            f"got {chosen!r}"
+        )
+
+    if chosen == "auto":
+        chosen = "inline" if values.size <= threshold else "source"
+    return chosen

xvrt/_dtype.py

@@ -0,0 +1,63 @@
+"""numpy dtype → GDAL VRT DataType string.
+
+In the multidim XSD, ``<DataType>`` is ``xs:string`` — not constrained to the
+classic ``DataTypeType`` enumeration — so technically we could emit anything.
+In practice we stick to canonical GDAL names so the output round-trips through
+``osgeo.gdal``'s mdim API without surprises.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from ._errors import VrtWriterError
+
+
+# Mirrors ``_gdal_to_vrt_dtype`` in vrtstack/R. Kept aligned deliberately —
+# the two writers should produce the same <DataType> string for the same
+# logical dtype.
+_NUMPY_TO_VRT = {
+    "bool": "Byte",      # GDAL has no bool; promote.
+    "int8": "Int8",
+    "uint8": "Byte",
+    "int16": "Int16",
+    "uint16": "UInt16",
+    "int32": "Int32",
+    "uint32": "UInt32",
+    "int64": "Int64",
+    "uint64": "UInt64",
+    "float16": "Float16",
+    "float32": "Float32",
+    "float64": "Float64",
+    "complex64": "CFloat32",
+    "complex128": "CFloat64",
+}
+
+
+def numpy_to_vrt_dtype(dtype: np.dtype | str) -> str:
+    """Map a numpy dtype to a canonical GDAL VRT DataType name.
+
+    Raises :class:`VrtWriterError` for datetime / timedelta / string / object
+    dtypes. See :func:`xvrt.encode_datetime_coord` for the datetime escape
+    hatch.
+    """
+    dt = np.dtype(dtype)
+    name = dt.name
+
+    if name in _NUMPY_TO_VRT:
+        return _NUMPY_TO_VRT[name]
+
+    kind = dt.kind
+    if kind == "M":
+        raise VrtWriterError(
+            f"datetime64 dtype ({dt}) not supported in v0. Convert the coord "
+            "to numeric first, e.g. via xvrt.encode_datetime_coord(da, "
+            "unit='days', since='1970-01-01'), and attach CF units in attrs."
+        )
+    if kind == "m":
+        raise VrtWriterError(f"timedelta64 dtype ({dt}) not supported in v0.")
+    if kind in ("U", "S", "O"):
+        raise VrtWriterError(
+            f"string/object dtype ({dt}) not supported by the VRT mdim model "
+            "used here. Convert categorical strings to integer codes first."
+        )
+    raise VrtWriterError(f"unsupported dtype: {dt}")

xvrt/_errors.py

@@ -0,0 +1,11 @@
+"""Single exception hierarchy so the rules R1..R7 raise something catchable."""
+from __future__ import annotations
+
+
+class VrtWriterError(ValueError):
+    """Raised when the writer's rules are violated.
+
+    Subclasses ``ValueError`` so that naive except-clauses still catch it;
+    specific enough that callers can ``except VrtWriterError`` to distinguish
+    rule violations from generic bad input.
+    """

xvrt/_sources.py

@@ -0,0 +1,200 @@
+"""Source specification — normalise user input.
+
+Accepts:
+  - ``list[str | Path]`` — each source is a path/URL, writer infers the source
+    array name per composition mode
+  - ``list[dict]`` — each dict carries ``{"path": ..., "array": ..., ...}``
+
+Produces a uniform list of :class:`Source` records for the emitter.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path, PurePosixPath
+from typing import Any, Mapping, Sequence
+
+from ._errors import VrtWriterError
+
+
+@dataclass(frozen=True)
+class Source:
+    """One participating source.
+
+    Attributes
+    ----------
+    path
+        The string that goes into ``<SourceFilename>``. May be a local path,
+        a URL with ``/vsicurl/`` prefix applied, or a plain ``/vsi*`` VSI path.
+    array
+        The ``<SourceArray>`` name — the full-name of the array inside the
+        source (e.g. ``"/temp"``, or ``"temp"`` for root-group arrays).
+    relative_to_vrt
+        Emitted as ``relativeToVRT="1"`` when True.
+    size
+        For ``composition="concat"``: number of elements this source
+        contributes along the concat dim. ``None`` for stack (always 1).
+    original
+        The source string as the user originally passed it, before VSI or
+        relative-to-VRT rewriting. Used by size auto-discovery so the
+        fallback opener sees a resolvable path.
+    """
+
+    path: str
+    array: str
+    relative_to_vrt: bool = False
+    size: int | None = None
+    extra: Mapping[str, Any] = field(default_factory=dict)
+    original: str = ""
+
+
+_VSI_PREFIXES = ("/vsi",)
+
+
+def _is_url(s: str) -> bool:
+    return s.startswith("http://") or s.startswith("https://")
+
+
+def _to_vsi(s: str) -> str:
+    """Prefix http(s) URLs with /vsicurl/; pass /vsi* through unchanged."""
+    if s.startswith(_VSI_PREFIXES):
+        return s
+    if _is_url(s):
+        return f"/vsicurl/{s}"
+    if s.startswith("s3://"):
+        return f"/vsis3/{s[5:]}"
+    return s
+
+
+def normalise_sources(
+    sources: Sequence[Any],
+    *,
+    default_array: str,
+    vrt_path: Path | None = None,
+    composition: str,
+    n_vars: int = 1,
+) -> list[Source]:
+    """Resolve user-supplied sources into :class:`Source` records.
+
+    Parameters
+    ----------
+    sources
+        ``list[str | Path | dict]``.
+    default_array
+        Array name to use when a dict-form source omits ``"array"``. Typically
+        the data-variable name from ``ds``.
+    vrt_path
+        Path the VRT will be written to. Used to decide whether to mark
+        ``relativeToVRT="1"``. If ``None``, always emit absolute paths.
+    composition
+        ``"stack"`` | ``"concat"`` | ``"mosaic"``. Stack sources must not
+        carry a per-source ``size``.
+    n_vars
+        Number of data variables being written. With more than one, a
+        dict-form ``"array"`` is ambiguous and refused; use ``"arrays"``
+        (a ``{var: source_array_name}`` mapping) instead.
+    """
+    if not sources:
+        raise VrtWriterError("at least one source is required")
+
+    out: list[Source] = []
+    for i, raw in enumerate(sources):
+        out.append(_coerce_one(raw, i, default_array, vrt_path, composition, n_vars))
+    return out
+
+
+def _coerce_one(
+    raw: Any,
+    index: int,
+    default_array: str,
+    vrt_path: Path | None,
+    composition: str,
+    n_vars: int = 1,
+) -> Source:
+    if isinstance(raw, Source):
+        return raw
+
+    # R6: no open handles. Check before type dispatch — a Dataset is not a
+    # str/Path/dict and would otherwise hit the generic "expected ..." error.
+    if hasattr(raw, "variables") and hasattr(raw, "dims"):
+        raise VrtWriterError(
+            f"source #{index}: open xarray/netCDF4 handles are not accepted. "
+            "Pass the path string instead (R6)."
+        )
+
+    if isinstance(raw, (str, Path, PurePosixPath)):
+        path_str = str(raw)
+        arr = default_array
+        size = None
+        rel = False
+        extra: Mapping[str, Any] = {}
+    elif isinstance(raw, Mapping):
+        if "path" not in raw:
+            raise VrtWriterError(
+                f"source #{index}: dict form requires a 'path' key"
+            )
+        path_str = str(raw["path"])
+        if n_vars > 1 and "array" in raw:
+            raise VrtWriterError(
+                f"source #{index}: 'array' names one source array but "
+                f"{n_vars} variables are being written. Use "
+                "'arrays': {var: '/name', ...} for renames."
+            )
+        arrays = raw.get("arrays")
+        if arrays is not None and not isinstance(arrays, Mapping):
+            raise VrtWriterError(
+                f"source #{index}: 'arrays' must be a dict {{var: name}}"
+            )
+        arr = raw.get("array", default_array)
+        size = raw.get("size", None)
+        rel = bool(raw.get("relative_to_vrt", False))
+        extra = {k: v for k, v in raw.items()
+                 if k not in {"path", "array", "size", "relative_to_vrt"}}
+    else:
+        raise VrtWriterError(
+            f"source #{index}: expected str, Path, or dict — got {type(raw).__name__}"
+        )
+
+    # Classic raster sources (GeoTIFF/COG): <SourceBand> instead of
+    # <SourceArray>. Explicit with "band": N in dict form; implied band 1 for
+    # .tif/.tiff paths that name no array.
+    band = extra.get("band") if isinstance(extra, Mapping) else None
+    if band is None and not (isinstance(raw, Mapping) and
+                             ("array" in raw or "arrays" in raw)):
+        if path_str.lower().split("?")[0].endswith((".tif", ".tiff")):
+            band = 1
+    if band is not None:
+        extra = {**extra, "band": int(band)}
+        if composition == "concat":
+            raise VrtWriterError(
+                f"source #{index}: a raster band source is 2D and has no "
+                "concat dim to contribute; use composition='stack'."
+            )
+
+    if composition == "stack" and size is not None and size != 1:
+        raise VrtWriterError(
+            f"source #{index}: stack composition contributes one element per "
+            "source; do not pass size=. Use concat if each source has >1 "
+            "element along the dim."
+        )
+
+    # Apply /vsicurl/ prefixing and relativity.
+    path_emitted = _to_vsi(path_str)
+    if (vrt_path is not None and not _is_url(path_str)
+            and not path_str.startswith(("/vsi", "s3://"))):
+        try:
+            rel_path = Path(path_str).resolve().relative_to(vrt_path.parent.resolve())
+            # Only auto-relativise if the caller didn't explicitly set it.
+            if rel is False:
+                path_emitted = str(rel_path)
+                rel = True
+        except (ValueError, OSError):
+            pass
+
+    return Source(
+        path=path_emitted,
+        array=str(arr),
+        relative_to_vrt=rel,
+        size=size,
+        extra=extra,
+        original=path_str,
+    )

xvrt/_stac.py

@@ -0,0 +1,301 @@
+"""Build a multidim VRT straight from STAC items: no file is opened.
+
+The catalogue already says everything the VRT needs: the grid
+(``proj:shape``, ``proj:transform``), the CRS (``proj:epsg`` / ``proj:code``
+/ ``proj:wkt2``), each item's datetime, and per asset the band's storage
+(``raster:bands``: ``data_type``, ``nodata``, ``scale``, ``offset``,
+``unit``). From that we build a template :class:`xarray.Dataset` whose data
+variables are zero-memory broadcast placeholders of the full shape, plus one
+source list per asset, and hand both to :func:`xvrt.write_mdim_vrt`.
+
+This is the catalogue-driven counterpart of the R package vrtstack: "the grid
+comes from the catalogue, identical grid or refuse", one array per asset, and
+items that lack an asset leave nodata at their position.
+"""
+from __future__ import annotations
+
+import datetime as _dt
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Sequence
+
+import numpy as np
+import xarray as xr
+
+from ._errors import VrtWriterError
+
+
+def from_stac(
+    items: str | Path | Iterable[Mapping[str, Any]],
+    path: str | Path,
+    *,
+    assets: Sequence[str] | None = None,
+    dim: str = "time",
+    crs: str | None = None,
+    block_size: Sequence[int] | Mapping[str, Sequence[int]] | None = None,
+) -> Path:
+    """Write a multidim VRT stacking STAC items along ``dim``.
+
+    Parameters
+    ----------
+    items
+        A stac-geoparquet file (path or URL; needs ``pyarrow``), or an
+        iterable of STAC item dicts (``pystac.Item.to_dict()`` works). Both
+        the flat geoparquet layout and the nested ``"properties"`` layout are
+        read.
+    path
+        Output ``.vrt`` path.
+    assets
+        Asset keys to write, one array each, in this order. Default: every
+        asset with ``raster:bands``, in first-seen order.
+    dim
+        Name of the stack dimension (one position per distinct datetime).
+    crs
+        WKT override. Default: from the items' projection fields, turned into
+        WKT with ``pyproj`` (or GDAL's ``osr``) when only an EPSG code is
+        given, so the axis mapping can be computed.
+    block_size
+        Optional ``<BlockSize>``; the catalogue does not record it.
+
+    Raises
+    ------
+    VrtWriterError
+        Items on different grids, duplicate datetimes, a band description
+        that changes between items, or no usable CRS.
+    """
+    from ._writer import write_mdim_vrt
+
+    rows = [_flatten(it) for it in _read_items(items)]
+    if not rows:
+        raise VrtWriterError("no STAC items")
+
+    times = [_item_time(r) for r in rows]
+    order = np.argsort(np.array(times, dtype="datetime64[ns]"), kind="stable")
+    rows = [rows[i] for i in order]
+    times = np.array([times[i] for i in order], dtype="datetime64[ns]")
+    if len(np.unique(times)) != len(times):
+        dup = times[1:][times[1:] == times[:-1]]
+        raise VrtWriterError(
+            f"duplicate datetimes in items (first: {dup[0]}); one item per "
+            f"position along {dim!r} is required."
+        )
+
+    keys = list(assets) if assets is not None else _band_assets(rows)
+    if not keys:
+        raise VrtWriterError("no assets with raster:bands found in the items")
+
+    shape, transform = _common_grid(rows, keys)
+    ny, nx = shape
+    a, b, c, d, e, f = transform[:6]
+    if b != 0 or d != 0:
+        raise VrtWriterError(
+            f"rotated/sheared transform {transform[:6]} is not supported"
+        )
+    x = c + a * (np.arange(nx) + 0.5)
+    y = f + e * (np.arange(ny) + 0.5)
+
+    wkt = crs or _common_crs_wkt(rows, keys)
+
+    data_vars = {}
+    sources: dict[str, list[dict[str, Any]]] = {}
+    for k in keys:
+        band = _common_band(rows, k)
+        dtype = np.dtype(band.get("data_type") or "float32")
+        placeholder = np.broadcast_to(np.zeros((), dtype=dtype), (len(rows), ny, nx))
+        da = xr.DataArray(placeholder, dims=(dim, "y", "x"), name=k)
+        enc: dict[str, Any] = {"dtype": dtype}
+        if band.get("nodata") is not None:
+            enc["_FillValue"] = band["nodata"]
+        if band.get("scale") is not None:
+            enc["scale_factor"] = band["scale"]
+        if band.get("offset") is not None:
+            enc["add_offset"] = band["offset"]
+        da.encoding.update(enc)
+        if band.get("unit"):
+            da.attrs["units"] = band["unit"]
+        data_vars[k] = da
+        sources[k] = [
+            {"path": r["assets"][k]["href"], "band": 1, "index": i}
+            for i, r in enumerate(rows)
+            if (r.get("assets") or {}).get(k)
+        ]
+
+    ds = xr.Dataset(
+        data_vars,
+        coords={dim: (dim, times), "y": ("y", y), "x": ("x", x)},
+    )
+    return write_mdim_vrt(
+        ds, sources, path,
+        composition="stack", concat_dim=dim, crs=wkt, block_size=block_size,
+    )
+
+
+# -- reading -------------------------------------------------------------------
+
+def _read_items(items) -> list[Mapping[str, Any]]:
+    if isinstance(items, (str, Path)):
+        try:
+            import pyarrow.parquet as pq
+        except ImportError as exc:  # pragma: no cover
+            raise VrtWriterError(
+                "reading stac-geoparquet needs pyarrow (pip install pyarrow)"
+            ) from exc
+        src = str(items)
+        if src.startswith(("http://", "https://")):
+            import io
+            import urllib.request
+
+            from . import __version__
+
+            # Some hosts refuse urllib's default User-Agent (HTTP 403).
+            req = urllib.request.Request(src, headers={"User-Agent": f"xvrt/{__version__}"})
+            with urllib.request.urlopen(req) as resp:  # noqa: S310
+                return pq.read_table(io.BytesIO(resp.read())).to_pylist()
+        return pq.read_table(src).to_pylist()
+    return [it.to_dict() if hasattr(it, "to_dict") else it for it in items]
+
+
+def _flatten(item: Mapping[str, Any]) -> dict[str, Any]:
+    """Geoparquet rows are flat; STAC JSON nests fields under properties."""
+    out = dict(item.get("properties") or {})
+    out.update({k: v for k, v in item.items() if k != "properties"})
+    return out
+
+
+def _item_time(r: Mapping[str, Any]) -> np.datetime64:
+    t = r.get("datetime") or r.get("start_datetime")
+    if t is None:
+        raise VrtWriterError(f"item {r.get('id')!r} has no datetime")
+    if isinstance(t, _dt.datetime):
+        if t.tzinfo is not None:
+            t = t.astimezone(_dt.timezone.utc).replace(tzinfo=None)
+        return np.datetime64(t, "ns")
+    s = str(t).replace("Z", "")
+    if s.endswith("+00:00"):
+        s = s[:-6]
+    return np.datetime64(s, "ns")
+
+
+def _band_assets(rows) -> list[str]:
+    seen: dict[str, None] = {}
+    for r in rows:
+        for k, a in (r.get("assets") or {}).items():
+            if a and a.get("raster:bands"):
+                seen.setdefault(k, None)
+    return list(seen)
+
+
+def _field(r, asset, name):
+    """A projection field from the asset, falling back to the item."""
+    a = (r.get("assets") or {}).get(asset) or {}
+    v = a.get(name)
+    return v if v is not None else r.get(name)
+
+
+def _common_grid(rows, keys):
+    grids = set()
+    for r in rows:
+        for k in keys:
+            if not (r.get("assets") or {}).get(k):
+                continue
+            shape = _field(r, k, "proj:shape")
+            tr = _field(r, k, "proj:transform")
+            if shape is None or tr is None:
+                raise VrtWriterError(
+                    f"item {r.get('id')!r} asset {k!r} lacks proj:shape / "
+                    "proj:transform; the VRT cannot be built from the "
+                    "catalogue alone."
+                )
+            grids.add((tuple(int(v) for v in shape),
+                       tuple(round(float(v), 12) for v in tr[:6])))
+    if len(grids) != 1:
+        raise VrtWriterError(
+            f"items are on {len(grids)} different grids (identical grid or "
+            f"refuse): {sorted(grids)[:3]}"
+        )
+    shape, tr = grids.pop()
+    return shape, tr
+
+
+_STORAGE = ("data_type", "nodata", "scale", "offset")
+
+
+def _common_band(rows, k) -> dict[str, Any]:
+    """One storage description per asset.
+
+    Storage fields (dtype, nodata, scale, offset) must agree across items:
+    they decide how bytes decode. The unit is advisory: items that omit it
+    take the unit other items give, and conflicting non-empty units warn and
+    use the most common.
+    """
+    storage = set()
+    units: dict[str, int] = {}
+    first = None
+    for r in rows:
+        a = (r.get("assets") or {}).get(k)
+        if not a:
+            continue
+        b = (a.get("raster:bands") or [{}])[0]
+        st = tuple(b.get(f) for f in _STORAGE)
+        storage.add(st)
+        if b.get("unit"):
+            units[b["unit"]] = units.get(b["unit"], 0) + 1
+        first = first or dict(zip(_STORAGE, st))
+    if len(storage) > 1:
+        raise VrtWriterError(
+            f"asset {k!r}: raster:bands storage ({', '.join(_STORAGE)}) differs "
+            f"between items: {sorted(storage, key=str)[:3]}; one array needs one "
+            "storage description."
+        )
+    out = dict(first or {})
+    if units:
+        unit = max(units, key=units.get)
+        if len(units) > 1:
+            import warnings
+            warnings.warn(
+                f"asset {k!r}: items give different units {sorted(units)}; "
+                f"using {unit!r}",
+                UserWarning, stacklevel=3,
+            )
+        out["unit"] = unit
+    return out
+
+
+def _common_crs_wkt(rows, keys) -> str:
+    found = set()
+    for r in rows[:: max(1, len(rows) // 50)] + rows[-1:]:
+        for k in keys:
+            if not (r.get("assets") or {}).get(k):
+                continue
+            for name in ("proj:wkt2", "proj:code", "proj:epsg"):
+                v = _field(r, k, name)
+                if v is not None:
+                    found.add((name, str(v)))
+                    break
+    if not found:
+        raise VrtWriterError("items carry no proj:epsg / proj:code / proj:wkt2; pass crs=")
+    if len({v for _, v in found}) > 1:
+        raise VrtWriterError(f"items declare different CRSs: {sorted(found)}")
+    name, v = found.pop()
+    if name == "proj:wkt2":
+        return v
+    code = v if ":" in v else f"EPSG:{v}"
+    return _code_to_wkt(code)
+
+
+def _code_to_wkt(code: str) -> str:
+    try:
+        import pyproj
+        return pyproj.CRS.from_user_input(code).to_wkt()
+    except ImportError:
+        pass
+    try:
+        from osgeo import osr
+        srs = osr.SpatialReference()
+        srs.SetFromUserInput(code)
+        return srs.ExportToWkt(["FORMAT=WKT2_2019"])
+    except ImportError:
+        pass
+    raise VrtWriterError(
+        f"{code} needs pyproj (or GDAL) to become WKT, which the axis mapping "
+        "depends on; install pyproj or pass crs=<WKT>."
+    )