tilepack 0.1.0__py3-none-any.whl

tilepack/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as: python -m tilepack"""
+
+from tilepack.cli import cli
+
+cli()

tilepack/cli.py

@@ -0,0 +1,58 @@
+"""CLI entrypoint for tilepack."""
+
+from importlib.metadata import version
+
+import click
+
+
+@click.group()
+@click.version_option(version("tilepack"), prog_name="tilepack")
+def cli():
+    """Convert TMS/XYZ tile folders to MBTiles/PMTiles and serve as TMS/WMTS endpoints."""
+
+
+@cli.command()
+@click.argument("input_root", type=click.Path(exists=True, file_okay=False))
+def verify(input_root):
+    """Scan a TMS folder and report tile statistics."""
+    from tilepack.verify import run_verify
+
+    run_verify(input_root)
+
+
+@cli.command()
+@click.argument("input_root", type=click.Path(exists=True, file_okay=False))
+@click.argument("output_file", type=click.Path())
+@click.option(
+    "--scheme",
+    type=click.Choice(["tms", "xyz"]),
+    default=None,
+    help="Input tile scheme (auto-detected if omitted).",
+)
+def convert(input_root, output_file, scheme):
+    """Convert a tile folder to MBTiles or PMTiles (inferred from extension)."""
+    from tilepack.convert import run_convert
+
+    run_convert(input_root, output_file, scheme=scheme)
+
+
+@cli.command()
+@click.argument("archive_file", type=click.Path(exists=True, dir_okay=False))
+@click.option("--port", default=8000, help="Port to bind to.")
+@click.option("--host", default="127.0.0.1", help="Host to bind to.")
+def serve(archive_file, port, host):
+    """Serve an MBTiles or PMTiles archive as a TMS endpoint."""
+    from tilepack.serve import run_serve
+
+    run_serve(archive_file, host, port)
+
+
+@cli.command()
+@click.argument("input_root", type=click.Path(exists=True, file_okay=False))
+@click.option("--base-url", required=True, help="Base URL of the running TMS server.")
+@click.option("--samples", default=200, help="Number of tiles to sample.")
+def selftest(input_root, base_url, samples):
+    """Validate a served TMS endpoint against the original tile folder."""
+    from tilepack.selftest import run_selftest
+
+    run_selftest(input_root, base_url, samples)

tilepack/convert.py

@@ -0,0 +1,188 @@
+"""Convert command: tile folder → MBTiles or PMTiles."""
+
+from __future__ import annotations
+
+import sqlite3
+import time
+from pathlib import Path
+
+import click
+
+from tilepack.tms_utils import collect_zoom_stats, compute_bounds, detect_scheme, iter_tiles
+
+
+def run_convert(input_root: str, output_file: str, scheme: str | None = None) -> None:
+    root = Path(input_root).resolve()
+    out = Path(output_file).resolve()
+    ext = out.suffix.lower()
+
+    # Scan tiles
+    stats = collect_zoom_stats(root)
+    if not stats:
+        click.echo("No tiles found.", err=True)
+        raise SystemExit(1)
+
+    # Detect or use provided scheme
+    if scheme is None:
+        has_xml = (root / "tilemapresource.xml").exists()
+        detected, _, _ = detect_scheme(stats, has_tilemapresource=has_xml)
+        scheme = detected
+        click.echo(f"Detected input scheme: {scheme.upper()}")
+    else:
+        click.echo(f"Using specified scheme: {scheme.upper()}")
+
+    if ext == ".mbtiles":
+        _convert_mbtiles(root, out, stats=stats, scheme=scheme)
+    elif ext == ".pmtiles":
+        _convert_pmtiles(root, out, stats=stats, scheme=scheme)
+    else:
+        click.echo(f"Unknown output format: {ext} (expected .mbtiles or .pmtiles)", err=True)
+        raise SystemExit(1)
+
+
+def _convert_mbtiles(root: Path, out: Path, *, stats: dict, scheme: str) -> None:
+    click.echo("Converting tile folder → MBTiles")
+    click.echo(f"  Input:  {root}")
+    click.echo(f"  Output: {out}\n")
+
+    t0 = time.perf_counter()
+
+    minzoom = min(stats)
+    maxzoom = max(stats)
+    bounds = compute_bounds(stats, scheme=scheme)
+    flip_y = scheme == "xyz"
+
+    # Create MBTiles database
+    if out.exists():
+        out.unlink()
+
+    conn = sqlite3.connect(str(out))
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("CREATE TABLE metadata (name TEXT, value TEXT)")
+    conn.execute(
+        "CREATE TABLE tiles ("
+        "  zoom_level INTEGER,"
+        "  tile_column INTEGER,"
+        "  tile_row INTEGER,"
+        "  tile_data BLOB"
+        ")"
+    )
+    conn.execute("CREATE UNIQUE INDEX tile_index ON tiles (zoom_level, tile_column, tile_row)")
+
+    # Populate metadata
+    bounds_str = f"{bounds[0]:.6f},{bounds[1]:.6f},{bounds[2]:.6f},{bounds[3]:.6f}"
+    center_lon = (bounds[0] + bounds[2]) / 2
+    center_lat = (bounds[1] + bounds[3]) / 2
+    center_zoom = (minzoom + maxzoom) // 2
+
+    meta = {
+        "name": root.name,
+        "format": "png",
+        "bounds": bounds_str,
+        "center": f"{center_lon:.6f},{center_lat:.6f},{center_zoom}",
+        "minzoom": str(minzoom),
+        "maxzoom": str(maxzoom),
+        "type": "overlay",
+        "version": "1",
+        "description": f"Converted from TMS folder: {root.name}",
+    }
+    conn.executemany("INSERT INTO metadata VALUES (?, ?)", meta.items())
+
+    # Insert tiles in batches
+    batch_size = 1000
+    batch = []
+    inserted = 0
+
+    for z, x, y, tile_path in iter_tiles(root):
+        tile_data = tile_path.read_bytes()
+        # MBTiles uses TMS scheme — flip Y if input is XYZ
+        y_tms = (2**z - 1) - y if flip_y else y
+        batch.append((z, x, y_tms, tile_data))
+
+        if len(batch) >= batch_size:
+            conn.executemany("INSERT INTO tiles VALUES (?, ?, ?, ?)", batch)
+            conn.commit()
+            inserted += len(batch)
+            batch.clear()
+
+    if batch:
+        conn.executemany("INSERT INTO tiles VALUES (?, ?, ?, ?)", batch)
+        conn.commit()
+        inserted += len(batch)
+
+    conn.close()
+    elapsed = time.perf_counter() - t0
+    size_mb = out.stat().st_size / (1024 * 1024)
+
+    click.echo("Done.")
+    click.echo(f"  Tiles inserted: {inserted:,}")
+    click.echo(f"  File size:      {size_mb:.1f} MB")
+    click.echo(f"  Duration:       {elapsed:.1f}s")
+
+
+def _convert_pmtiles(root: Path, out: Path, *, stats: dict, scheme: str) -> None:
+    click.echo("Converting tile folder → PMTiles")
+    click.echo(f"  Input:  {root}")
+    click.echo(f"  Output: {out}\n")
+
+    t0 = time.perf_counter()
+
+    from pmtiles.tile import Compression, TileType, zxy_to_tileid
+
+    minzoom = min(stats)
+    maxzoom = max(stats)
+    bounds = compute_bounds(stats, scheme=scheme)
+    total = sum(s.count for s in stats.values())
+    flip_y = scheme == "tms"
+
+    # Build entries: list of (tileid, tile_data)
+    # PMTiles uses XYZ internally — flip Y only if input is TMS
+    def tile_entries():
+        for z, x, y, tile_path in iter_tiles(root):
+            y_xyz = (2**z - 1) - y if flip_y else y
+            tile_id = zxy_to_tileid(z, x, y_xyz)
+            yield tile_id, tile_path.read_bytes()
+
+    # Sort by tile_id (required by PMTiles writer)
+    click.echo("Reading and sorting tiles...")
+    entries = sorted(tile_entries(), key=lambda e: e[0])
+
+    # Write PMTiles using the low-level writer
+    from pmtiles.writer import Writer as PMTilesWriter
+
+    if out.exists():
+        out.unlink()
+
+    with open(out, "wb") as f:
+        writer = PMTilesWriter(f)
+
+        for tile_id, tile_data in entries:
+            writer.write_tile(tile_id, tile_data)
+
+        writer.finalize(
+            header={
+                "tile_type": TileType.PNG,
+                "min_zoom": minzoom,
+                "max_zoom": maxzoom,
+                "min_lon_e7": int(bounds[0] * 1e7),
+                "min_lat_e7": int(bounds[1] * 1e7),
+                "max_lon_e7": int(bounds[2] * 1e7),
+                "max_lat_e7": int(bounds[3] * 1e7),
+                "tile_compression": Compression.NONE,
+            },
+            metadata={
+                "name": root.name,
+                "format": "png",
+                "bounds": f"{bounds[0]:.6f},{bounds[1]:.6f},{bounds[2]:.6f},{bounds[3]:.6f}",
+                "minzoom": str(minzoom),
+                "maxzoom": str(maxzoom),
+            },
+        )
+
+    elapsed = time.perf_counter() - t0
+    size_mb = out.stat().st_size / (1024 * 1024)
+
+    click.echo("Done.")
+    click.echo(f"  Tiles written:  {total:,}")
+    click.echo(f"  File size:      {size_mb:.1f} MB")
+    click.echo(f"  Duration:       {elapsed:.1f}s")

tilepack/selftest.py

@@ -0,0 +1,101 @@
+"""Selftest command: validate served tiles against original TMS folder."""
+
+from __future__ import annotations
+
+import random
+import time
+from pathlib import Path
+
+import click
+import httpx
+
+from tilepack.tms_utils import PNG_SIGNATURE, iter_tiles
+
+
+def run_selftest(input_root: str, base_url: str, samples: int) -> None:
+    root = Path(input_root).resolve()
+    base = base_url.rstrip("/")
+
+    click.echo(f"Selftest: {root}")
+    click.echo(f"Server:   {base}")
+    click.echo(f"Samples:  {samples}\n")
+
+    # Collect all tile coordinates
+    all_tiles = [(z, x, y, p) for z, x, y, p in iter_tiles(root)]
+    if not all_tiles:
+        click.echo("No tiles found in input folder.", err=True)
+        raise SystemExit(1)
+
+    # Sample
+    if samples >= len(all_tiles):
+        selected = all_tiles
+    else:
+        selected = random.sample(all_tiles, samples)
+
+    passed = 0
+    failed = 0
+    errors = []
+    latencies = []
+
+    with httpx.Client(timeout=30.0) as client:
+        for z, x, y, tile_path in selected:
+            url = f"{base}/{z}/{x}/{y}.png"
+            original = tile_path.read_bytes()
+
+            t0 = time.perf_counter()
+            try:
+                resp = client.get(url)
+            except httpx.RequestError as e:
+                failed += 1
+                errors.append(f"  {z}/{x}/{y}: connection error: {e}")
+                continue
+            latency_ms = (time.perf_counter() - t0) * 1000
+            latencies.append(latency_ms)
+
+            # Check status
+            if resp.status_code != 200:
+                failed += 1
+                errors.append(f"  {z}/{x}/{y}: HTTP {resp.status_code}")
+                continue
+
+            # Check content type
+            ct = resp.headers.get("content-type", "")
+            if "image/png" not in ct:
+                failed += 1
+                errors.append(f"  {z}/{x}/{y}: wrong content-type: {ct}")
+                continue
+
+            # Check PNG header
+            if resp.content[:8] != PNG_SIGNATURE:
+                failed += 1
+                errors.append(f"  {z}/{x}/{y}: invalid PNG header")
+                continue
+
+            # Byte comparison
+            if resp.content != original:
+                failed += 1
+                errors.append(
+                    f"  {z}/{x}/{y}: byte mismatch "
+                    f"(original={len(original)}, served={len(resp.content)})"
+                )
+                continue
+
+            passed += 1
+
+    # Report
+    avg_latency = sum(latencies) / len(latencies) if latencies else 0
+
+    click.echo(f"Total tested: {passed + failed}")
+    click.echo(f"Passed:       {passed}")
+    click.echo(f"Failed:       {failed}")
+    click.echo(f"Avg latency:  {avg_latency:.1f}ms")
+
+    if errors:
+        click.echo("\nFailures:")
+        for e in errors[:20]:
+            click.echo(e)
+        if len(errors) > 20:
+            click.echo(f"  ... and {len(errors) - 20} more")
+
+    if failed > 0:
+        raise SystemExit(1)

tilepack/serve.py

@@ -0,0 +1,211 @@
+"""Serve command: expose an MBTiles or PMTiles archive as a TMS and WMTS endpoint."""
+
+from __future__ import annotations
+
+import sqlite3
+from collections.abc import Callable
+from pathlib import Path
+
+import click
+from fastapi import FastAPI, Query, Response
+
+from tilepack.tms_utils import generate_tilemapresource_xml
+from tilepack.wmts_utils import generate_wmts_capabilities_xml
+
+
+def _add_wmts_routes(
+    app: FastAPI,
+    *,
+    wmts_xml: str,
+    layer_name: str,
+    get_tile_tms: Callable[[int, int, int], bytes | None],
+) -> None:
+    """Add WMTS endpoints (capabilities, RESTful tiles, KVP) to a FastAPI app.
+
+    ``get_tile_tms`` accepts (z, x, y_tms) and returns tile bytes or None.
+    """
+
+    @app.get("/WMTSCapabilities.xml")
+    def wmts_capabilities():
+        return Response(content=wmts_xml, media_type="application/xml")
+
+    @app.get("/wmts/{layer}/{tilematrixset}/{z}/{row}/{col}.png")
+    def wmts_tile_rest(layer: str, tilematrixset: str, z: int, row: int, col: int):
+        # WMTS Row = XYZ y (row 0 at north). Convert to TMS y (y 0 at south).
+        y_tms = (2**z - 1) - row
+        data = get_tile_tms(z, col, y_tms)
+        if data is None:
+            return Response(status_code=404, content="Tile not found")
+        return Response(content=data, media_type="image/png")
+
+    @app.get("/wmts")
+    def wmts_kvp(
+        Service: str = Query("WMTS"),
+        Request: str = Query("GetTile"),
+        Layer: str = Query(""),
+        TileMatrixSet: str = Query(""),
+        TileMatrix: int = Query(0),
+        TileRow: int = Query(0),
+        TileCol: int = Query(0),
+        Format: str = Query("image/png"),
+    ):
+        if Request == "GetCapabilities":
+            return Response(content=wmts_xml, media_type="application/xml")
+
+        # GetTile (default)
+        z = TileMatrix
+        y_tms = (2**z - 1) - TileRow
+        data = get_tile_tms(z, TileCol, y_tms)
+        if data is None:
+            return Response(status_code=404, content="Tile not found")
+        return Response(content=data, media_type="image/png")
+
+
+def _build_mbtiles_app(archive_path: Path, *, host: str, port: int) -> FastAPI:
+    app = FastAPI()
+    db_path = str(archive_path)
+
+    # Read metadata once at startup
+    conn = sqlite3.connect(db_path)
+    meta = dict(conn.execute("SELECT name, value FROM metadata").fetchall())
+    conn.close()
+
+    minzoom = int(meta.get("minzoom", "0"))
+    maxzoom = int(meta.get("maxzoom", "20"))
+    tile_format = meta.get("format", "png")
+
+    bounds_str = meta.get("bounds", "-180,-85,180,85")
+    parts = [float(v) for v in bounds_str.split(",")]
+    bounds = (parts[0], parts[1], parts[2], parts[3])
+    title = meta.get("name", "TMS Tiles")
+
+    # TMS capability document
+    xml = generate_tilemapresource_xml(
+        minzoom=minzoom,
+        maxzoom=maxzoom,
+        bounds=bounds,
+        tile_format=tile_format,
+        title=title,
+    )
+
+    @app.get("/tilemapresource.xml")
+    def tilemapresource():
+        return Response(content=xml, media_type="application/xml")
+
+    def _get_tile_tms(z: int, x: int, y: int) -> bytes | None:
+        conn = sqlite3.connect(db_path)
+        row = conn.execute(
+            "SELECT tile_data FROM tiles WHERE zoom_level=? AND tile_column=? AND tile_row=?",
+            (z, x, y),
+        ).fetchone()
+        conn.close()
+        return row[0] if row else None
+
+    @app.get("/{z}/{x}/{y}.png")
+    def get_tile(z: int, x: int, y: int):
+        data = _get_tile_tms(z, x, y)
+        if data is None:
+            return Response(status_code=404, content="Tile not found")
+        return Response(content=data, media_type="image/png")
+
+    # WMTS
+    wmts_xml = generate_wmts_capabilities_xml(
+        minzoom=minzoom,
+        maxzoom=maxzoom,
+        bounds=bounds,
+        tile_format=tile_format,
+        title=title,
+        base_url=f"http://{host}:{port}",
+    )
+    _add_wmts_routes(app, wmts_xml=wmts_xml, layer_name=title, get_tile_tms=_get_tile_tms)
+
+    return app
+
+
+def _build_pmtiles_app(archive_path: Path, *, host: str, port: int) -> FastAPI:
+    app = FastAPI()
+
+    from pmtiles.reader import MmapSource
+    from pmtiles.reader import Reader as PMTilesReader
+
+    source = MmapSource(open(archive_path, "rb"))
+    reader = PMTilesReader(source)
+    header = reader.header()
+
+    minzoom = header.get("min_zoom", 0)
+    maxzoom = header.get("max_zoom", 20)
+    bounds = (
+        header.get("min_lon_e7", -1800000000) / 1e7,
+        header.get("min_lat_e7", -850000000) / 1e7,
+        header.get("max_lon_e7", 1800000000) / 1e7,
+        header.get("max_lat_e7", 850000000) / 1e7,
+    )
+    title = archive_path.stem
+
+    # TMS capability document
+    xml = generate_tilemapresource_xml(
+        minzoom=minzoom,
+        maxzoom=maxzoom,
+        bounds=bounds,
+        tile_format="png",
+        title=title,
+    )
+
+    @app.get("/tilemapresource.xml")
+    def tilemapresource():
+        return Response(content=xml, media_type="application/xml")
+
+    def _get_tile_tms(z: int, x: int, y_tms: int) -> bytes | None:
+        # PMTiles stores in XYZ — flip TMS y to XYZ y
+        y_xyz = (2**z - 1) - y_tms
+        return reader.get(z, x, y_xyz)
+
+    @app.get("/{z}/{x}/{y}.png")
+    def get_tile(z: int, x: int, y: int):
+        data = _get_tile_tms(z, x, y)
+        if data is None:
+            return Response(status_code=404, content="Tile not found")
+        return Response(content=data, media_type="image/png")
+
+    # WMTS
+    wmts_xml = generate_wmts_capabilities_xml(
+        minzoom=minzoom,
+        maxzoom=maxzoom,
+        bounds=bounds,
+        tile_format="png",
+        title=title,
+        base_url=f"http://{host}:{port}",
+    )
+    _add_wmts_routes(app, wmts_xml=wmts_xml, layer_name=title, get_tile_tms=_get_tile_tms)
+
+    return app
+
+
+def run_serve(archive_file: str, host: str, port: int) -> None:
+    archive_path = Path(archive_file).resolve()
+    ext = archive_path.suffix.lower()
+
+    if ext == ".mbtiles":
+        app = _build_mbtiles_app(archive_path, host=host, port=port)
+    elif ext == ".pmtiles":
+        app = _build_pmtiles_app(archive_path, host=host, port=port)
+    else:
+        click.echo(f"Unknown archive format: {ext}", err=True)
+        raise SystemExit(1)
+
+    click.echo(f"Serving {archive_path.name} on http://{host}:{port}")
+    click.echo("  TMS:")
+    click.echo(f"    tilemapresource.xml → http://{host}:{port}/tilemapresource.xml")
+    click.echo(f"    Tiles               → http://{host}:{port}/{{z}}/{{x}}/{{y}}.png")
+    click.echo("  WMTS:")
+    click.echo(f"    Capabilities        → http://{host}:{port}/WMTSCapabilities.xml")
+    click.echo(
+        f"    Tiles (REST)        → http://{host}:{port}/wmts/{{Layer}}/{{TileMatrixSet}}/{{z}}/{{row}}/{{col}}.png"
+    )
+    click.echo(
+        f"    Tiles (KVP)         → http://{host}:{port}/wmts?Service=WMTS&Request=GetTile&...\n"
+    )
+
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port, log_level="info")

tilepack/tms_utils.py

@@ -0,0 +1,220 @@
+"""Shared utilities for TMS tile iteration, bounds computation, and XML generation."""
+
+from __future__ import annotations
+
+import math
+import re
+from collections import defaultdict
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from pathlib import Path
+from xml.sax.saxutils import escape
+
+PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
+EXT_RE = re.compile(r"\.(png|jpg|jpeg|webp)$", re.IGNORECASE)
+
+
+@dataclass
+class ZoomStats:
+    min_x: int = field(default=10**18)
+    max_x: int = field(default=-(10**18))
+    min_y: int = field(default=10**18)
+    max_y: int = field(default=-(10**18))
+    count: int = 0
+
+    def update(self, x: int, y: int) -> None:
+        self.min_x = min(self.min_x, x)
+        self.max_x = max(self.max_x, x)
+        self.min_y = min(self.min_y, y)
+        self.max_y = max(self.max_y, y)
+        self.count += 1
+
+
+def iter_tiles(root: Path) -> Iterable[tuple[int, int, int, Path]]:
+    """Yield (z, x, y, filepath) for tiles matching root/z/x/y.ext."""
+    for z_dir in sorted(root.iterdir()):
+        if not z_dir.is_dir():
+            continue
+        try:
+            z = int(z_dir.name)
+        except ValueError:
+            continue
+
+        for x_dir in sorted(z_dir.iterdir()):
+            if not x_dir.is_dir():
+                continue
+            try:
+                x = int(x_dir.name)
+            except ValueError:
+                continue
+
+            for f in x_dir.iterdir():
+                if not f.is_file() or not EXT_RE.search(f.name):
+                    continue
+                try:
+                    y = int(f.stem)
+                except ValueError:
+                    continue
+                yield z, x, y, f
+
+
+def collect_zoom_stats(root: Path) -> dict[int, ZoomStats]:
+    """Scan a TMS folder and return per-zoom statistics."""
+    stats: dict[int, ZoomStats] = defaultdict(ZoomStats)
+    for z, x, y, _ in iter_tiles(root):
+        stats[z].update(x, y)
+    return dict(stats)
+
+
+def _tile2lon(x: float, z: int) -> float:
+    return x / (2**z) * 360.0 - 180.0
+
+
+def _tile2lat_xyz(y_xyz: float, z: int) -> float:
+    """Convert XYZ y coordinate to latitude. In XYZ, y=0 is at the north pole."""
+    n = math.pi - (2.0 * math.pi * y_xyz) / (2**z)
+    return math.degrees(math.atan(math.sinh(n)))
+
+
+def _compute_bounds_as_scheme(
+    zoom_stats: dict[int, ZoomStats], scheme: str
+) -> tuple[float, float, float, float]:
+    """Compute bounds assuming the Y values follow the given scheme ('tms' or 'xyz').
+
+    Returns (min_lon, min_lat, max_lon, max_lat).
+    """
+    min_lon, min_lat = 180.0, 90.0
+    max_lon, max_lat = -180.0, -90.0
+
+    for z, st in zoom_stats.items():
+        lon_left = _tile2lon(st.min_x, z)
+        lon_right = _tile2lon(st.max_x + 1, z)
+
+        if scheme == "tms":
+            # TMS: y=0 at bottom (south). Convert to XYZ for the lat formula.
+            y_xyz_top = (2**z - 1) - (st.max_y + 1)  # top edge
+            y_xyz_bottom = (2**z - 1) - st.min_y  # bottom edge
+        else:
+            # XYZ: y values are already XYZ
+            y_xyz_top = st.min_y  # top edge (smaller y = further north)
+            y_xyz_bottom = st.max_y + 1  # bottom edge
+
+        lat_top = _tile2lat_xyz(max(y_xyz_top, 0), z)
+        lat_bottom = _tile2lat_xyz(min(y_xyz_bottom, 2**z), z)
+
+        min_lon = min(min_lon, lon_left)
+        max_lon = max(max_lon, lon_right)
+        min_lat = min(min_lat, lat_bottom, lat_top)
+        max_lat = max(max_lat, lat_bottom, lat_top)
+
+    return min_lon, min_lat, max_lon, max_lat
+
+
+def compute_bounds(
+    zoom_stats: dict[int, ZoomStats],
+    scheme: str = "tms",
+) -> tuple[float, float, float, float]:
+    """Compute a union bounding box in EPSG:4326 from tile ranges.
+
+    ``scheme`` indicates how to interpret Y values: ``"tms"`` (y=0 at south)
+    or ``"xyz"`` (y=0 at north).  Returns (min_lon, min_lat, max_lon, max_lat).
+    """
+    return _compute_bounds_as_scheme(zoom_stats, scheme)
+
+
+def detect_scheme(
+    zoom_stats: dict[int, ZoomStats],
+    has_tilemapresource: bool = False,
+) -> tuple[str, tuple[float, float, float, float], tuple[float, float, float, float]]:
+    """Detect whether tile Y coordinates follow TMS or XYZ convention.
+
+    Uses two signals:
+    1. Presence of tilemapresource.xml in the folder (strong TMS indicator).
+    2. Y-coordinate position relative to the midpoint of the tile grid.
+       - TMS: y=0 at south, so northern-hemisphere data has y > 2^(z-1).
+       - XYZ: y=0 at north, so northern-hemisphere data has y < 2^(z-1).
+       Interpreting with the wrong scheme mirrors latitude across the equator.
+
+    Returns (detected_scheme, tms_bounds, xyz_bounds).
+    """
+    tms_bounds = _compute_bounds_as_scheme(zoom_stats, "tms")
+    xyz_bounds = _compute_bounds_as_scheme(zoom_stats, "xyz")
+
+    # If tilemapresource.xml exists, it's definitively TMS
+    if has_tilemapresource:
+        return "tms", tms_bounds, xyz_bounds
+
+    # Heuristic: check if y values sit above or below the midpoint of the grid.
+    # Use the highest zoom level for best precision.
+    z = max(zoom_stats)
+    st = zoom_stats[z]
+    midpoint = 2 ** (z - 1)  # half of 2^z
+    y_center = (st.min_y + st.max_y) / 2
+
+    # If y_center > midpoint, the data is in the northern hemisphere under TMS
+    # (and southern under XYZ). If y_center < midpoint, it's the reverse.
+    # For datasets on the equator (y_center ≈ midpoint), both schemes give
+    # nearly identical results, so the choice doesn't matter much.
+    #
+    # We can't know "ground truth" without external info, but we can report
+    # which interpretation places the data where, and make a best guess:
+    # For y_center > midpoint: likely TMS (data in northern hemisphere)
+    # For y_center < midpoint: likely XYZ (data in northern hemisphere)
+    # This works because most populated landmass is in the northern hemisphere.
+    if y_center > midpoint:
+        return "tms", tms_bounds, xyz_bounds
+    elif y_center < midpoint:
+        return "xyz", tms_bounds, xyz_bounds
+    else:
+        # Equatorial — default to TMS
+        return "tms", tms_bounds, xyz_bounds
+
+
+def generate_tilemapresource_xml(
+    minzoom: int,
+    maxzoom: int,
+    bounds: tuple[float, float, float, float],
+    tile_format: str = "png",
+    title: str = "TMS Tiles",
+    tile_size: int = 256,
+    srs: str = "EPSG:3857",
+) -> str:
+    """Generate a TMS tilemapresource.xml string."""
+    min_lon, min_lat, max_lon, max_lat = bounds
+    R = 6378137.0
+
+    if srs == "EPSG:4326":
+        bb_minx, bb_miny = min_lon, min_lat
+        bb_maxx, bb_maxy = max_lon, max_lat
+        origin_x, origin_y = -180.0, -90.0
+        tilesets_profile = "global-geodetic"
+        initial_resolution = 360.0 / tile_size
+    else:  # EPSG:3857
+        bb_minx = min_lon * math.pi * R / 180.0
+        bb_miny = math.log(math.tan(math.pi / 4 + math.radians(min_lat) / 2)) * R
+        bb_maxx = max_lon * math.pi * R / 180.0
+        bb_maxy = math.log(math.tan(math.pi / 4 + math.radians(max_lat) / 2)) * R
+        origin_x, origin_y = -20037508.342789244, -20037508.342789244
+        tilesets_profile = "global-mercator"
+        initial_resolution = (2 * math.pi * R) / tile_size
+
+    tile_sets = []
+    for z in range(minzoom, maxzoom + 1):
+        res = initial_resolution / (2**z)
+        tile_sets.append(f'    <TileSet href="{z}" units-per-pixel="{res:.14f}" order="{z}"/>')
+
+    mime = "image/jpeg" if tile_format in ("jpg", "jpeg") else f"image/{tile_format}"
+
+    return f"""<?xml version="1.0" encoding="UTF-8"?>
+<TileMap version="1.0.0" tilemapservice="1.0.0">
+  <Title>{escape(title)}</Title>
+  <Abstract/>
+  <SRS>{srs}</SRS>
+  <BoundingBox minx="{bb_minx:.10f}" miny="{bb_miny:.10f}" maxx="{bb_maxx:.10f}" maxy="{bb_maxy:.10f}"/>
+  <Origin x="{origin_x}" y="{origin_y}"/>
+  <TileFormat width="{tile_size}" height="{tile_size}" mime-type="{mime}" extension="{tile_format}"/>
+  <TileSets profile="{tilesets_profile}">
+{chr(10).join(tile_sets)}
+  </TileSets>
+</TileMap>
+"""

tilepack/verify.py

@@ -0,0 +1,70 @@
+"""Verify command: scan a TMS folder and report tile statistics."""
+
+import random
+from pathlib import Path
+
+import click
+
+from tilepack.tms_utils import (
+    PNG_SIGNATURE,
+    collect_zoom_stats,
+    detect_scheme,
+)
+
+
+def _fmt_bounds(bounds: tuple) -> str:
+    """Format bounds as a readable string with lat/lon labels."""
+    min_lon, min_lat, max_lon, max_lat = bounds
+    return f"lon [{min_lon:.4f}, {max_lon:.4f}]  lat [{min_lat:.4f}, {max_lat:.4f}]"
+
+
+def run_verify(input_root: str) -> None:
+    root = Path(input_root).resolve()
+    click.echo(f"Scanning: {root}\n")
+
+    stats = collect_zoom_stats(root)
+    if not stats:
+        click.echo("No tiles found.", err=True)
+        raise SystemExit(1)
+
+    minzoom = min(stats)
+    maxzoom = max(stats)
+    total = sum(s.count for s in stats.values())
+
+    click.echo(f"Zoom range: {minzoom} – {maxzoom}")
+    click.echo(f"{'Zoom':>6}  {'Tiles':>10}")
+    click.echo(f"{'----':>6}  {'-----':>10}")
+    for z in range(minzoom, maxzoom + 1):
+        s = stats.get(z)
+        click.echo(f"{z:>6}  {s.count if s else 0:>10,}")
+    click.echo(f"{'Total':>6}  {total:>10,}")
+
+    # PNG header check on a random sample tile
+    click.echo()
+    # Pick a random zoom, then a random x dir, then a random tile file
+    z_pick = random.choice(list(stats.keys()))
+    z_dir = root / str(z_pick)
+    x_dirs = [d for d in z_dir.iterdir() if d.is_dir()]
+    if x_dirs:
+        x_dir = random.choice(x_dirs)
+        tile_files = [f for f in x_dir.iterdir() if f.is_file() and f.suffix.lower() == ".png"]
+        if tile_files:
+            tile_path = random.choice(tile_files)
+            header = tile_path.read_bytes()[:8]
+            is_png = header == PNG_SIGNATURE
+            rel = tile_path.relative_to(root)
+            click.echo(f"Format check: {'PNG ✓' if is_png else 'NOT PNG ✗'} (sampled {rel})")
+        else:
+            click.echo("Format check: no tile files to sample")
+    else:
+        click.echo("Format check: no tile directories to sample")
+
+    # Scheme detection
+    has_xml = (root / "tilemapresource.xml").exists()
+    detected, tms_bounds, xyz_bounds = detect_scheme(stats, has_tilemapresource=has_xml)
+
+    click.echo("\nY-axis scheme detection:")
+    click.echo(f"  tilemapresource.xml present: {'yes' if has_xml else 'no'}")
+    click.echo(f"  If TMS (y=0 at south):  {_fmt_bounds(tms_bounds)}")
+    click.echo(f"  If XYZ (y=0 at north):  {_fmt_bounds(xyz_bounds)}")
+    click.echo(f"  Detected scheme: {detected.upper()}")

tilepack/wmts_utils.py

@@ -0,0 +1,159 @@
+"""Generate OGC WMTS GetCapabilities XML documents."""
+
+from __future__ import annotations
+
+import math
+from xml.sax.saxutils import escape
+
+# OGC WMTS constants for GoogleMapsCompatible tile matrix set
+_R = 6378137.0  # WGS-84 Earth radius in metres
+_TOP_LEFT_CORNER = f"-{math.pi * _R:.10f} {math.pi * _R:.10f}"
+# OGC defines 1 pixel = 0.28 mm for scale denominator calculation
+_PIXEL_SIZE_M = 0.00028
+# Scale denominator at zoom 0 for 256px tiles in EPSG:3857
+_SCALE_DENOM_Z0 = (2 * math.pi * _R) / (256 * _PIXEL_SIZE_M)
+
+
+def generate_wmts_capabilities_xml(
+    *,
+    minzoom: int,
+    maxzoom: int,
+    bounds: tuple[float, float, float, float],
+    tile_format: str = "png",
+    title: str = "WMTS Tiles",
+    tile_size: int = 256,
+    base_url: str = "http://localhost:8000",
+) -> str:
+    """Generate an OGC WMTS 1.0.0 GetCapabilities XML string.
+
+    Parameters
+    ----------
+    minzoom, maxzoom : int
+        Zoom level range.
+    bounds : tuple
+        (min_lon, min_lat, max_lon, max_lat) in EPSG:4326.
+    tile_format : str
+        Tile image format (png, jpg, webp).
+    title : str
+        Layer/service title.
+    tile_size : int
+        Tile width/height in pixels (default 256).
+    base_url : str
+        Server base URL used for ResourceURL templates.
+    """
+    min_lon, min_lat, max_lon, max_lat = bounds
+    layer_id = escape(title)
+    tms_id = "GoogleMapsCompatible"
+    mime = "image/jpeg" if tile_format in ("jpg", "jpeg") else f"image/{tile_format}"
+
+    # Build TileMatrix entries for each zoom level
+    tile_matrices = []
+    for z in range(minzoom, maxzoom + 1):
+        scale_denom = _SCALE_DENOM_Z0 / (2**z)
+        matrix_size = 2**z
+        tile_matrices.append(
+            f"""      <TileMatrix>
+        <ows:Identifier>{z}</ows:Identifier>
+        <ScaleDenominator>{scale_denom:.10f}</ScaleDenominator>
+        <TopLeftCorner>{_TOP_LEFT_CORNER}</TopLeftCorner>
+        <TileWidth>{tile_size}</TileWidth>
+        <TileHeight>{tile_size}</TileHeight>
+        <MatrixWidth>{matrix_size}</MatrixWidth>
+        <MatrixHeight>{matrix_size}</MatrixHeight>
+      </TileMatrix>"""
+        )
+
+    # Bounding box in EPSG:3857 (metres)
+    bb_minx = min_lon * math.pi * _R / 180.0
+    bb_miny = math.log(math.tan(math.pi / 4 + math.radians(min_lat) / 2)) * _R
+    bb_maxx = max_lon * math.pi * _R / 180.0
+    bb_maxy = math.log(math.tan(math.pi / 4 + math.radians(max_lat) / 2)) * _R
+
+    resource_url = f"{base_url}/wmts/{title}/{tms_id}/{{TileMatrix}}/{{TileRow}}/{{TileCol}}.png"
+
+    return f"""<?xml version="1.0" encoding="UTF-8"?>
+<Capabilities xmlns="http://www.opengis.net/wmts/1.0"
+              xmlns:ows="http://www.opengis.net/ows/1.1"
+              xmlns:xlink="http://www.w3.org/1999/xlink"
+              version="1.0.0">
+  <ows:ServiceIdentification>
+    <ows:Title>{layer_id}</ows:Title>
+    <ows:ServiceType>OGC WMTS</ows:ServiceType>
+    <ows:ServiceTypeVersion>1.0.0</ows:ServiceTypeVersion>
+  </ows:ServiceIdentification>
+  <Contents>
+    <Layer>
+      <ows:Title>{layer_id}</ows:Title>
+      <ows:Identifier>{layer_id}</ows:Identifier>
+      <ows:WGS84BoundingBox>
+        <ows:LowerCorner>{min_lon:.10f} {min_lat:.10f}</ows:LowerCorner>
+        <ows:UpperCorner>{max_lon:.10f} {max_lat:.10f}</ows:UpperCorner>
+      </ows:WGS84BoundingBox>
+      <Style isDefault="true">
+        <ows:Identifier>default</ows:Identifier>
+      </Style>
+      <Format>{mime}</Format>
+      <TileMatrixSetLink>
+        <TileMatrixSet>{tms_id}</TileMatrixSet>
+        <TileMatrixSetLimits>
+{_tile_matrix_set_limits(minzoom, maxzoom, bounds)}
+        </TileMatrixSetLimits>
+      </TileMatrixSetLink>
+      <ResourceURL format="{mime}" resourceType="tile"
+                   template="{escape(resource_url)}"/>
+    </Layer>
+    <TileMatrixSet>
+      <ows:Identifier>{tms_id}</ows:Identifier>
+      <ows:SupportedCRS>urn:ogc:def:crs:EPSG::3857</ows:SupportedCRS>
+      <ows:BoundingBox crs="urn:ogc:def:crs:EPSG::3857">
+        <ows:LowerCorner>{bb_minx:.10f} {bb_miny:.10f}</ows:LowerCorner>
+        <ows:UpperCorner>{bb_maxx:.10f} {bb_maxy:.10f}</ows:UpperCorner>
+      </ows:BoundingBox>
+{chr(10).join(tile_matrices)}
+    </TileMatrixSet>
+  </Contents>
+</Capabilities>
+"""
+
+
+def _lat_to_wmts_row(lat_deg: float, n: int) -> int:
+    """Convert latitude (degrees) to WMTS tile row at grid size n."""
+    lat_rad = math.radians(lat_deg)
+    frac = (1.0 - math.log(math.tan(lat_rad) + 1.0 / math.cos(lat_rad)) / math.pi) / 2.0
+    return int(math.floor(frac * n))
+
+
+def _tile_matrix_set_limits(
+    minzoom: int,
+    maxzoom: int,
+    bounds: tuple[float, float, float, float],
+) -> str:
+    """Compute TileMatrixSetLimits for the given bounds at each zoom level.
+
+    Returns XML fragment with min/max row/col for each TileMatrix.
+    """
+    min_lon, min_lat, max_lon, max_lat = bounds
+    lines = []
+    for z in range(minzoom, maxzoom + 1):
+        n = 2**z
+        # Column range (same as x in both TMS and XYZ)
+        min_col = int(math.floor((min_lon + 180.0) / 360.0 * n))
+        max_col = int(math.floor((max_lon + 180.0) / 360.0 * n))
+        max_col = min(max_col, n - 1)
+
+        # Row range (WMTS row = XYZ y, row 0 at north)
+        min_row = _lat_to_wmts_row(max_lat, n)
+        max_row = _lat_to_wmts_row(min_lat, n)
+        min_row = max(min_row, 0)
+        max_row = min(max_row, n - 1)
+
+        lines.append(
+            f"""          <TileMatrixLimits>
+            <TileMatrix>{z}</TileMatrix>
+            <MinTileRow>{min_row}</MinTileRow>
+            <MaxTileRow>{max_row}</MaxTileRow>
+            <MinTileCol>{min_col}</MinTileCol>
+            <MaxTileCol>{max_col}</MaxTileCol>
+          </TileMatrixLimits>"""
+        )
+    return "\n".join(lines)

tilepack-0.1.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: tilepack
+Version: 0.1.0
+Summary: Convert TMS tile folders to MBTiles/PMTiles and serve them as TMS/WMTS endpoints
+Author-email: Ashwin Nair <ashnair0007@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Python: >=3.11
+Requires-Dist: click>=8.0
+Requires-Dist: fastapi>=0.110
+Requires-Dist: httpx>=0.27
+Requires-Dist: pmtiles>=3.4
+Requires-Dist: uvicorn[standard]>=0.29
+Description-Content-Type: text/markdown
+
+# tilepack
+
+[![CI](https://github.com/ashnair1/tilepack/actions/workflows/ci.yml/badge.svg)](https://github.com/ashnair1/tilepack/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/tilepack)](https://pypi.org/project/tilepack/)
+[![Python](https://img.shields.io/pypi/pyversions/tilepack)](https://pypi.org/project/tilepack/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Pack raster tile folders (TMS or XYZ) into single-file archives (MBTiles / PMTiles) and serve them as TMS and WMTS endpoints over HTTP.
+
+## Why
+
+Raster tile folders contain thousands of small PNG files in deeply nested `z/x/y` directories. This makes them slow to copy, hard to manage, and fragile to transfer. Tilepack solves this by packing tiles into a single archive file while still exposing standard TMS and WMTS HTTP endpoints that clients like QGIS and CesiumForUnreal can consume directly.
+
+## Install
+
+Requires Python 3.11+.
+
+```bash
+pip install tilepack
+```
+
+For development:
+
+```bash
+git clone https://github.com/ashnair1/tilepack.git
+cd tilepack
+uv sync --group dev
+```
+
+## Usage
+
+### Verify a tile folder
+
+Scan a tile folder and report zoom levels, tile counts, format, and detected Y-axis scheme (TMS vs XYZ).
+
+```bash
+tilepack verify ./path/to/tiles
+```
+
+### Convert to archive
+
+The output format is inferred from the file extension. The input tile scheme (TMS or XYZ) is auto-detected, or can be specified explicitly.
+
+```bash
+# Auto-detect input scheme
+tilepack convert ./path/to/tiles output.mbtiles
+tilepack convert ./path/to/tiles output.pmtiles
+
+# Specify input scheme explicitly
+tilepack convert ./path/to/tiles output.mbtiles --scheme xyz
+```
+
+### Serve as TMS + WMTS endpoint
+
+Start a local HTTP server exposing both TMS and OGC WMTS 1.0.0 endpoints from an archive file.
+
+```bash
+tilepack serve output.mbtiles --port 8000
+tilepack serve output.pmtiles --port 8000
+```
+
+**TMS endpoints:**
+- `http://localhost:8000/tilemapresource.xml`
+- `http://localhost:8000/{z}/{x}/{y}.png`
+
+**WMTS endpoints:**
+- `http://localhost:8000/WMTSCapabilities.xml` — GetCapabilities
+- `http://localhost:8000/wmts/{Layer}/{TileMatrixSet}/{z}/{row}/{col}.png` — RESTful tiles
+- `http://localhost:8000/wmts?Service=WMTS&Request=GetTile&...` — KVP tiles
+
+To load in QGIS: **Layer > Add WMS/WMTS Layer > New**, set URL to `http://localhost:8000/WMTSCapabilities.xml`, then Connect and Add.
+
+### Validate correctness
+
+Randomly sample tiles from the original folder, fetch them from the running server, and verify byte-exact matches.
+
+```bash
+# Start the server in one terminal, then in another:
+tilepack selftest ./path/to/tiles --base-url http://127.0.0.1:8000 --samples 200
+```
+
+## MBTiles vs PMTiles
+
+| | MBTiles | PMTiles |
+|---|---------|---------|
+| Format | SQLite database | Cloud-optimised archive (Hilbert-curve index) |
+| File count | 1 | 1 |
+| Needs a tile server | Yes | No (supports HTTP range requests) |
+| Best for | Local / on-prem serving | Cloud storage (S3, Azure Blob, GCS) |
+
+**Use MBTiles** for local or on-prem serving (e.g. feeding CesiumForUnreal on the same machine or network). It's a SQLite file with fast tile lookups and no coordinate flipping at read time.
+
+**Use PMTiles** if you plan to host tiles in cloud storage. PMTiles can be served directly from a bucket via HTTP range requests with no tile server needed. However, TMS clients like CesiumForUnreal cannot consume PMTiles directly — they still need a server translating to TMS endpoints.
+
+**Either format** works identically when served through `tilepack serve` — clients see the same TMS and WMTS endpoints regardless of the backing archive.
+
+## License
+
+MIT

tilepack-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+tilepack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tilepack/__main__.py,sha256=Rd5tVnXo2vKtYrGXpzfaeG7m8kOw_YI-4QqukMfuZg4,80
+tilepack/cli.py,sha256=2olgdpnIQPFEMPCoqHdaHipkTd6JlN2g-B6h7WvdXMU,1923
+tilepack/convert.py,sha256=sVngsfGr2cesAItI9sMYZvTSPSK3MJt6NkxLE-gM3HM,6070
+tilepack/selftest.py,sha256=5-8DZbKQkPEH9Y_-SMIm6XsT6zoajxC541EZCGh6kCQ,2969
+tilepack/serve.py,sha256=wdSJc03KNmx9BzeP15DLRO-B8IbisDp9-V4-Jd0lyYA,6955
+tilepack/tms_utils.py,sha256=tX56mghMH7aDIGVclwYL2eVuK5_kdMfxnB0Tn9eH950,7969
+tilepack/verify.py,sha256=aSTIQO0aywcPIw_k-QMxMn3HHN-kEamldjMdz8KSwbE,2504
+tilepack/wmts_utils.py,sha256=80bJaurnNS_7bp8YBZuVsbhcIx34G1_iOG8KUCecwow,5706
+tilepack-0.1.0.dist-info/METADATA,sha256=leqttRORevOZueb_NYEFkGf4lLnXMWdKEdlfy-uj7gg,4433
+tilepack-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+tilepack-0.1.0.dist-info/entry_points.txt,sha256=dQeecyuWc4Jri8YQ7PdprFBFY2UraVUVpwhUxETnDGI,46
+tilepack-0.1.0.dist-info/licenses/LICENSE,sha256=XgQUG_tS3jb9Ona3ukK8Fxu3iULlAGEUQi2LvVcsnIM,1068
+tilepack-0.1.0.dist-info/RECORD,,

tilepack-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

tilepack-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tilepack = tilepack.cli:cli

tilepack-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ashwin Nair
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.