tilegrab 1.1.0__py3-none-any.whl

tilegrab/mosaic.py

@@ -0,0 +1,75 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List
+from PIL import Image
+import re
+import os
+
+from tilegrab.tiles import TileCollection
+
+
+class Mosaic:
+
+    def __init__(
+        self, directory: str = "saved_tiles", ext: str = ".png", recursive: bool = False
+    ):
+        self.directory = directory
+        self.ext = ext
+        self.recursive = recursive
+
+        self.image_col = self._get_images()
+        assert len(self.image_col) > 0
+
+        pat = re.compile(
+            r"^([0-9]+)_([0-9]+)_([0-9]+)\.[A-Za-z0-9]+$"
+        )
+        self.image_data = {}
+
+        for i in self.image_col:
+            m = pat.match(os.path.basename(str(i)))
+            if m:
+                first = m.group(1)
+                second = m.group(2)
+                third = m.group(3)
+
+                self.image_data[i] = [int(second), int(third), int(first)]
+
+        assert len(self.image_data.keys()) > 0
+
+        print(f"Processing {len(self.image_data.keys())} tiles...")
+
+    def _get_images(self) -> List[Path]:
+
+        directory = Path(self.directory)
+        ext = self.ext
+
+        if not ext.startswith("."):
+            ext = "." + self.ext
+
+        if self.recursive:
+            return [p for p in directory.rglob(f"*{ext}") if p.is_file()]
+        else:
+            return [p for p in directory.glob(f"*{ext}") if p.is_file()]
+
+    def merge(self, tiles: TileCollection, tile_size: int = 256):
+
+        img_w = int((tiles.MAX_X - tiles.MIN_X + 1) * tile_size)
+        img_h = int((tiles.MAX_Y - tiles.MIN_Y + 1) * tile_size)
+        print(f"Image size: {img_w}x{img_h}")
+
+        merged_image = Image.new("RGB", (img_w, img_h))
+
+        for img_path, img_id in self.image_data.items():
+            x, y, _ = img_id
+
+            print(x - tiles.MIN_X + 1, "x" ,y - tiles.MIN_Y + 1)
+
+            img = Image.open(img_path)
+            img.load()
+
+            px = int((x - tiles.MIN_X) * tile_size)
+            py = int((y - tiles.MIN_Y) * tile_size)
+
+            merged_image.paste(img, (px, py))
+
+        merged_image.save(os.path.join(self.directory, "merged_output.png"))

tilegrab/sources.py

@@ -0,0 +1,62 @@
+import logging
+from typing import Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+class TileSource:
+    URL_TEMPLATE = ""
+    name = None
+
+    def __init__(
+        self, 
+        api_key: Optional[str] = None, 
+        headers: Optional[Dict[str, str]] = None
+    ) -> None:
+        self._headers = headers
+        self.api_key = api_key
+        logger.debug(f"Initializing TileSource: {self.name}, has_api_key={api_key is not None}")
+
+    def get_url(self, z: int, x: int, y: int) -> str:
+        url = self.URL_TEMPLATE.format(x=x, y=y, z=z)
+        logger.debug(f"Generated URL for {self.name}: z={z}, x={x}, y={y}")
+        return url
+
+    def headers(self) -> Dict[str, str]:
+        return self._headers or {
+            "referer": "",
+            "accept": "*/*",
+            "user-agent": "Mozilla/5.0 QGIS/34202/Windows 11 Version 2009",
+            "connection": "Keep-Alive ",
+            "accept-encoding": "gzip, deflate",
+            "accept-language": "en-US,*",
+        }
+
+
+class GoogleSat(TileSource):
+    name = "GoogleSat"
+    description = "Google satellite imageries"
+    URL_TEMPLATE = "https://mt1.google.com/vt/lyrs=s&x={x}&y={y}&z={z}"
+    
+
+class OSM(TileSource):
+    name = "OSM"
+    description = "OpenStreetMap imageries"
+    URL_TEMPLATE = "https://tile.openstreetmap.org/{z}/{x}/{y}.png"
+
+class ESRIWorldImagery(TileSource):
+    name = "ESRIWorldImagery"
+    description = "ESRI satellite imageries"
+    URL_TEMPLATE = "https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}"
+
+class Nearmap(TileSource):
+    name = "NearmapSat"
+    description = "Nearmap satellite imageries"
+    URL_TEMPLATE = "https://api.nearmap.com/tiles/v3/Vert/{z}/{x}/{y}.png?apikey={token}"
+
+    def get_url(self, z: int, x: int, y: int) -> str:
+        if not self.api_key:
+            logger.error("Nearmap API key is required but not provided")
+            raise AssertionError("API key required for Nearmap")
+        url = self.URL_TEMPLATE.format(x=x, y=y, z=z, token=self.api_key)
+        logger.debug(f"Generated Nearmap URL: z={z}, x={x}, y={y}")
+        return url

