tilefetch 0.1.0__py3-none-any.whl

tilefetch/download.py

@@ -0,0 +1,334 @@
+"""Polite, resumable tile downloading.
+
+* a small thread pool (2 threads by default) with a shared request-rate limit;
+* retries with exponential backoff and jitter on timeouts, connection errors,
+  HTTP 408/425/429/5xx, honouring ``Retry-After``;
+* an optional on-disk cache with ``ETag`` / ``Last-Modified`` revalidation
+  (``If-None-Match`` / ``If-Modified-Since``);
+* an honest ``User-Agent`` (``tilefetch/<version>``) - browser strings are refused.
+"""
+
+from __future__ import annotations
+
+import email.utils
+import json
+import os
+import random
+import socket
+import threading
+import time
+import urllib.error
+import urllib.request
+from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait
+from dataclasses import dataclass, field
+from typing import Callable, Iterable, Mapping
+
+from ._version import __version__
+from .sources import PolicyError, TileSource
+from .tiles import Tile
+
+__all__ = [
+    "DEFAULT_USER_AGENT",
+    "RateLimiter",
+    "TileCache",
+    "TileResult",
+    "FetchStats",
+    "Downloader",
+    "check_user_agent",
+]
+
+DEFAULT_USER_AGENT = f"tilefetch/{__version__} (+https://github.com/YusufEminoglu/tilefetch_sdk)"
+_RETRY_STATUS = {408, 425, 429, 500, 502, 503, 504}
+_MISSING_STATUS = {204, 404, 410}
+_BROWSER_MARKERS = ("mozilla/", "applewebkit", "chrome/", "safari/", "firefox/", "edg/", "trident/")
+ProgressFn = Callable[[int, int], None]
+
+
+def check_user_agent(user_agent: str) -> str:
+    """Reject empty or browser-imitating User-Agent strings.
+
+    Tile operators identify and contact heavy users through the User-Agent;
+    pretending to be a browser defeats that and breaks most tile policies.
+    """
+    ua = user_agent.strip()
+    if not ua:
+        raise PolicyError("User-Agent must not be empty; identify your application")
+    low = ua.lower()
+    if any(m in low for m in _BROWSER_MARKERS):
+        raise PolicyError(
+            "tilefetch does not send browser User-Agent strings. Identify your application "
+            "instead, e.g. 'myproject/1.0 (contact@example.org)'."
+        )
+    return ua
+
+
+class RateLimiter:
+    """Spaces requests at least ``1 / rate`` seconds apart across all threads."""
+
+    def __init__(self, rate: float | None) -> None:
+        self.interval = 1.0 / rate if rate and rate > 0 else 0.0
+        self._lock = threading.Lock()
+        self._next = 0.0
+
+    def wait(self) -> None:
+        if not self.interval:
+            return
+        with self._lock:
+            now = time.monotonic()
+            slot = max(now, self._next)
+            self._next = slot + self.interval
+        delay = slot - now
+        if delay > 0:
+            time.sleep(delay)
+
+
+class TileCache:
+    """On-disk HTTP cache: ``<root>/<source key>/<z>/<x>/<y>.tile`` plus a JSON sidecar."""
+
+    def __init__(self, root: str | os.PathLike[str], source: TileSource) -> None:
+        self.root = os.path.join(os.fspath(root), source.cache_key)
+
+    def _paths(self, tile: Tile) -> tuple[str, str]:
+        z, x, y = tile
+        base = os.path.join(self.root, str(z), str(x), str(y))
+        return base + ".tile", base + ".json"
+
+    def get(self, tile: Tile) -> tuple[bytes, dict[str, str]] | None:
+        data_path, meta_path = self._paths(tile)
+        try:
+            with open(data_path, "rb") as fh:
+                data = fh.read()
+            meta: dict[str, str] = {}
+            if os.path.exists(meta_path):
+                with open(meta_path, encoding="utf-8") as fh:
+                    meta = json.load(fh)
+            return data, meta
+        except OSError:
+            return None
+
+    def put(self, tile: Tile, data: bytes, meta: Mapping[str, str]) -> None:
+        data_path, meta_path = self._paths(tile)
+        os.makedirs(os.path.dirname(data_path), exist_ok=True)
+        tmp = f"{data_path}.{threading.get_ident()}.tmp"
+        with open(tmp, "wb") as fh:
+            fh.write(data)
+        os.replace(tmp, data_path)
+        with open(meta_path, "w", encoding="utf-8") as fh:
+            json.dump(dict(meta), fh)
+
+
+@dataclass
+class TileResult:
+    tile: Tile
+    status: str  # downloaded | cached | not_modified | missing | failed
+    data: bytes | None = None
+    error: str | None = None
+    attempts: int = 0
+
+
+@dataclass
+class FetchStats:
+    total: int = 0
+    downloaded: int = 0
+    cached: int = 0
+    skipped: int = 0
+    missing: int = 0
+    failed: int = 0
+    bytes: int = 0
+    errors: list[tuple[Tile, str]] = field(default_factory=list)
+
+    def add(self, r: TileResult) -> None:
+        if r.status in ("cached", "not_modified"):
+            self.cached += 1
+        elif r.status == "downloaded":
+            self.downloaded += 1
+        elif r.status == "missing":
+            self.missing += 1
+        else:
+            self.failed += 1
+            if len(self.errors) < 100:
+                self.errors.append((r.tile, r.error or "unknown error"))
+        if r.data is not None and r.status == "downloaded":
+            self.bytes += len(r.data)
+
+
+def _retry_after(value: str | None) -> float | None:
+    if not value:
+        return None
+    try:
+        return max(0.0, float(value))
+    except ValueError:
+        pass
+    try:
+        when = email.utils.parsedate_to_datetime(value)
+    except (TypeError, ValueError):
+        return None
+    return max(0.0, when.timestamp() - time.time())
+
+
+class Downloader:
+    """Download tiles of one :class:`TileSource`.
+
+    Parameters
+    ----------
+    threads:
+        Worker threads (default 2). Capped at ``source.max_threads`` for
+        built-in providers.
+    rate:
+        Maximum requests per second across all threads (default: the
+        source's ``max_rate``).
+    retries:
+        Extra attempts after the first for retryable failures.
+    backoff:
+        Base delay in seconds; attempt ``n`` waits ``backoff * 2**n`` plus jitter.
+    cache_dir:
+        Folder for the on-disk HTTP cache, or ``None`` to disable it.
+    revalidate:
+        With a cache, send conditional requests (``If-None-Match`` /
+        ``If-Modified-Since``) instead of trusting cached tiles blindly.
+    """
+
+    def __init__(
+        self,
+        source: TileSource,
+        *,
+        threads: int = 2,
+        rate: float | None = None,
+        retries: int = 4,
+        backoff: float = 0.5,
+        timeout: float = 30.0,
+        user_agent: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        cache_dir: str | os.PathLike[str] | None = None,
+        revalidate: bool = False,
+        max_backoff: float = 60.0,
+    ) -> None:
+        if threads < 1:
+            raise ValueError("threads must be at least 1")
+        self.source = source
+        self.threads = min(threads, source.max_threads) if source.builtin else threads
+        if rate is None:
+            rate = source.max_rate
+        elif source.builtin and source.max_rate:
+            rate = min(rate, source.max_rate)
+        self.limiter = RateLimiter(rate)
+        self.retries = max(0, retries)
+        self.backoff = backoff
+        self.max_backoff = max_backoff
+        self.timeout = timeout
+        hdrs = {"User-Agent": DEFAULT_USER_AGENT, "Accept": "image/*,*/*;q=0.8"}
+        hdrs.update(source.headers)
+        hdrs.update(headers or {})
+        for k in list(hdrs):
+            if k.lower() == "user-agent" and k != "User-Agent":
+                hdrs["User-Agent"] = hdrs.pop(k)
+        if user_agent is not None:
+            hdrs["User-Agent"] = user_agent
+        check_user_agent(hdrs["User-Agent"])
+        self.headers = hdrs
+        self.cache = TileCache(cache_dir, source) if cache_dir else None
+        self.revalidate = revalidate
+        self.requests = 0
+        self._count_lock = threading.Lock()
+
+    # -- single tile ------------------------------------------------------
+
+    def _request(self, url: str, extra: Mapping[str, str]) -> tuple[int, bytes, dict[str, str]]:
+        headers = dict(self.headers)
+        headers.update(extra)
+        req = urllib.request.Request(url, headers=headers)
+        self.limiter.wait()
+        with self._count_lock:
+            self.requests += 1
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:  # noqa: S310
+                body = resp.read()
+                return resp.status, body, {k.lower(): v for k, v in resp.headers.items()}
+        except urllib.error.HTTPError as err:
+            hdrs = {k.lower(): v for k, v in (err.headers or {}).items()}
+            try:
+                body = err.read()
+            except Exception:  # pragma: no cover - depends on the server
+                body = b""
+            return err.code, body, hdrs
+
+    def fetch_tile(self, tile: Tile) -> TileResult:
+        """Fetch one tile (from cache, revalidated, or over HTTP)."""
+        tile = Tile(*tile)
+        cached = self.cache.get(tile) if self.cache else None
+        if cached is not None and not self.revalidate:
+            return TileResult(tile, "cached", cached[0])
+        try:
+            url = self.source.tile_url(tile)
+        except ValueError as exc:
+            return TileResult(tile, "failed", error=str(exc))
+        extra: dict[str, str] = {}
+        if cached is not None:
+            if cached[1].get("etag"):
+                extra["If-None-Match"] = cached[1]["etag"]
+            if cached[1].get("last-modified"):
+                extra["If-Modified-Since"] = cached[1]["last-modified"]
+        attempt = 0
+        last_error = ""
+        while True:
+            retry_after: float | None = None
+            try:
+                status, body, hdrs = self._request(url, extra)
+            except (
+                urllib.error.URLError,
+                socket.timeout,
+                TimeoutError,
+                ConnectionError,
+                OSError,
+            ) as exc:
+                status, body, hdrs = -1, b"", {}
+                last_error = f"{type(exc).__name__}: {getattr(exc, 'reason', exc)}"
+            if status == 304 and cached is not None:
+                return TileResult(tile, "not_modified", cached[0], attempts=attempt + 1)
+            if status == 200:
+                ctype = hdrs.get("content-type", "").lower()
+                if ("html" in ctype or "xml" in ctype) and body.lstrip()[:1] == b"<":
+                    snippet = body[:120].decode("utf-8", "replace").strip()
+                    return TileResult(
+                        tile,
+                        "failed",
+                        error=f"server returned {ctype} instead of a tile: {snippet}",
+                    )
+                if self.cache is not None:
+                    meta: dict[str, str] = {
+                        k: hdrs[k] for k in ("etag", "last-modified", "content-type") if k in hdrs
+                    }
+                    self.cache.put(tile, body, meta)
+                return TileResult(tile, "downloaded", body, attempts=attempt + 1)
+            if status in _MISSING_STATUS:
+                return TileResult(tile, "missing", attempts=attempt + 1)
+            if status != -1:
+                last_error = f"HTTP {status}"
+                if status not in _RETRY_STATUS:
+                    return TileResult(tile, "failed", error=last_error, attempts=attempt + 1)
+                retry_after = _retry_after(hdrs.get("retry-after"))
+            if attempt >= self.retries:
+                return TileResult(tile, "failed", error=last_error, attempts=attempt + 1)
+            delay = self.backoff * (2**attempt) + random.uniform(0, self.backoff)
+            if retry_after is not None:
+                delay = max(delay, retry_after)
+            time.sleep(min(delay, self.max_backoff))
+            attempt += 1
+
+    # -- many tiles -------------------------------------------------------
+
+    def iter_fetch(self, tiles: Iterable[Tile]) -> Iterable[TileResult]:
+        """Yield results as they complete, keeping a bounded number in flight."""
+        window = self.threads * 4
+        with ThreadPoolExecutor(max_workers=self.threads, thread_name_prefix="tilefetch") as pool:
+            pending: set[Future[TileResult]] = set()
+            for t in tiles:
+                pending.add(pool.submit(self.fetch_tile, t))
+                if len(pending) >= window:
+                    done, pending = wait(pending, return_when=FIRST_COMPLETED)
+                    for f in done:
+                        yield f.result()
+            while pending:
+                done, pending = wait(pending, return_when=FIRST_COMPLETED)
+                for f in done:
+                    yield f.result()

