tilegrab 1.1.0__py3-none-any.whl → 1.2.0b2__py3-none-any.whl

tilegrab/tiles.py

@@ -1,15 +1,18 @@
 import logging
 import math
-from typing import Any, List, Tuple
-import mercantile
+from typing import Iterator, List, Tuple, Union
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Union
 from .dataset import GeoDataset
 from box import Box
+from functools import cache
 
 logger = logging.getLogger(__name__)
 
+EPSILON = 1e-14
+LL_EPSILON = 1e-11
+
+
 @dataclass
 class Tile:
     x: int = 0
@@ -18,13 +21,13 @@ class Tile:
 
     def __post_init__(self):
         self._position = None
-        logger.debug(f"Tile created: z={self.z}, x={self.x}, y={self.y}")
+        logger.debug(f"Tile created: x={self.x}, y={self.y}, z={self.z}")
 
     # @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
@@ -38,59 +41,67 @@ class Tile:
     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")
+            raise RuntimeError("Image does not have a 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})
+        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
+    _cache: List[Tile]
+    _tile_count: int = 0
 
     @abstractmethod
-    def _build_tile_cache(self) -> list[Tile]:
+    def _build_tile_cache(self) -> List[Tile]:
         raise NotImplementedError
 
     def __len__(self):
-        return sum(1 for _ in self)
+        return self._tile_count
 
     def __iter__(self):
-        for t in self._cache:  # type: ignore
-            yield t.z, t.x, t.y
+        for t in self._cache:
+            yield t
 
-    def __init__(self, feature: GeoDataset, zoom: int, SAFE_LIMIT: int = 250):
+    def __init__(self, 
+        geo_dataset: GeoDataset, 
+        zoom: int, 
+        SAFE_LIMIT: int = 250
+    ):
         self.zoom = zoom
         self.SAFE_LIMIT = SAFE_LIMIT
-        self.feature = feature
+        self.geo_dataset = geo_dataset
 
-        logger.info(f"Initializing TileCollection: zoom={zoom}, safe_limit={SAFE_LIMIT}")
+        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
+        assert geo_dataset.bbox.minx < geo_dataset.bbox.maxx
+        assert geo_dataset.bbox.miny < geo_dataset.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})"
+        return f"TileCollection; len={len(self)}; x-extent=({self.geo_dataset.bbox.minx}-{self.geo_dataset.bbox.maxx}); y-extent=({self.geo_dataset.bbox.miny}-{self.geo_dataset.bbox.maxy})"
 
-    def tile_bounds(self, x, y, z) -> Tuple[float, float, float, float]:
+    def tile_bounds(self, tile: Union[Tile, Box]) -> Tuple[float, float, float, float]:
+        x, y, z = tile.x, tile.y, tile.z
         n = 2**z
 
         lon_min = x / n * 360.0 - 180.0
@@ -99,81 +110,156 @@ class TileCollection(ABC):
         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})")
+        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:
+    @cache
+    def to_list(self) -> List[Tile]:
+        cache = list(self._cache)
+        if cache is None or len(cache) < 1:
             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}")
+                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
+        return list(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)
+    def tile_bbox_geojson(self, x: int, y: int, z: int) -> dict:
+        min_lon, min_lat, max_lon, max_lat = self.tile_bbox(x, y, z)
+        return {
+            "type": "Polygon",
+            "coordinates": [[
+                [min_lon, min_lat],
+                [min_lon, max_lat],
+                [max_lon, max_lat],
+                [max_lon, min_lat],
+                [min_lon, min_lat]
+            ]]
+        }
+
+    def tile_bbox(self, x: int, y: int, z: int) -> Tuple[float, float, float, float]:
+        """
+        Return bounding box of a Slippy Map tile as (min_lon, min_lat, max_lon, max_lat).
+        x, y are tile indices at zoom z.
+        """
+        n = 2.0 ** z
+        min_lon = x / n * 360.0 - 180.0
+        max_lon = (x + 1) / n * 360.0 - 180.0
+
+        def tile_y_to_lat(yt: float) -> float:
+            # convert fractional tile y to latitude in degrees
+            merc_y = math.pi * (1 - 2 * yt / n)
+            lat_rad = math.atan(math.sinh(merc_y))
+            return math.degrees(lat_rad)
+
+        max_lat = tile_y_to_lat(y)        # top edge (smaller y => larger lat)
+        min_lat = tile_y_to_lat(y + 1)    # bottom edge
+
+        return (min_lon, min_lat, max_lon, max_lat)
+
+    def _tiles_in_bounds(self, clip_to_shape=False) -> Iterator[Tile]:
+        
+        bbox = self.geo_dataset.bbox
+
+        def tile(lng, lat, zoom):
+            logger.debug(f"Creating new Tile; lat={lat}; lng={lng}")
 
