GeoPakTile 2.0.0__py3-none-any.whl

geopaktile/__init__.py

@@ -0,0 +1,5 @@
+from geopaktile.geopaktile import GeoPakTile
+from geopaktile.xml_parser import get_tile_matrix_set, parse_capabilities
+
+def main():
+    print("Command line usage has not been implemented.")

geopaktile/__main__.py

@@ -0,0 +1,4 @@
+from geopaktile import main
+
+if __name__ == "__main__":
+    main()

geopaktile/geopaktile.py

@@ -0,0 +1,442 @@
+import re
+import sqlite3
+import sys
+from collections.abc import Iterable
+from os import PathLike
+from pathlib import Path
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+from typing import ClassVar, Literal
+
+import numpy as np
+from morecantile.models import TileMatrixSet
+from pyproj import CRS
+
+_IDENTIFIER_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+class GeoPakTile:
+    DEFAULT_PRAGMAS: ClassVar[dict[str, str]] = {
+        "synchronous": "NORMAL",
+        "journal_mode": "WAL",
+        "locking_mode": "EXCLUSIVE",
+    }
+
+    def __init__(
+        self,
+        filepath: str | PathLike,
+        tms: TileMatrixSet,
+        table_name: str = "tiles",
+        mode: Literal["ro", "rw", "rwc"] = "ro",
+        pragmas: dict[str, str] | None = None,
+    ):
+        """Create and or write tiles to a geopackage XYZ tile layer.
+
+        A tile matrix set is required in order to get the correct co-ordinates for the tiles and data extents.
+        These are provided by the `morecantile` library, or can be parsed from a WMTS capabilities document using the
+        `xml_parser.parse_tile_matrix_set` function.
+
+        Args:
+            filepath (str | PathLike): where the geopackage is or should be created
+            tms (TileMatrixSet): Describes the tile coordinates and data extent
+            table_name (str, optional): The name of the tile table/layer. Defaults to "tiles".
+            mode (Literal[ro, rw, rwc], optional): Sqlite3 connection modes. ro = read only, rw is
+                read-write, rwc is read, write or create. Defaults to 'ro' for safety.
+            pragmas (dict[str, str], optional): PRAGMA overrides/additions applied
+                on top of DEFAULT_PRAGMAS after connecting. Pass e.g.
+                {"synchronous": "FULL"} to override a default, or add new keys
+                for pragmas not set by default. Defaults to None (no changes).
+        """
+
+        self.filepath = Path(filepath)
+        self.tms = tms
+        self.table_name = table_name
+
+        self._validate_table_name()
+
+        if mode not in ("ro", "rw", "rwc"):
+            raise ValueError("Mode must be ro, rw or rwc")
+
+        if mode in ["ro", "rw"] and not self.filepath.exists():
+            raise FileNotFoundError("geopackage not found")
+
+        file_string = f"{self.filepath.absolute().as_uri()}?mode={mode}"
+        self._conn = sqlite3.connect(file_string, uri=True)
+        self._cursor = self._conn.cursor()
+        self._apply_pragmas(pragmas)
+
+        # initialize tables if needed and in create mode
+        if mode == "rwc":
+            self._create_tables()
+
+    def __enter__(self) -> Self:
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        """Close the connection"""
+        self._cursor.close()
+        self._conn.close()
+
+    def has_tile(self, z: int, x: int, y: int):
+        """Check if a tile is present, using the zxy coordinates"""
+
+        self._cursor.execute(
+            f"SELECT EXISTS (SELECT 1 FROM {self.table_name} "
+            "where zoom_level=? and tile_column=? and tile_row=? LIMIT 1)",
+            (z, x, y),
+        )
+
+        row = self._cursor.fetchone()
+        return row[0] == 1
+
+    def has_tiles(self, zxys: list[tuple[int, int, int]] | np.ndarray) -> np.ndarray:
+        """Check many tiles efficiently."""
+
+        requested = np.asarray(zxys, dtype=np.uint64)
+
+        self._cursor.execute(
+            f"SELECT zoom_level, tile_column, tile_row FROM {self.table_name}"
+        )
+        rows = self._cursor.fetchall()
+        existing = (
+            np.array(rows, dtype=np.uint64)
+            if rows
+            else np.empty((0, 3), dtype=np.uint64)
+        )
+
+        # Combine z, x, y into a single array using bit shifting
+        # [ 8 bits unused ][ 8 bits z ][ 28 bits x ][ 28 bits y ]
+        def pack(arr: np.ndarray) -> np.ndarray:
+            z, x, y = arr[:, 0], arr[:, 1], arr[:, 2]
+            return (z << np.uint64(56)) | (x << np.uint64(28)) | y
+
+        req_keys = pack(requested)
+        exist_keys = pack(existing)
+
+        return np.isin(req_keys, exist_keys, assume_unique=False)
+
+    def add_tiles(
+        self,
+        tiles: Iterable[tuple[int, int, int, bytes]],
+        batch_size: int = 1000,
+    ) -> None:
+        """Add tiles to the geopackage
+
+        Args:
+            tiles (Iterable[tuple[int, int, int, bytes]]): List of tiles - [z, x, y, image data in bytes]
+            batch_size (int, optional): Add images in batches for speed. Defaults to 1000.
+        """
+
+        insert_sql = f"""
+            INSERT OR IGNORE INTO "{self.table_name}"
+            (
+                zoom_level,
+                tile_column,
+                tile_row,
+                tile_data
+            )
+            VALUES (?, ?, ?, ?)
+        """
+
+        zs = {t[0] for t in tiles}
+        for z in zs:
+            self._ensure_zoom_level(z)
+
+        batch = []
+        for z, x, y, tile_bytes in tiles:
+            z = int(z)
+            x = int(x)
+            y = int(y)
+
+            if self.has_tile(z, x, y):
+                continue
+
+            batch.append((z, x, y, sqlite3.Binary(tile_bytes)))
+            if len(batch) >= batch_size:
+                self._cursor.executemany(insert_sql, batch)
+                self._conn.commit()
+                batch.clear()
+
+        if batch:
+            self._cursor.executemany(insert_sql, batch)
+            self._conn.commit()
+
+    def _apply_pragmas(self, overrides: dict[str, str] | None) -> None:
+        merged = {**self.DEFAULT_PRAGMAS, **(overrides or {})}
+        for name, value in merged.items():
+            # Ensure malicious values aren't parsed.
+            # Passes: "WAL", "NORMAL", "OFF", "EXCLUSIVE", "1000" (a plausible wal_autocheckpoint value)
+            # Blocked: "WAL; DROP TABLE tiles;--", "OFF' OR '1'='1", anything with spaces, quotes, or punctuation
+            if not str(value).replace("_", "").isalnum():
+                raise ValueError(f"Unsafe PRAGMA value for {name!r}: {value!r}")
+            self._cursor.execute(f"PRAGMA {name}={value}")
+
+    def _create_tables(self):
+        """Create the tables for a valid geopackage XYZ layer"""
+
+        self._cursor.execute("PRAGMA application_id = 1196437808")
+        self._cursor.execute("PRAGMA user_version = 10400")
+
+        self._cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS gpkg_spatial_ref_sys (
+                srs_name TEXT NOT NULL,
+                srs_id INTEGER NOT NULL PRIMARY KEY,
+                organization TEXT NOT NULL,
+                organization_coordsys_id INTEGER NOT NULL,
+                definition TEXT NOT NULL,
+                description TEXT
+            )
+            """
+        )
+
+        self._cursor.execute(
+            """
+            INSERT OR IGNORE INTO gpkg_spatial_ref_sys
+            VALUES
+            (
+                'Undefined Cartesian SRS',
+                -1,
+                'NONE',
+                -1,
+                'undefined',
+                'undefined Cartesian coordinate reference system'
+            )
+            """
+        )
+
+        self._cursor.execute(
+            """
+            INSERT OR IGNORE INTO gpkg_spatial_ref_sys
+            VALUES
+            (
+                'Undefined Geographic SRS',
+                0,
+                'NONE',
+                0,
+                'undefined',
+                'undefined geographic coordinate reference system'
+            )
+            """
+        )
+
+        epsg = self.tms.crs.to_epsg()
+        if epsg is None:
+            raise ValueError(
+                f"TileMatrixSet CRS {self.tms.crs} does not have an EPSG code."
+            )
+        crs = CRS.from_epsg(epsg)
+        srs_name = crs.name
+        definition = crs.to_wkt()
+
+        self._cursor.execute(
+            """
+            INSERT OR IGNORE INTO gpkg_spatial_ref_sys
+            (
+                srs_name,
+                srs_id,
+                organization,
+                organization_coordsys_id,
+                definition,
+                description
+            )
+            VALUES (?, ?, 'EPSG', ?, ?, ?)
+            """,
+            (
+                srs_name,
+                epsg,
+                epsg,
+                definition,
+                srs_name,
+            ),
+        )
+
+        self._cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS gpkg_contents (
+                table_name TEXT NOT NULL PRIMARY KEY,
+                data_type TEXT NOT NULL,
+                identifier TEXT UNIQUE,
+                description TEXT DEFAULT '',
+                last_change DATETIME NOT NULL DEFAULT
+                    (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+                min_x DOUBLE,
+                min_y DOUBLE,
+                max_x DOUBLE,
+                max_y DOUBLE,
+                srs_id INTEGER,
+                CONSTRAINT fk_gc_r_srs_id
+                    FOREIGN KEY (srs_id)
+                    REFERENCES gpkg_spatial_ref_sys(srs_id)
+            )
+            """
+        )
+
+        self._cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS gpkg_tile_matrix_set (
+                table_name TEXT NOT NULL PRIMARY KEY,
+                srs_id INTEGER NOT NULL,
+                min_x DOUBLE NOT NULL,
+                min_y DOUBLE NOT NULL,
+                max_x DOUBLE NOT NULL,
+                max_y DOUBLE NOT NULL,
+                CONSTRAINT fk_gtms_table_name
+                    FOREIGN KEY (table_name)
+                    REFERENCES gpkg_contents(table_name),
+                CONSTRAINT fk_gtms_srs
+                    FOREIGN KEY (srs_id)
+                    REFERENCES gpkg_spatial_ref_sys(srs_id)
+            )
+            """
+        )
+
+        self._cursor.execute(
+            """
+            CREATE TABLE IF NOT EXISTS gpkg_tile_matrix (
+                table_name TEXT NOT NULL,
+                zoom_level INTEGER NOT NULL,
+                matrix_width INTEGER NOT NULL,
+                matrix_height INTEGER NOT NULL,
+                tile_width INTEGER NOT NULL,
+                tile_height INTEGER NOT NULL,
+                pixel_x_size DOUBLE NOT NULL,
+                pixel_y_size DOUBLE NOT NULL,
+                CONSTRAINT pk_ttm PRIMARY KEY (table_name, zoom_level),
+                CONSTRAINT fk_tmm_table_name
+                    FOREIGN KEY (table_name)
+                    REFERENCES gpkg_contents(table_name)
+            )
+            """
+        )
+
+        self._cursor.execute(
+            f"""
+            CREATE TABLE IF NOT EXISTS "{self.table_name}" (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                zoom_level INTEGER NOT NULL,
+                tile_column INTEGER NOT NULL,
+                tile_row INTEGER NOT NULL,
+                tile_data BLOB NOT NULL,
+                UNIQUE (zoom_level, tile_column, tile_row)
+            )
+            """
+        )
+
+        self._cursor.execute(
+            f"""
+            CREATE INDEX IF NOT EXISTS "{self.table_name}_zxy_idx"
+            ON "{self.table_name}" (zoom_level, tile_column, tile_row)
+            """
+        )
+
+        bb = self.tms.xy_bbox
+
+        self._cursor.execute(
+            """
+            INSERT OR REPLACE INTO gpkg_contents
+            (
+                table_name,
+                data_type,
+                identifier,
+                description,
+                min_x,
+                min_y,
+                max_x,
+                max_y,
+                srs_id
+            )
+            VALUES (?, 'tiles', ?, '', ?, ?, ?, ?, ?)
+            """,
+            (
+                self.table_name,
+                self.table_name,
+                bb.left,
+                bb.bottom,
+                bb.right,
+                bb.top,
+                epsg,
+            ),
+        )
+
+        self._cursor.execute(
+            """
+            INSERT OR REPLACE INTO gpkg_tile_matrix_set
+            (
+                table_name,
+                srs_id,
+                min_x,
+                min_y,
+                max_x,
+                max_y
+            )
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (
+                self.table_name,
+                epsg,
+                bb.left,
+                bb.bottom,
+                bb.right,
+                bb.top,
+            ),
+        )
+
+        self._conn.commit()
+
+    def _ensure_zoom_level(
+        self,
+        z: int,
+    ) -> None:
+        """
+        Add one gpkg_tile_matrix row for a zoom level.
+        """
+
+        tm = self.tms.matrix(z)
+        self._cursor.execute(
+            """
+            INSERT OR IGNORE INTO gpkg_tile_matrix
+            (
+                table_name,
+                zoom_level,
+                matrix_width,
+                matrix_height,
+                tile_width,
+                tile_height,
+                pixel_x_size,
+                pixel_y_size
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                self.table_name,
+                z,
+                tm.matrixWidth,
+                tm.matrixHeight,
+                tm.tileWidth,
+                tm.tileHeight,
+                tm.cellSize,
+                tm.cellSize,
+            ),
+        )
+
+    def _validate_table_name(self) -> None:
+        """Ensure table_name is safe to interpolate into SQL and spec-compliant."""
+        if not _IDENTIFIER_RE.match(self.table_name):
+            raise ValueError(
+                f"Invalid table_name {self.table_name!r}: must match "
+                f"[A-Za-z_][A-Za-z0-9_]* (letters, digits, underscore only, "
+                f"not starting with a digit)."
+            )
+        if self.table_name.lower().startswith("gpkg_"):
+            raise ValueError(
+                f"Invalid table_name {self.table_name!r}: the 'gpkg_' prefix is "
+                f"reserved by the GeoPackage spec."
+            )

geopaktile/xml_parser.py

@@ -0,0 +1,191 @@
+"""Parse OGC WMTS GetCapabilities XML into TileMatrix / TileMatrixSet models."""
+
+from __future__ import annotations
+
+import re
+from xml.etree import ElementTree as ET
+
+import pyproj
+from morecantile.models import CRS, TileMatrix, TileMatrixSet, TMSBoundingBox
+from morecantile.utils import meters_per_unit
+
+NS = {
+    "wmts": "http://www.opengis.net/wmts/1.0",
+    "ows": "http://www.opengis.net/ows/1.1",
+}
+
+# Matches the EPSG code out of any of the common ways a CRS URN/URI is
+# written in WMTS capabilities, e.g.:
+#   "urn:ogc:def:crs:EPSG::27700"
+#   "urn:ogc:def:crs:EPSG:6.3:27700"
+#   "urn:ogc:def:crs:EPSG:6.18:3:3857"   (multiple version/codespace segments)
+#   "EPSG:27700"
+#   "http://www.opengis.net/def/crs/EPSG/0/27700"
+# The middle segment is repeated (*, not ?) since some URN authorities
+# chain more than one version/codespace token before the actual code.
+_EPSG_RE = re.compile(r"EPSG[:/]+(?:[\w.]+[:/]+)*(\d+)\s*$", re.IGNORECASE)
+
+# CRS84 ("urn:ogc:def:crs:OGC:1.3:CRS84") is WGS84 with (lon, lat) axis
+# order
+_CRS84_RE = re.compile(r"\bCRS84\b", re.IGNORECASE)
+
+
+def _parse_crs(crs_text: str) -> str:
+    """Parse a SupportedCRS string into a CRS string pyproj/morecantile accept.
+
+    Returns "OGC:CRS84" for CRS84 and "EPSG:<code>" otherwise.
+    """
+    crs_text = crs_text.strip()
+    if _CRS84_RE.search(crs_text):
+        return "OGC:CRS84"
+
+    match = _EPSG_RE.search(crs_text)
+    if not match:
+        raise ValueError(f"Could not parse EPSG code from SupportedCRS: {crs_text!r}")
+    return f"EPSG:{int(match.group(1))}"
+
+
+def _text(elem: ET.Element, path: str, ns: dict[str, str] = NS) -> str:
+    found = elem.find(path, ns)
+    if found is None or found.text is None:
+        raise ValueError(f"Missing required element {path!r} in {elem.tag}")
+    return found.text.strip()
+
+
+def _text_any_ns(elem: ET.Element, local_name: str) -> str:
+    """Look up a WMTS-namespaced child, tolerating servers that omit the
+    default xmlns declaration and emit bare (no-namespace) element names."""
+    found = elem.find(f"wmts:{local_name}", NS)
+    if found is None:
+        found = elem.find(local_name)
+    if found is None or found.text is None:
+        raise ValueError(f"Missing required element {local_name!r} in {elem.tag}")
+    return found.text.strip()
+
+
+def _parse_tile_matrix(elem: ET.Element, fallback_zoom: int, meters_per_crs_unit: float) -> TileMatrix:
+    """Parse a single <TileMatrix> element.
+
+    The WMTS spec doesn't require ows:Identifier to be an integer zoom
+    level, just a unique label. morecantile requires an integer id, so we
+    try the identifier first and fall back to the element's position in the
+    (already document-ordered) TileMatrixSet.
+
+    pointOfOrigin is kept in the order written in the capabilities (the
+    CRS axis order); TileMatrixSet handles any lat/lon inversion itself.
+    """
+    raw_id = _text(elem, "ows:Identifier")
+    try:
+        zoom_level = int(raw_id)
+    except ValueError:
+        zoom_level = fallback_zoom
+
+    first, second = _text_any_ns(elem, "TopLeftCorner").split()
+    scale_denominator = float(_text_any_ns(elem, "ScaleDenominator"))
+
+    return TileMatrix(
+        id=str(zoom_level),
+        scaleDenominator=scale_denominator,
+        cellSize=scale_denominator * 0.28e-3 / meters_per_crs_unit,
+        cornerOfOrigin="topLeft",
+        pointOfOrigin=(float(first), float(second)),
+        tileWidth=int(_text_any_ns(elem, "TileWidth")),
+        tileHeight=int(_text_any_ns(elem, "TileHeight")),
+        matrixWidth=int(_text_any_ns(elem, "MatrixWidth")),
+        matrixHeight=int(_text_any_ns(elem, "MatrixHeight")),
+    )
+
+
+def _parse_bounding_box(elem: ET.Element) -> TMSBoundingBox | None:
+    """Parse an optional ows:BoundingBox (coordinates in CRS axis order)."""
+    bbox = elem.find("ows:BoundingBox", NS)
+    if bbox is None:
+        return None
+    lower = tuple(float(v) for v in _text(bbox, "ows:LowerCorner").split())
+    upper = tuple(float(v) for v in _text(bbox, "ows:UpperCorner").split())
+    return TMSBoundingBox(lowerLeft=lower, upperRight=upper)  # type: ignore morecantile uses NumType = int | float
+
+
+def parse_tile_matrix_set(elem: ET.Element, swap_xy: bool | None = None) -> TileMatrixSet:
+    """Parse a single <TileMatrixSet> element (found under <Contents>).
+
+    Parameters
+    ----------
+    swap_xy : bool | None
+        Whether TopLeftCorner/BoundingBox coordinates are written as
+        (lat, lon) instead of (lon, lat) / (x, y). If None (default),
+        morecantile infers this from the CRS's axis order (e.g. True for
+        EPSG:4326, False for CRS84). WMTS servers are inconsistent about
+        this in practice, so if your parsed bounds look implausible, try
+        passing the opposite explicitly; this sets the TileMatrixSet's
+        orderedAxes.
+    """
+    identifier = _text(elem, "ows:Identifier")
+    crs_str = _parse_crs(_text(elem, "ows:SupportedCRS"))
+    mpu = meters_per_unit(pyproj.CRS.from_user_input(crs_str))
+
+    tile_matrix_elems = elem.findall("wmts:TileMatrix", NS) or elem.findall("TileMatrix")
+    if not tile_matrix_elems:
+        raise ValueError(f"TileMatrixSet {identifier!r} has no TileMatrix levels")
+
+    tile_matrices = [
+        _parse_tile_matrix(tm_elem, fallback_zoom=i, meters_per_crs_unit=mpu)
+        for i, tm_elem in enumerate(tile_matrix_elems)
+    ]
+    tile_matrices.sort(key=lambda tm: int(tm.id))
+
+    ordered_axes = None if swap_xy is None else (["Y", "X"] if swap_xy else ["X", "Y"])
+
+    return TileMatrixSet(
+        # morecantile restricts ids to [\w\d_-]; keep the original as title.
+        id=re.sub(r"[^\w\-]", "_", identifier),
+        title=identifier,
+        crs=CRS(crs_str),
+        orderedAxes=ordered_axes,
+        boundingBox=_parse_bounding_box(elem),
+        tileMatrices=tile_matrices,
+    )
+
+
+def parse_capabilities(xml_source: str | bytes, swap_xy: bool | None = None) -> list[TileMatrixSet]:
+    """Parse a full WMTS GetCapabilities document into its TileMatrixSets.
+
+    Parameters
+    ----------
+    xml_source : str | bytes
+        The raw GetCapabilities XML, as returned by the WMTS endpoint.
+    swap_xy : bool | None
+        See parse_tile_matrix_set. Applied to every TileMatrixSet found;
+        pass None (default) to auto-detect per-set based on CRS.
+
+    Returns
+    -------
+    list[TileMatrixSet]
+        One entry per <TileMatrixSet> found under <Contents>. A capabilities
+        document commonly advertises several (e.g. one per CRS, or several
+        resolutions of the same CRS) even if you only care about one.
+    """
+    root = ET.fromstring(xml_source)
+    contents = root.find("wmts:Contents", NS)
+    if contents is None:
+        raise ValueError("GetCapabilities document has no <Contents> element")
+
+    tms_elems = contents.findall("wmts:TileMatrixSet", NS)
+    return [parse_tile_matrix_set(elem, swap_xy=swap_xy) for elem in tms_elems]
+
+
+def get_tile_matrix_set(
+    xml_source: str | bytes, identifier: str, swap_xy: bool | None = None
+) -> TileMatrixSet:
+    """Convenience wrapper: parse and return one named TileMatrixSet.
+
+    Raises KeyError if no TileMatrixSet with that identifier is present,
+    listing what was actually found so mismatches (e.g. guessing "2km"
+    when the service calls it "2km_epsg4326") are easy to debug.
+    """
+    all_sets = parse_capabilities(xml_source, swap_xy=swap_xy)
+    for tms in all_sets:
+        if identifier in (tms.id, tms.title):
+            return tms
+    available = [tms.title or tms.id for tms in all_sets]
+    raise KeyError(f"No TileMatrixSet {identifier!r} found. Available: {available}")

geopaktile-2.0.0.dist-info/METADATA

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: GeoPakTile
+Version: 2.0.0
+Summary: Create a Geopackage XYZ Tile layer.
+Keywords: GIS,Geopackage,Tiles,XYZ,gpkg
+Author: apwebber
+Author-email: apwebber <39490780+apwebber@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE.md
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: typing-extensions>=4.0 ; python_full_version < '3.11'
+Requires-Dist: morecantile>=6.2.0
+Requires-Dist: numpy>=2.2.6
+Requires-Dist: requests>=2.34.2
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/apwebber/GeoPakTile
+Project-URL: Documentation, https://github.com/apwebber/GeoPakTile
+Project-URL: Repository, https://github.com/apwebber/GeoPakTile.git
+Project-URL: Issues, https://github.com/apwebber/GeoPakTile/issues
+Description-Content-Type: text/markdown
+
+# GeoPakTile
+
+For writing geopackage XYZ raster tile layers, with support for using arbitrary grid systems.
+
+Geopackage XYZ files can use any tile grid system, this is often defined by a server's GetCapabilities response where a TileMatrixSet defines the data co-ordinate system, the extent, the number of rows and columns in each zoom lever, and the corner co-ordinates for each zoom level. This package contains a tool for parsing the GetCapabilities XML into a [morecantile](https://github.com/developmentseed/morecantile) `TileMatrixSet`, and then for writing tiles to a new or existing geopackage.
+
+## Examples
+
+Write tiles to a new geopackage using web mercator (similar to mbtiles), where tiles is a list of (z, x, y, bytes). `tms` is a morecantile `TileMatrixSet` - the standard web mercator can be obtained with `morecantile.tms.get('WebMercatorQuad')`
+
+```
+# Here, a list of tiles are read from a local path, the bytes and co-ordinates are stored as tuples in a list:
+# You might get these tiles from a tile server or anywhere else. Adjust accordingly.
+
+tiles = [
+    (z, x, y, path.read_bytes()),
+    (z2, x2, y2, path2.read_bytes()),
+    (z3, x3, y3, path3.read_bytes()),
+    ...
+]
+
+with GeoPakTile(test_gpkg, tms=morecantile.tms.get('WebMercatorQuad'), mode='rwc') as gpkg:
+    gpkg.add_tiles(tiles)
+```
+
+Parse a GetCapabilties xml to provide the TileMatrixSet for writing a geopackage:
+
+```
+tms_set = parse_capabilities(xml)
+tms = tms_set[0] # you'll need to know which one you want, or use:
+
+tms = get_tile_matrix_set(xml, identifier = '1km') # an identifier that you know is defined in the xml
+```
+
+
+### TileMatrixSet models
+
+Tile Matrix definitions use the [morecantile](https://github.com/developmentseed/morecantile) package (`morecantile.TileMatrixSet`, `TileMatrix`, etc.) so any morecantile TileMatrixSet (built-in or custom-loaded) can be passed to `GeoPakTile`. The XML parser returns morecantile `TileMatrixSet` objects.
+
+### XML Parser
+
+The xml parser has been tested on NASA GetCapabilties XML and some others, if you come across any that doesn't work then please raise an issue or fix and pull request.
+

geopaktile-2.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+geopaktile/__init__.py,sha256=pon2_W2DtAs6vnxyJyN-Ig4iaNVTyufrfAg8yH0V77s,189
+geopaktile/__main__.py,sha256=MD118vcJhpneDLGbjmErx-_ug1lrjRsZzlmOj0LG8bY,69
+geopaktile/geopaktile.py,sha256=wT5jX0XKRzyixLOfvJY358Nm0IUHwtaau_DylCoPw9g,14380
+geopaktile/xml_parser.py,sha256=eNEbJtHo885F5cQmAKPBOci7fz7f4E7D1z_jvTOCPKo,7791
+geopaktile-2.0.0.dist-info/licenses/LICENSE.md,sha256=l_OJCOs5Hli7ri30MKfXMFO58k8juM3sT1aTvR3fRBM,1085
+geopaktile-2.0.0.dist-info/WHEEL,sha256=M4DeIjVCA49okfALADZoWX5JOGwnmHb-JOpQHtI-1c0,80
+geopaktile-2.0.0.dist-info/entry_points.txt,sha256=cNf1TFW8KuDXF6Mmi424dwlTm2pq5NLg-sntV37tePs,48
+geopaktile-2.0.0.dist-info/METADATA,sha256=ZFKdaaUJzJZAWu9g0VhsJH8U4mmzWyD5XIukI2hJFjg,3238
+geopaktile-2.0.0.dist-info/RECORD,,

geopaktile-2.0.0.dist-info/WHEEL

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

geopaktile-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+geopaktile = geopaktile:main
+

geopaktile-2.0.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Alex Webber
+
+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.