tilegrab/tiles.py

@@ -0,0 +1,179 @@
+import logging
+import math
+from typing import Any, List, Tuple
+import mercantile
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Union
+from .dataset import GeoDataset
+from box import Box
+
+logger = logging.getLogger(__name__)
+
+@dataclass
+class Tile:
+    x: int = 0
+    y: int = 0
+    z: int = 0
+
+    def __post_init__(self):
+        self._position = None
+        logger.debug(f"Tile created: z={self.z}, x={self.x}, y={self.y}")
+
+    # @classmethod
+    # def from_tuple(cls, t: tuple[int, int, int]) -> "Tile":
+    #     logger.debug(f"Creating Tile from tuple: {t}")
+    #     return cls(*t)
+    
+    @property
+    def url(self) -> Union[str, None]:
+        return self._url
+
+    @url.setter
+    def url(self, value: str):
+        logger.debug(f"Tile URL set for z={self.z},x={self.x},y={self.y}")
+        self._url = value
+
+    @property
+    def position(self) -> Box:
+        if self._position is None:
+            logger.error(f"Tile position not set: z={self.z}, x={self.x}, y={self.y}")
+            raise RuntimeError("Image does not have an position")
+        return self._position
+
+    @position.setter
+    def position(self, value: Tuple[float, float]):
+        x, y = self.x - value[0], self.y - value[1]
+        self._position = Box({'x': x, 'y': y})
+        logger.debug(f"Tile position calculated: x={x}, y={y}")
+
+class TileCollection(ABC):
+    
+    MIN_X: float = 0
+    MAX_X: float = 0
+    MIN_Y: float = 0
+    MAX_Y: float = 0
+    _cache: Union[List[Tile], None] = None
+
+    @abstractmethod
+    def _build_tile_cache(self) -> list[Tile]:
+        raise NotImplementedError
+
+    def __len__(self):
+        return sum(1 for _ in self)
+
+    def __iter__(self):
+        for t in self._cache:  # type: ignore
+            yield t.z, t.x, t.y
+
+    def __init__(self, feature: GeoDataset, zoom: int, SAFE_LIMIT: int = 250):
+        self.zoom = zoom
+        self.SAFE_LIMIT = SAFE_LIMIT
+        self.feature = feature
+
+        logger.info(f"Initializing TileCollection: zoom={zoom}, safe_limit={SAFE_LIMIT}")
+
+        assert feature.bbox.minx < feature.bbox.maxx
+        assert feature.bbox.miny < feature.bbox.maxy
+
+        self._build_tile_cache()
+        self._update_min_max()
+        
+        if len(self) > SAFE_LIMIT:
+            logger.error(f"Tile count exceeds safe limit: {len(self)} > {SAFE_LIMIT}")
+            raise ValueError(
+                f"Your query excedes the hard limit {len(self)} > {SAFE_LIMIT}"
+            )
+        
+        logger.info(f"TileCollection initialized with {len(self)} tiles")
+
+    def __repr__(self) -> str:
+        return f"TileCollection; len={len(self)}; x-extent=({self.feature.bbox.minx}-{self.feature.bbox.maxx}); y-extent=({self.feature.bbox.miny}-{self.feature.bbox.maxy})"
+
+    def tile_bounds(self, x, y, z) -> Tuple[float, float, float, float]:
+        n = 2**z
+
+        lon_min = x / n * 360.0 - 180.0
+        lon_max = (x + 1) / n * 360.0 - 180.0
+
+        lat_min = math.degrees(math.atan(math.sinh(math.pi * (1 - 2 * (y + 1) / n))))
+        lat_max = math.degrees(math.atan(math.sinh(math.pi * (1 - 2 * y / n))))
+
+        logger.debug(f"Tile bounds calculated for z={z},x={x},y={y}: ({lon_min},{lat_min},{lon_max},{lat_max})")
+        return lon_min, lat_min, lon_max, lat_max
+
+    @property
+    def to_list(self) -> list[Tile]:
+        if self._cache is None:
+            logger.debug("Building tile cache from to_list property")
+            self._build_tile_cache()
+            self._update_min_max()
+            if len(self) > self.SAFE_LIMIT:
+                logger.error(f"Tile count exceeds safe limit in to_list: {len(self)} > {self.SAFE_LIMIT}")
+                raise ValueError("Too many tiles")
+        
+        assert self._cache
+        return self._cache
+
+    def _update_min_max(self):
+        assert self._cache
+        x = [t.x for t in self._cache]
+        y = [t.y for t in self._cache]
+        self.MAX_X, self.MIN_X = max(x), min(x)
+        self.MAX_Y, self.MIN_Y = max(y), min(y)
+
+        logger.info(f"TileCollection bounds: x=({self.MIN_X}, {self.MAX_X}) y=({self.MIN_Y}, {self.MAX_Y})")
+
+        for i in range(len(self._cache)):
+            self._cache[i].position = self.MIN_X, self.MIN_Y
+
+class TilesByBBox(TileCollection):
+    
+    def _build_tile_cache(self) -> list[Tile]:
+        logger.info(f"Building tiles by bounding box at zoom level {self.zoom}")
+        bbox = self.feature.bbox
+        logger.debug(f"BBox coordinates: minx={bbox.minx}, miny={bbox.miny}, maxx={bbox.maxx}, maxy={bbox.maxy}")
+        
+        self._cache = [
+            Tile(t.x, t.y, t.z)
+            for t in mercantile.tiles(
+                bbox.minx,
+                bbox.miny,
+                bbox.maxx,
+                bbox.maxy,
+                self.zoom,
+            )
+        ]
+        
+        logger.debug(f"Generated {len(self._cache)} tiles from bounding box")
+        return self._cache
+
+class TilesByShape(TileCollection):
+
+    def _build_tile_cache(self) -> list[Tile]:
+        from shapely.geometry import box
+
+        logger.info(f"Building tiles by shape intersection at zoom level {self.zoom}")
+        geometry = self.feature.shape
+        if hasattr(geometry, "geometry"):
+            geometry = geometry.geometry.unary_union
+            logger.debug("Converted GeoDataFrame geometry to unary_union")
+
+        tiles = []
+        bbox = self.feature.bbox
+        logger.debug(f"Checking tiles within bbox: minx={bbox.minx}, miny={bbox.miny}, maxx={bbox.maxx}, maxy={bbox.maxy}")
+        
+        for t in mercantile.tiles(
+            bbox.minx,
+            bbox.miny,
+            bbox.maxx,
+            bbox.maxy,
+            self.zoom,
+        ):
+            tb = box(*self.tile_bounds(t.x, t.y, t.z))
+            if tb.intersects(geometry):
+                tiles.append(Tile(t.x, t.y, t.z))
+        
+        self._cache = tiles
+        logger.info(f"Generated {len(tiles)} tiles from shape intersection")
+        return tiles