tilefetch/georef.py

@@ -0,0 +1,291 @@
+"""Write georeferenced images: PNG/JPEG/WebP + world file + .prj, and GeoTIFF.
+
+The GeoTIFF writer needs only Pillow: it stores ModelPixelScaleTag,
+ModelTiepointTag and a GeoKeyDirectoryTag (GeoTIFF 1.0 keys) describing
+EPSG:3857 or EPSG:4326, which GDAL/rasterio/QGIS read as a proper CRS. With
+``engine="rasterio"`` the file is written through GDAL instead.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, NamedTuple
+
+from PIL import Image, TiffImagePlugin, TiffTags
+
+from ._version import __version__
+
+__all__ = [
+    "GeoTransform",
+    "WKT_3857",
+    "WKT_4326",
+    "world_file_lines",
+    "world_file_path",
+    "write_world_file",
+    "write_prj",
+    "write_geotiff",
+    "save_georeferenced",
+    "geokeys",
+]
+
+WKT_3857 = (
+    'PROJCS["WGS_1984_Web_Mercator_Auxiliary_Sphere",GEOGCS["GCS_WGS_1984",'
+    'DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],'
+    'PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],'
+    'PROJECTION["Mercator_Auxiliary_Sphere"],PARAMETER["False_Easting",0.0],'
+    'PARAMETER["False_Northing",0.0],PARAMETER["Central_Meridian",0.0],'
+    'PARAMETER["Standard_Parallel_1",0.0],PARAMETER["Auxiliary_Sphere_Type",0.0],'
+    'UNIT["Meter",1.0]]'
+)
+WKT_4326 = (
+    'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],'
+    'PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]]'
+)
+
+# GeoTIFF tag numbers
+_MODEL_PIXEL_SCALE = 33550
+_MODEL_TIEPOINT = 33922
+_GEO_KEY_DIRECTORY = 34735
+_GEO_ASCII_PARAMS = 34737
+_COPYRIGHT = 33432
+
+
+class GeoTransform(NamedTuple):
+    """North-up raster georeferencing: top-left corner and pixel size."""
+
+    minx: float
+    maxy: float
+    pixel_width: float
+    pixel_height: float  # positive; rows go downwards
+
+    @classmethod
+    def from_bounds(
+        cls, bounds: tuple[float, float, float, float], width: int, height: int
+    ) -> GeoTransform:
+        minx, miny, maxx, maxy = bounds
+        return cls(minx, maxy, (maxx - minx) / width, (maxy - miny) / height)
+
+    def bounds(self, width: int, height: int) -> tuple[float, float, float, float]:
+        return (
+            self.minx,
+            self.maxy - self.pixel_height * height,
+            self.minx + self.pixel_width * width,
+            self.maxy,
+        )
+
+    def to_gdal(self) -> tuple[float, float, float, float, float, float]:
+        """GDAL-style geotransform ``(c, a, b, f, d, e)``."""
+        return (self.minx, self.pixel_width, 0.0, self.maxy, 0.0, -self.pixel_height)
+
+
+def _epsg(crs: str | int) -> int:
+    s = str(crs).upper().replace("EPSG:", "")
+    if s in ("3857", "900913"):
+        return 3857
+    if s == "4326":
+        return 4326
+    raise ValueError(f"unsupported CRS {crs!r}; use EPSG:3857 or EPSG:4326")
+
+
+def world_file_lines(gt: GeoTransform) -> list[str]:
+    """The six world-file lines; C/F refer to the centre of the top-left pixel."""
+    return [
+        repr(gt.pixel_width),
+        "0.0",
+        "0.0",
+        repr(-gt.pixel_height),
+        repr(gt.minx + gt.pixel_width / 2.0),
+        repr(gt.maxy - gt.pixel_height / 2.0),
+    ]
+
+
+def world_file_path(image_path: str | os.PathLike[str]) -> str:
+    """``x.png`` -> ``x.pgw``, ``x.jpg`` -> ``x.jgw``, ``x.tif`` -> ``x.tfw``, else ``.wld``."""
+    root, ext = os.path.splitext(os.fspath(image_path))
+    ext = ext.lower().lstrip(".")
+    special = {"png": "pgw", "jpg": "jgw", "jpeg": "jgw", "tif": "tfw", "tiff": "tfw"}
+    return f"{root}.{special.get(ext, 'wld')}"
+
+
+def write_world_file(image_path: str | os.PathLike[str], gt: GeoTransform) -> str:
+    path = world_file_path(image_path)
+    with open(path, "w", encoding="ascii", newline="\n") as fh:
+        fh.write("\n".join(world_file_lines(gt)) + "\n")
+    return path
+
+
+def write_prj(image_path: str | os.PathLike[str], crs: str | int = "EPSG:3857") -> str:
+    path = os.path.splitext(os.fspath(image_path))[0] + ".prj"
+    with open(path, "w", encoding="ascii", newline="\n") as fh:
+        fh.write(WKT_3857 if _epsg(crs) == 3857 else WKT_4326)
+    return path
+
+
+def geokeys(crs: str | int) -> tuple[int, ...]:
+    """GeoKeyDirectoryTag values (KeyDirectoryVersion 1, revision 1.0)."""
+    epsg = _epsg(crs)
+    if epsg == 3857:
+        keys = [
+            (1024, 0, 1, 1),  # GTModelTypeGeoKey = ModelTypeProjected
+            (1025, 0, 1, 1),  # GTRasterTypeGeoKey = RasterPixelIsArea
+            (3072, 0, 1, 3857),  # ProjectedCSTypeGeoKey
+            (3076, 0, 1, 9001),  # ProjLinearUnitsGeoKey = metre
+        ]
+    else:
+        keys = [
+            (1024, 0, 1, 2),  # ModelTypeGeographic
+            (1025, 0, 1, 1),
+            (2048, 0, 1, 4326),  # GeographicTypeGeoKey
+            (2054, 0, 1, 9102),  # GeogAngularUnitsGeoKey = degree
+        ]
+    out = [1, 1, 0, len(keys)]
+    for k in keys:
+        out.extend(k)
+    return tuple(out)
+
+
+def _prepare(image: Image.Image, fmt: str) -> Image.Image:
+    if image.mode not in ("RGB", "RGBA", "L", "LA"):
+        image = image.convert("RGBA")
+    if image.mode in ("RGBA", "LA"):
+        alpha = image.getchannel("A")
+        if alpha.getextrema()[0] == 255:  # fully opaque: drop the alpha band
+            image = image.convert("RGB" if image.mode == "RGBA" else "L")
+        elif fmt == "jpeg":
+            bg = Image.new("RGB", image.size, (255, 255, 255))
+            bg.paste(image.convert("RGBA"), mask=alpha)
+            image = bg
+    return image
+
+
+def write_geotiff(
+    path: str | os.PathLike[str],
+    image: Image.Image,
+    gt: GeoTransform,
+    crs: str | int = "EPSG:3857",
+    *,
+    attribution: str = "",
+    engine: str = "pillow",
+    compression: str | None = "deflate",
+) -> str:
+    """Write ``image`` as a GeoTIFF.
+
+    ``engine="pillow"`` (default) needs nothing beyond Pillow;
+    ``engine="rasterio"`` writes through GDAL. ``compression`` is
+    ``"deflate"``, ``"lzw"`` or ``None``.
+    """
+    path = os.fspath(path)
+    image = _prepare(image, "tiff")
+    epsg = _epsg(crs)
+    if engine == "rasterio":
+        return _write_geotiff_rasterio(path, image, gt, epsg, attribution, compression)
+    if engine != "pillow":
+        raise ValueError("engine must be 'pillow' or 'rasterio'")
+    ifd = TiffImagePlugin.ImageFileDirectory_v2()
+    ifd[_MODEL_PIXEL_SCALE] = (float(gt.pixel_width), float(gt.pixel_height), 0.0)
+    ifd.tagtype[_MODEL_PIXEL_SCALE] = TiffTags.DOUBLE
+    ifd[_MODEL_TIEPOINT] = (0.0, 0.0, 0.0, float(gt.minx), float(gt.maxy), 0.0)
+    ifd.tagtype[_MODEL_TIEPOINT] = TiffTags.DOUBLE
+    ifd[_GEO_KEY_DIRECTORY] = geokeys(epsg)
+    ifd.tagtype[_GEO_KEY_DIRECTORY] = TiffTags.SHORT
+    ifd[305] = f"tilefetch {__version__}"  # Software
+    if attribution:
+        ifd[270] = attribution  # ImageDescription
+        ifd[_COPYRIGHT] = attribution
+        ifd.tagtype[_COPYRIGHT] = TiffTags.ASCII
+    comp = {"deflate": "tiff_deflate", "lzw": "tiff_lzw", None: None}[compression]
+    tmp = path + ".tmp.tif"
+    image.save(tmp, format="TIFF", tiffinfo=ifd, compression=comp)
+    os.replace(tmp, path)
+    return path
+
+
+def _write_geotiff_rasterio(
+    path: str,
+    image: Image.Image,
+    gt: GeoTransform,
+    epsg: int,
+    attribution: str,
+    compression: str | None,
+) -> str:
+    try:
+        import numpy as np
+        import rasterio
+        from rasterio.enums import ColorInterp
+        from rasterio.transform import Affine
+    except ImportError as exc:  # pragma: no cover - depends on the environment
+        raise ImportError("engine='rasterio' needs: pip install 'tilefetch[rasterio]'") from exc
+    arr = np.asarray(image)
+    if arr.ndim == 2:
+        arr = arr[np.newaxis, :, :]
+    else:
+        arr = np.transpose(arr, (2, 0, 1))
+    profile: dict[str, Any] = {
+        "driver": "GTiff",
+        "width": image.width,
+        "height": image.height,
+        "count": arr.shape[0],
+        "dtype": "uint8",
+        "crs": f"EPSG:{epsg}",
+        "transform": Affine(gt.pixel_width, 0.0, gt.minx, 0.0, -gt.pixel_height, gt.maxy),
+        "tiled": True,
+        "blockxsize": 256,
+        "blockysize": 256,
+    }
+    if compression:
+        profile["compress"] = compression
+    if arr.shape[0] >= 3:
+        profile["photometric"] = "RGB"
+    with rasterio.open(path, "w", **profile) as ds:
+        ds.write(arr)
+        if arr.shape[0] == 4:
+            ds.colorinterp = [
+                ColorInterp.red,
+                ColorInterp.green,
+                ColorInterp.blue,
+                ColorInterp.alpha,
+            ]
+        tags = {"TIFFTAG_SOFTWARE": f"tilefetch {__version__}"}
+        if attribution:
+            tags["TIFFTAG_COPYRIGHT"] = attribution
+            tags["TIFFTAG_IMAGEDESCRIPTION"] = attribution
+        ds.update_tags(**tags)
+    return path
+
+
+def save_georeferenced(
+    path: str | os.PathLike[str],
+    image: Image.Image,
+    gt: GeoTransform,
+    crs: str | int = "EPSG:3857",
+    *,
+    attribution: str = "",
+    engine: str = "pillow",
+) -> list[str]:
+    """Save an image with georeferencing chosen by extension.
+
+    ``.tif``/``.tiff`` -> GeoTIFF; ``.png``/``.jpg``/``.webp`` -> image plus
+    world file and ``.prj``. Returns the paths written.
+    """
+    p = os.fspath(path)
+    ext = os.path.splitext(p)[1].lower()
+    if ext in (".tif", ".tiff"):
+        return [write_geotiff(p, image, gt, crs, attribution=attribution, engine=engine)]
+    fmt = {".png": "png", ".jpg": "jpeg", ".jpeg": "jpeg", ".webp": "webp"}.get(ext)
+    if fmt is None:
+        raise ValueError(f"unsupported image extension {ext!r}")
+    img = _prepare(image, fmt)
+    kwargs: dict[str, Any] = {}
+    if fmt == "png":
+        from PIL import PngImagePlugin
+
+        info = PngImagePlugin.PngInfo()
+        info.add_text("Software", f"tilefetch {__version__}")
+        if attribution:
+            info.add_text("Copyright", attribution)
+        kwargs["pnginfo"] = info
+        kwargs["optimize"] = True
+    elif fmt == "jpeg":
+        kwargs["quality"] = 92
+    img.save(p, format=fmt.upper(), **kwargs)
+    return [p, write_world_file(p, gt), write_prj(p, crs)]