-        logger.info(f"TileCollection bounds: x=({self.MIN_X}, {self.MAX_X}) y=({self.MIN_Y}, {self.MAX_Y})")
+            x = lng / 360.0 + 0.5
+            sinlat = math.sin(math.radians(lat))
+
+            try:
+                y = 0.5 - 0.25 * math.log((1.0 + sinlat) / (1.0 - sinlat)) / math.pi
+            except:
+                raise
+
+            Z2 = math.pow(2, zoom)
+
+            if x <= 0:
+                xtile = 0
+            elif x >= 1:
+                xtile = int(Z2 - 1)
+            else:
+                # To address loss of precision in round-tripping between tile
+                # and lng/lat, points within EPSILON of the right side of a tile
+                # are counted in the next tile over.
+                xtile = int(math.floor((x + EPSILON) * Z2))
+
+            if y <= 0:
+                ytile = 0
+            elif y >= 1:
+                ytile = int(Z2 - 1)
+            else:
+                ytile = int(math.floor((y + EPSILON) * Z2))
+
+            
+            return Box({"x": xtile, "y": ytile})
+
+        w, s, e, n = bbox.minx, bbox.miny, bbox.maxx, bbox.maxy
+        if s < -85.051129 or n > 85.051129:
+            logger.warning("Your geometry bounds exceed the Web Mercator's limits")
+            logger.info("Clipping bounds for Web Mercator's limits")
+
+            w = max(-180.0, w)
+            s = max(-85.051129, s)
+            e = min(180.0, e)
+            n = min(85.051129, n)
+
+        ul_tile = tile(w, n, self.zoom)
+        lr_tile = tile(e - LL_EPSILON, s + LL_EPSILON, self.zoom)
+        logger.debug(f"UpperLeft Tile=({ul_tile}); LowerRight Tile=({lr_tile})")
+
+        self._tile_count = 0
+        self.MAX_X, self.MIN_X = lr_tile.x, ul_tile.x
+        self.MAX_Y, self.MIN_Y = lr_tile.y, ul_tile.y
+        logger.info(
+            f"TileCollection bounds: x=({self.MIN_X}, {self.MAX_X}) y=({self.MIN_Y}, {self.MAX_Y})"
+        )
+
+        for i in range(ul_tile.x, lr_tile.x + 1):
+            for j in range(ul_tile.y, lr_tile.y + 1):
+                if clip_to_shape:
+                    from shapely.geometry import box
+                    tb = box(*self.tile_bbox(i,j,self.zoom))
+                    if not tb.intersects(self.geo_dataset.shape.geometry).any():
+                        logger.debug(f"Tile excluded: z={self.zoom}, x={i}, y={j}")
+                        continue
+                self._tile_count += 1
+                t = Tile(i, j, self.zoom)
+                t.position = self.MIN_X, self.MIN_Y
+                yield t
 
-        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]:
+
+    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")
+        bbox = self.geo_dataset.bbox
+        logger.debug(
+            f"BBox coordinates: minx={bbox.minx}, miny={bbox.miny}, maxx={bbox.maxx}, maxy={bbox.maxy}"
+        )
+
+        self._cache = list(self._tiles_in_bounds(True))
+        logger.debug(f"Generated {len(self)} tiles from bounding box")
         return self._cache
 
+
 class TilesByShape(TileCollection):
 
-    def _build_tile_cache(self) -> list[Tile]:
-        from shapely.geometry import box
+    def _build_tile_cache(self) -> List[Tile]:
 
         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
+        bbox = self.geo_dataset.bbox
+        logger.debug(
+            f"Checking tiles within bbox: minx={bbox.minx}, miny={bbox.miny}, maxx={bbox.maxx}, maxy={bbox.maxy}"
+        )
+
+        self._cache = list(self._tiles_in_bounds(True))
+        logger.info(f"Generated {len(self)} tiles from shape intersection")
+        return self._cache