tilegrab-1.1.0.dist-info/METADATA

@@ -0,0 +1,375 @@
+Metadata-Version: 2.4
+Name: tilegrab
+Version: 1.1.0
+Summary: Fast geospatial map tile downloader and mosaicker
+Author: Thiwanka Munasinghe
+License-Expression: MIT
+Project-URL: Changelog, https://github.com/thiwaK/tilegrab
+Project-URL: Contact, https://github.com/thiwaK
+Project-URL: Homepage, https://github.com/thiwaK/tilegrab
+Project-URL: Source, https://github.com/thiwaK/tilegrab
+Project-URL: Tracker, https://github.com/thiwaK/tilegrab/issues
+Keywords: tilegrab,Tilegrab,TileGrab,tileGrab
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: mercantile
+Requires-Dist: pillow
+Requires-Dist: tqdm
+Requires-Dist: python-box
+Requires-Dist: geopandas
+Requires-Dist: pyproj
+Requires-Dist: shapely
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: mock; extra == "dev"
+Requires-Dist: tox; extra == "dev"
+Dynamic: license-file
+
+
+<div align="center">
+    <h1 align="center">TileGrab 🧩</h1>
+    <!-- until publish on PyPi -->
+    <img alt="TileGrab" src="https://img.shields.io/badge/testpypi-1.0.0-blue">
+    <!-- <img alt="TileGrab" src="https://img.shields.io/pypi/v/tilegrab.svg"> -->
+    <img alt="TileGrab - Python Versions" src="https://img.shields.io/badge/python-3.9%20|%203.10%20|%203.11|%203.12|%203.13-blue">
+    <!-- <img alt="TileGrab - Python Versions" src="https://img.shields.io/pypi/pyversions/tilegrab.svg"> -->
+    <!--  -->
+    <img alt="Test Status" src="https://img.shields.io/github/actions/workflow/status/thiwaK/tilegrab/test.yml?branch=main&event=push&style=flat&label=test">
+    <br/>
+    <br/>
+</div>
+
+
+**Fast, scriptable map tile downloader and mosaicker for geospatial workflows.**
+
+
+`tilegrab` downloads raster map tiles from common providers (OSM, Google Satellite, ESRI World Imagery) using a **vector extent** (polygon or bounding box), then optionally mosaics them into a single raster. Built for automation, reproducibility, and real GIS work — not GUI clicking.
+
+---
+
+<!-- <p align="center">
+  <picture align="center">
+    <source media="(prefers-color-scheme: dark)" srcset="https://github.com/astral-sh/uv/assets/1309177/03aa9163-1c79-4a87-a31d-7a9311ed9310">
+    <source media="(prefers-color-scheme: light)" srcset="https://github.com/astral-sh/uv/assets/1309177/629e59c0-9c6e-4013-9ad4-adb2bcf5080d">
+    <img alt="Shows a bar chart with benchmark results." src="https://github.com/astral-sh/uv/assets/1309177/629e59c0-9c6e-4013-9ad4-adb2bcf5080d">
+  </picture>
+</p> -->
+
+
+## Why tilegrab?
+
+Most tile downloaders fall into one of two traps:
+- GUI tools that don’t scale or automate
+- Scripts that only support bounding boxes and break on real geometries
+
+`tilegrab` is different:
+
+- Uses **actual vector geometries**, not just extents  
+- Clean CLI, easy to script and integrate  
+- Works with **Shapefiles, GeoPackages, GeoJSON**  
+- Supports **download-only**, **mosaic-only**, or full pipelines  
+- Designed for **GIS, remote sensing, and map production workflows**
+
+No magic. No black boxes.
+
+---
+
+## Features
+
+- Vector-driven tile selection  
+  - Exact geometry-based tile filtering  
+  - Or fast bounding-box-based selection  
+- Multiple tile providers  
+  - OpenStreetMap  
+  - Google Satellite  
+  - ESRI World Imagery  
+- Automatic tile mosaicking  
+- Progress reporting (optional)  
+- API-key support where required  
+- Sensible defaults, strict CLI validation  
+
+---
+
+## Installation
+
+### From TestPyPI
+
+```bash
+  pip install -i https://test.pypi.org/simple/tilegrab
+````
+
+> [!NOTE]
+> A stable PyPI release will follow once the API is finalized.
+
+---
+
+## Quick Start
+
+### Download and mosaic tiles using a polygon
+
+```bash
+tilegrab \
+  --source boundary.shp \
+  --shape \
+  --osm \
+  --zoom 16
+```
+
+### Use bounding box instead of exact geometry
+
+```bash
+tilegrab \
+  --source boundary.geojson \
+  --bbox \
+  --esri_sat \
+  --zoom 17
+```
+
+---
+
+## CLI Usage
+
+```bash
+usage: tilegrab [-h] --source SOURCE (--shape | --bbox) (--osm | --google_sat | --esri_sat | --key KEY) --zoom ZOOM [--out OUT] [--download-only] [--mosaic-only] [--no-progress] [--quiet]
+
+Download and mosaic map tiles
+
+options:
+  -h, --help       show this help message and exit
+  --zoom ZOOM      Zoom level (integer)
+  --out OUT        Output directory (default: ./saved_tiles)
+  --download-only  Only download tiles; do not run mosaicking or postprocessing
+  --mosaic-only    Only mosaic tiles; do not download
+  --no-progress    Hide download progress bar
+  --quiet          Hide all prints
+
+Source options(Extent):
+  Options for the vector polygon source
+
+  --source SOURCE  The vector polygon source for filter tiles
+  --shape          Use actual shape to derive tiles
+  --bbox           Use shape's bounding box to derive tiles
+
+Source options(Map tiles):
+  Options for the map tile source
+
+  --osm            OpenStreetMap
+  --google_sat     Google Satellite
+  --esri_sat       ESRI World Imagery
+  --key KEY        API key where required by source
+```
+
+---
+<!-- 
+## Required Arguments
+
+| Argument   | Description                               |
+| ---------- | ----------------------------------------- |
+| `--source` | Vector dataset used to derive tile extent |
+| `--shape`  | Use exact geometry to select tiles        |
+| `--bbox`   | Use geometry bounding box                 |
+| `--zoom`   | Web map zoom level                        |
+
+---
+
+## Tile Sources (CLI)
+
+| Flag           | Source             |
+| -------------- | ------------------ |
+| `--osm`        | OpenStreetMap      |
+| `--google_sat` | Google Satellite   |
+| `--esri_sat`   | ESRI World Imagery |
+
+Optional API key:
+
+```bash
+--key YOUR_API_KEY
+```
+
+---
+
+## Output & Processing Options
+
+| Option            | Description                                 |
+| ----------------- | ------------------------------------------- |
+| `--out <dir>`     | Output directory (default: `./saved_tiles`) |
+| `--download-only` | Download tiles only                         |
+| `--mosaic-only`   | Mosaic existing tiles only                  |
+| `--no-progress`   | Disable progress bar                        |
+| `--quiet`         | Suppress console output                     |
+
+--- 
+-->
+
+## Supported Vector Formats
+
+Any format readable by **GeoPandas**, including:
+
+* Shapefile (`.shp`)
+* GeoPackage (`.gpkg`)
+* GeoJSON (`.geojson`)
+* Spatial databases (via supported drivers)
+
+---
+
+## Custom Tile Sources (Bring Your Own Provider)
+
+`tilegrab` is **not limited** to built-in providers.
+
+If a tile service follows the standard `{z}/{x}/{y}` pattern, you can add it in **one small class** by extending `TileSource`.
+
+No registration. No plugin system. No magic.
+
+---
+
+### Example
+
+```python
+from tilegrab.sources import TileSource
+
+class MyCustomSource(TileSource):
+    name = "MyCustomSource name"
+    description = "MyCustomSource description"
+    URL_TEMPLATE = "https://MyCustomSource/{z}/{x}/{y}.png"
+```
+
+That’s it.
+
+Once instantiated, the source works exactly like built-in providers.
+
+---
+
+
+### get_url Function
+
+You can change how the url is generate by override `get_url` function, inside your Custom Tile Sources. If you are planning to use API key, you must override this function.
+
+```python
+def get_url(self, z: int, x: int, y: int) -> str:
+  assert self.api_key
+  return self.URL_TEMPLATE.format(x=x, y=y, z=z, token=self.api_key)
+```
+
+### URL Template Rules
+
+Your tile source **must** define:
+
+* `URL_TEMPLATE`
+  Must contain `{z}`, `{x}`, `{y}` placeholders.
+
+Optional but recommended:
+
+* `name` – Human-readable name
+* `description` – Short description of the imagery
+
+Example templates:
+
+```text
+https://server/{z}/{x}/{y}.png
+https://tiles.example.com/{z}/{x}/{y}.jpg
+https://api.provider.com/tiles/{z}/{x}/{y}?key={token}
+```
+
+---
+
+### API Keys
+
+If your provider requires an API key, pass it during instantiation:
+
+```python
+source = MyCustomSource(api_key="YOUR_KEY")
+```
+
+`TileSource` already handles key injection — you don’t need to reinvent it.
+
+---
+
+
+### Using a Custom Source in Code
+
+Custom sources are intended for **programmatic use** (not CLI flags):
+
+```python
+from tilegrab.downloader import Downloader
+from tilegrab.tiles import TilesByShape
+from tilegrab.dataset import GeoDataset
+
+dataset = GeoDataset("area.gpkg")
+tiles = TilesByShape(dataset, zoom=16)
+
+source = MyCustomSource(api_key="XYZ")
+downloader = Downloader(tiles, source, "output")
+downloader.run()
+```
+
+This keeps the CLI clean while giving developers full control.
+
+---
+
+### Why This Design?
+
+* Zero configuration overhead
+* No registry or plugin boilerplate
+* Easy to vendor in private or internal tile servers
+* Safe default for public CLI usage
+
+If you need full flexibility, use the Python API.
+
+---
+
+## Project Structure
+
+```text
+tilegrab/
+├── cli.py          # CLI entry point
+├── dataset.py      # Vector dataset handling
+├── tiles.py        # Tile calculation logic
+├── downloader.py   # Tile download engine
+├── mosaic.py       # Tile mosaicking
+└── sources.py      # Tile providers
+```
+
+---
+
+## Who This Is For
+
+* GIS analysts automating basemap generation
+* Remote sensing workflows needing tiled imagery
+* Developers building spatial data pipelines
+* Anyone tired of manual tile grabbing
+
+If you want a GUI, this isn’t it.
+If you want control, repeatability, and speed — it is.
+
+---
+
+## Roadmap
+
+Planned (not promises):
+
+* Additional tile providers
+* Parallel download tuning
+* Cloud-optimized raster output
+* Raster reprojection and resampling options
+* Expanded Python API documentation
+
+---
+
+## License
+
+MIT License.
+Do whatever you want — just don’t pretend you wrote it.
+
+---
+
+## Author
+
+**Thiwanka Munasinghe**
+GitHub: [https://github.com/thiwaK](https://github.com/thiwaK)
+
+```
+```

tilegrab-1.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+tilegrab/__init__.py,sha256=0L3afZyDycCUGuBO0w7DQ9fOd798dUyinbGsM77aQOg,289
+tilegrab/__main__.py,sha256=wT62aXCuN7iwRPQoswnmeGiBS5Cou0CIBvMxbOTfvFs,33
+tilegrab/cli.py,sha256=4AxEpxBhl8REUFAc7Dqa-bCxCo5oUNJGZ1Om3QnTHV0,7700
+tilegrab/dataset.py,sha256=dNZ52mTkX_FC4e-hKAdEsvL5JVeo-MXhhAHpxKjwyGE,2525
+tilegrab/downloader.py,sha256=ge3o4PS0v3_npaiOvFmlNSx62VqL8nwjcefy4Jr_UQo,5120
+tilegrab/images.py,sha256=rld-BLuGA8LPcq0QbGsVY48mbMRivvzxdyfAwVfe0dk,7466
+tilegrab/mosaic.py,sha256=H2-Mr2j9AmwSicPGwYE5z5t0wdAfj2m42J0G7IxE0zA,2191
+tilegrab/sources.py,sha256=GzldtFGndziw9NNB1YMG4WUrD0fTRET1FjGCfIMMDlQ,2188
+tilegrab/tiles.py,sha256=WEWv96fCeHlZs_Gxzg0m3wYAy_qsHfAwkCQHcWEFwf4,6137
+tilegrab-1.1.0.dist-info/licenses/LICENSE,sha256=bcZProekTTcPtnEpRKB2i1kUJ6ujlaxBZchNWKeoXc8,1094
+tilegrab-1.1.0.dist-info/METADATA,sha256=ddmKHnd5A9LaTsjOIxSics7kovf_AXKC92bN3rrhdYY,10197
+tilegrab-1.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tilegrab-1.1.0.dist-info/entry_points.txt,sha256=z-WoKN8NnA5_ZsWXucSeq-r4TeEscu0xjWYu560uNTk,47
+tilegrab-1.1.0.dist-info/top_level.txt,sha256=lVio8bCk3r4Bu_INLgaj4PZCrhFY2UcxHjnFBdHwyPo,9
+tilegrab-1.1.0.dist-info/RECORD,,