{tilegrab-1.1.0.dist-info → tilegrab-1.2.0b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilegrab
-Version: 1.1.0
+Version: 1.2.0b2
 Summary: Fast geospatial map tile downloader and mosaicker
 Author: Thiwanka Munasinghe
 License-Expression: MIT
@@ -14,7 +14,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests
-Requires-Dist: mercantile
+Requires-Dist: rasterio
 Requires-Dist: pillow
 Requires-Dist: tqdm
 Requires-Dist: python-box
@@ -32,13 +32,13 @@ 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">
+    <img alt="TileGrab" src="https://img.shields.io/pypi/v/tilegrab.svg">
+    <img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/tilegrab.svg">
+    <img alt="PyPI - Wheel" src="https://img.shields.io/pypi/wheel/tilegrab">
+    <img alt="Test Status" src="https://img.shields.io/github/actions/workflow/status/thiwaK/tilegrab/test.yml?branch=main&event=push&style=flat&label=CI">
+    <img alt="PyPI - Implementation" src="https://img.shields.io/pypi/implementation/tilegrab">
+    <img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/thiwaK/tilegrab">
+    <img alt="GitHub License" src="https://img.shields.io/github/license/thiwaK/tilegrab">
     <br/>
     <br/>
 </div>
@@ -47,7 +47,7 @@ Dynamic: license-file
 **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.
+`tilegrab` downloads raster map tiles from common providers (OSM, Google Satellite, ESRI World Imagery) using a **vector extent** (polygon shape or bounding box), then optionally mosaics them into a single or multiple rasters.
 
 ---
 
@@ -62,20 +62,19 @@ Dynamic: license-file
 
 ## Why tilegrab?
 
-Most tile downloaders fall into one of two traps:
+Most tile downloaders have two major drawbacks:
 - 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  
+- Uses **actual vector geometries**, not only just extents 
+- Scalable API
 - Clean CLI, easy to script and integrate  
 - Works with **Shapefiles, GeoPackages, GeoJSON**  
-- Supports **download-only**, **mosaic-only**, or full pipelines  
+- Supports **download-only**, **mosaic-only** or full pipelines  
 - Designed for **GIS, remote sensing, and map production workflows**
 
-No magic. No black boxes.
-
 ---
 
 ## Features
@@ -86,8 +85,9 @@ No magic. No black boxes.
 - Multiple tile providers  
   - OpenStreetMap  
   - Google Satellite  
-  - ESRI World Imagery  
-- Automatic tile mosaicking  
+  - ESRI World Imagery
+  - or Custom providers
+- Tile mosaicking 
 - Progress reporting (optional)  
 - API-key support where required  
 - Sensible defaults, strict CLI validation  
@@ -98,12 +98,15 @@ No magic. No black boxes.
 
 ### From TestPyPI
 
+#### Stable version
 ```bash
-  pip install -i https://test.pypi.org/simple/tilegrab
+  pip install -i tilegrab
 ````
 
-> [!NOTE]
-> A stable PyPI release will follow once the API is finalized.
+#### Beta version
+```bash
+  pip install tilegrab==1.2.0b2
+````
 
 ---
 
@@ -134,76 +137,55 @@ tilegrab \
 ## 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]
+usage: tilegrab [-h] --source SOURCE (--shape | --bbox) (--osm | --google_sat | --esri_sat | --key KEY) (--jpg | --png | --tiff) --zoom ZOOM [--tiles-out TILES_OUT] [--download-only] [--mosaic-only]
+                [--group-tiles GROUP_TILES] [--group-overlap] [--tile-limit TILE_LIMIT] [--workers WORKERS] [--no-parallel] [--no-progress] [--quiet] [--debug]
 
 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
+  -h, --help            show this help message and exit
+  --zoom ZOOM           Zoom level (integer between 1 and 22)
+  --tiles-out TILES_OUT
+                        Output directory for downloaded tiles (default: ./saved_tiles)
+  --download-only       Only download tiles; do not run mosaicking or postprocessing
+  --mosaic-only         Only mosaic tiles; do not download
+  --group-tiles GROUP_TILES
+                        Mosaic tiles but according to given WxH into ./grouped_tiles
+  --group-overlap       Overlap with the next consecutive tile when grouping
+  --tile-limit TILE_LIMIT
+                        Override maximum tile limit that can download (use with caution)
+  --workers WORKERS     Max number of threads to use when parallel downloading
+  --no-parallel         Download tiles sequentially, no parallel downloading
+  --no-progress         Hide tile download progress bar
+  --quiet               Hide all prints
+  --debug               Enable debug logging
 
 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 SOURCE       The vector polygon source for filter tiles
+  --shape               Use actual shape to derive tiles
+  --bbox                Use shape's bbox 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                        |
+  --osm                 OpenStreetMap
+  --google_sat          Google Satellite
+  --esri_sat            ESRI World Imagery
+  --key KEY             API key where required by source
 
----
-
-## Tile Sources (CLI)
+Mosaic export formats:
+  Formats for the output mosaic image
 
-| Flag           | Source             |
-| -------------- | ------------------ |
-| `--osm`        | OpenStreetMap      |
-| `--google_sat` | Google Satellite   |
-| `--esri_sat`   | ESRI World Imagery |
+  --jpg                 JPG image; no geo-reference
+  --png                 PNG image; no geo-reference
+  --tiff                GeoTiff image; with geo-reference
 
-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
 
@@ -222,9 +204,6 @@ Any format readable by **GeoPandas**, including:
 
 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
 
@@ -234,12 +213,9 @@ from tilegrab.sources import TileSource
 class MyCustomSource(TileSource):
     name = "MyCustomSource name"
     description = "MyCustomSource description"
-    URL_TEMPLATE = "https://MyCustomSource/{z}/{x}/{y}.png"
+    url_template = "https://MyCustomSource/{z}/{x}/{y}.png"
 ```
 
-That’s it.
-
-Once instantiated, the source works exactly like built-in providers.
 
 ---
 
@@ -251,28 +227,19 @@ You can change how the url is generate by override `get_url` function, inside yo
 ```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)
+  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`
+* `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}
-```
 
 ---
 
@@ -284,8 +251,6 @@ If your provider requires an API key, pass it during instantiation:
 source = MyCustomSource(api_key="YOUR_KEY")
 ```
 
-`TileSource` already handles key injection — you don’t need to reinvent it.
-
 ---
 
 
@@ -299,10 +264,9 @@ 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")
+tile_collection = TilesByShape(dataset, zoom=16)
+tile_source = MyCustomSource(api_key="XYZ")
+downloader = Downloader(tile_collection, tile_source, "output")
 downloader.run()
 ```
 
@@ -321,7 +285,7 @@ If you need full flexibility, use the Python API.
 
 ---
 
-## Project Structure
+<!-- ## Project Structure
 
 ```text
 tilegrab/
@@ -331,11 +295,12 @@ tilegrab/
 ├── downloader.py   # Tile download engine
 ├── mosaic.py       # Tile mosaicking
 └── sources.py      # Tile providers
-```
+``` 
 
 ---
+-->
 
-## Who This Is For
+<!-- ## Who This Is For
 
 * GIS analysts automating basemap generation
 * Remote sensing workflows needing tiled imagery
@@ -345,7 +310,7 @@ tilegrab/
 If you want a GUI, this isn’t it.
 If you want control, repeatability, and speed — it is.
 
----
+--- -->
 
 ## Roadmap
 
@@ -353,9 +318,9 @@ Planned (not promises):
 
 * Additional tile providers
 * Parallel download tuning
-* Cloud-optimized raster output
 * Raster reprojection and resampling options
 * Expanded Python API documentation
+* Test implementation
 
 ---
 

tilegrab-1.2.0b2.dist-info/RECORD

@@ -0,0 +1,15 @@
+tilegrab/__init__.py,sha256=Ti-EFZrLJA9WtEN3ZwvstVIBAsceEuZgjV7gw9JOoyk,295
+tilegrab/__main__.py,sha256=wT62aXCuN7iwRPQoswnmeGiBS5Cou0CIBvMxbOTfvFs,33
+tilegrab/cli.py,sha256=XaSC-qhANE7Y_73k18Izjpi_pGiZu7Qey1s4zP_JQAU,8099
+tilegrab/dataset.py,sha256=kzLMBbLLjdnlKN7Ac-qB7k7e63VCDs3T23CweRdvKLQ,2709
+tilegrab/downloader.py,sha256=ApQLgDjBo-RYrUuaavbulGbHaZ__G9xVQvkPO35RoP4,5371
+tilegrab/images.py,sha256=RAv_gsW5HYOk7cAcu00tHILEFBpF4tKmQ-xDXPtaNmw,11991
+tilegrab/logs.py,sha256=serS8_0bhxoTO0F03t-BDSdkMYR_eX78vI2y1sSVpUk,2151
+tilegrab/sources.py,sha256=rQshFLjzbJu4x0AXTLa3YXhfK07719bMoZrSoOiAWG8,2344
+tilegrab/tiles.py,sha256=XeFxO1i4kXokyK0mg_6f7FeHOkPXOMk8n2m-4C6H87Y,9044
+tilegrab-1.2.0b2.dist-info/licenses/LICENSE,sha256=bcZProekTTcPtnEpRKB2i1kUJ6ujlaxBZchNWKeoXc8,1094
+tilegrab-1.2.0b2.dist-info/METADATA,sha256=363_bNbE-ONRebVSiEX1TGwsmT0KQ4uRowALZhKsVs8,9684
+tilegrab-1.2.0b2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tilegrab-1.2.0b2.dist-info/entry_points.txt,sha256=z-WoKN8NnA5_ZsWXucSeq-r4TeEscu0xjWYu560uNTk,47
+tilegrab-1.2.0b2.dist-info/top_level.txt,sha256=lVio8bCk3r4Bu_INLgaj4PZCrhFY2UcxHjnFBdHwyPo,9
+tilegrab-1.2.0b2.dist-info/RECORD,,