rslearn 0.0.20__py3-none-any.whl → 0.0.22__py3-none-any.whl

rslearn/data_sources/planetary_computer.py

@@ -1,6 +1,5 @@
 """Data on Planetary Computer."""
 
-import json
 import os
 import tempfile
 import xml.etree.ElementTree as ET
@@ -10,18 +9,14 @@ from typing import Any
 import affine
 import numpy.typing as npt
 import planetary_computer
-import pystac
-import pystac_client
 import rasterio
 import requests
-import shapely
 from rasterio.enums import Resampling
 from upath import UPath
 
-from rslearn.config import LayerConfig, QueryConfig
-from rslearn.const import WGS84_PROJECTION
-from rslearn.data_sources import DataSource, DataSourceContext, Item
-from rslearn.data_sources.utils import match_candidate_items_to_window
+from rslearn.config import LayerConfig
+from rslearn.data_sources import DataSourceContext
+from rslearn.data_sources.stac import SourceItem, StacDataSource
 from rslearn.dataset import Window
 from rslearn.dataset.materialize import RasterMaterializer
 from rslearn.log_utils import get_logger
@@ -35,38 +30,7 @@ from .copernicus import get_harmonize_callback
 logger = get_logger(__name__)
 
 
-class PlanetaryComputerItem(Item):
-    """An item in the PlanetaryComputer data source."""
-
-    def __init__(self, name: str, geometry: STGeometry, asset_urls: dict[str, str]):
-        """Creates a new PlanetaryComputerItem.
-
-        Args:
-            name: unique name of the item
-            geometry: the spatial and temporal extent of the item
-            asset_urls: map from asset key to the unsigned asset URL.
-        """
-        super().__init__(name, geometry)
-        self.asset_urls = asset_urls
-
-    def serialize(self) -> dict[str, Any]:
-        """Serializes the item to a JSON-encodable dictionary."""
-        d = super().serialize()
-        d["asset_urls"] = self.asset_urls
-        return d
-
-    @staticmethod
-    def deserialize(d: dict[str, Any]) -> "PlanetaryComputerItem":
-        """Deserializes an item from a JSON-decoded dictionary."""
-        item = super(PlanetaryComputerItem, PlanetaryComputerItem).deserialize(d)
-        return PlanetaryComputerItem(
-            name=item.name,
-            geometry=item.geometry,
-            asset_urls=d["asset_urls"],
-        )
-
-
-class PlanetaryComputer(DataSource, TileStore):
+class PlanetaryComputer(StacDataSource, TileStore):
     """Modality-agnostic data source for data on Microsoft Planetary Computer.
 
     If there is a subclass available for a modality, it is recommended to use the
@@ -83,10 +47,6 @@ class PlanetaryComputer(DataSource, TileStore):
 
     STAC_ENDPOINT = "https://planetarycomputer.microsoft.com/api/stac/v1"
 
-    # Default threshold for recreating the STAC client to prevent memory leaks
-    # from the pystac Catalog's resolved objects cache growing unbounded
-    DEFAULT_MAX_ITEMS_PER_CLIENT = 1000
-
     def __init__(
         self,
         collection_name: str,
@@ -97,7 +57,6 @@ class PlanetaryComputer(DataSource, TileStore):
         timeout: timedelta = timedelta(seconds=10),
         skip_items_missing_assets: bool = False,
         cache_dir: str | None = None,
-        max_items_per_client: int | None = None,
         context: DataSourceContext = DataSourceContext(),
     ):
         """Initialize a new PlanetaryComputer instance.
@@ -115,228 +74,40 @@ class PlanetaryComputer(DataSource, TileStore):
             cache_dir: optional directory to cache items by name, including asset URLs.
                 If not set, there will be no cache and instead STAC requests will be
                 needed each time.
-            max_items_per_client: number of STAC items to process before recreating
-                the client to prevent memory leaks from the resolved objects cache.
-                Defaults to DEFAULT_MAX_ITEMS_PER_CLIENT.
             context: the data source context.
         """
-        self.collection_name = collection_name
-        self.asset_bands = asset_bands
-        self.query = query
-        self.sort_by = sort_by
-        self.sort_ascending = sort_ascending
-        self.timeout = timeout
-        self.skip_items_missing_assets = skip_items_missing_assets
-        self.max_items_per_client = (
-            max_items_per_client or self.DEFAULT_MAX_ITEMS_PER_CLIENT
-        )
-
+        # Determine the cache_dir to use.
+        cache_upath: UPath | None = None
         if cache_dir is not None:
             if context.ds_path is not None:
-                self.cache_dir = join_upath(context.ds_path, cache_dir)
+                cache_upath = join_upath(context.ds_path, cache_dir)
             else:
-                self.cache_dir = UPath(cache_dir)
-
-            self.cache_dir.mkdir(parents=True, exist_ok=True)
-        else:
-            self.cache_dir = None
+                cache_upath = UPath(cache_dir)
 
-        self.client: pystac_client.Client | None = None
-        self._client_item_count = 0
+            cache_upath.mkdir(parents=True, exist_ok=True)
 
-    def _load_client(
-        self,
-    ) -> pystac_client.Client:
-        """Lazily load pystac client.
-
-        We don't load it when creating the data source because it takes time and caller
-        may not be calling get_items. Additionally, loading it during the get_items
-        call enables leveraging the retry loop functionality in
-        prepare_dataset_windows.
+        # We pass required_assets to StacDataSource of skip_items_missing_assets is set.
+        required_assets: list[str] | None = None
+        if skip_items_missing_assets:
+            required_assets = list(asset_bands.keys())
 
-        Note: We periodically recreate the client to prevent memory leaks from the
-        pystac Catalog's resolved objects cache, which grows unbounded as STAC items
-        are deserialized and cached. The cache cannot be cleared or disabled.
-        """
-        if self.client is None:
-            logger.info("Creating initial STAC client")
-            self.client = pystac_client.Client.open(self.STAC_ENDPOINT)
-            return self.client
-
-        if self._client_item_count < self.max_items_per_client:
-            return self.client
-
-        # Recreate client to clear the resolved objects cache
-        current_client = self.client
-        logger.debug(
-            "Recreating STAC client after processing %d items (threshold: %d)",
-            self._client_item_count,
-            self.max_items_per_client,
+        super().__init__(
+            endpoint=self.STAC_ENDPOINT,
+            collection_name=collection_name,
+            query=query,
+            sort_by=sort_by,
+            sort_ascending=sort_ascending,
+            required_assets=required_assets,
+            cache_dir=cache_upath,
         )
-        client_root = current_client.get_root()
-        client_root.clear_links()
-        client_root.clear_items()
-        client_root.clear_children()
-        self._client_item_count = 0
-        self.client = pystac_client.Client.open(self.STAC_ENDPOINT)
-        return self.client
-
-    def _stac_item_to_item(self, stac_item: pystac.Item) -> PlanetaryComputerItem:
-        shp = shapely.geometry.shape(stac_item.geometry)
-
-        # Get time range.
-        metadata = stac_item.common_metadata
-        if metadata.start_datetime is not None and metadata.end_datetime is not None:
-            time_range = (
-                metadata.start_datetime,
-                metadata.end_datetime,
-            )
-        elif stac_item.datetime is not None:
-            time_range = (stac_item.datetime, stac_item.datetime)
-        else:
-            raise ValueError(
-                f"item {stac_item.id} unexpectedly missing start_datetime, end_datetime, and datetime"
-            )
-
-        geom = STGeometry(WGS84_PROJECTION, shp, time_range)
-        asset_urls = {
-            asset_key: asset_obj.href
-            for asset_key, asset_obj in stac_item.assets.items()
-        }
-        return PlanetaryComputerItem(stac_item.id, geom, asset_urls)
-
-    def get_item_by_name(self, name: str) -> PlanetaryComputerItem:
-        """Gets an item by name.
-
-        Args:
-            name: the name of the item to get
-
-        Returns:
-            the item object
-        """
-        # If cache_dir is set, we cache the item. First here we check if it is already
-        # in the cache.
-        cache_fname: UPath | None = None
-        if self.cache_dir:
-            cache_fname = self.cache_dir / f"{name}.json"
-        if cache_fname is not None and cache_fname.exists():
-            with cache_fname.open() as f:
-                return PlanetaryComputerItem.deserialize(json.load(f))
-
-        # No cache or not in cache, so we need to make the STAC request.
-        logger.debug("Getting STAC item {name}")
-        client = self._load_client()
-
-        search_result = client.search(ids=[name], collections=[self.collection_name])
-        stac_items = list(search_result.items())
-
-        if not stac_items:
-            raise ValueError(
-                f"Item {name} not found in collection {self.collection_name}"
-            )
-        if len(stac_items) > 1:
-            raise ValueError(
-                f"Multiple items found for ID {name} in collection {self.collection_name}"
-            )
-
-        stac_item = stac_items[0]
-        item = self._stac_item_to_item(stac_item)
-
-        # Track items processed for client recreation threshold (after deserialization)
-        self._client_item_count += 1
-
-        # Finally we cache it if cache_dir is set.
-        if cache_fname is not None:
-            with cache_fname.open("w") as f:
-                json.dump(item.serialize(), f)
-
-        return item
-
-    def get_items(
-        self, geometries: list[STGeometry], query_config: QueryConfig
-    ) -> list[list[list[PlanetaryComputerItem]]]:
-        """Get a list of items in the data source intersecting the given geometries.
-
-        Args:
-            geometries: the spatiotemporal geometries
-            query_config: the query configuration
-
-        Returns:
-            List of groups of items that should be retrieved for each geometry.
-        """
-        client = self._load_client()
-
-        groups = []
-        for geometry in geometries:
-            # Get potentially relevant items from the collection by performing one search
-            # for each requested geometry.
-            wgs84_geometry = geometry.to_projection(WGS84_PROJECTION)
-            logger.debug("performing STAC search for geometry %s", wgs84_geometry)
-            result = client.search(
-                collections=[self.collection_name],
-                intersects=shapely.to_geojson(wgs84_geometry.shp),
-                datetime=wgs84_geometry.time_range,
-                query=self.query,
-            )
-            stac_items = [item for item in result.items()]
-            # Track items processed for client recreation threshold (after deserialization)
-            self._client_item_count += len(stac_items)
-            logger.debug("STAC search yielded %d items", len(stac_items))
-
-            if self.skip_items_missing_assets:
-                # Filter out items that are missing any of the assets in self.asset_bands.
-                good_stac_items = []
-                for stac_item in stac_items:
-                    good = True
-                    for asset_key in self.asset_bands.keys():
-                        if asset_key in stac_item.assets:
-                            continue
-                        good = False
-                        break
-                    if good:
-                        good_stac_items.append(stac_item)
-                logger.debug(
-                    "skip_items_missing_assets filter from %d to %d items",
-                    len(stac_items),
-                    len(good_stac_items),
-                )
-                stac_items = good_stac_items
-
-            if self.sort_by is not None:
-                stac_items.sort(
-                    key=lambda stac_item: stac_item.properties[self.sort_by],
-                    reverse=not self.sort_ascending,
-                )
-
-            candidate_items = [
-                self._stac_item_to_item(stac_item) for stac_item in stac_items
-            ]
-
-            # Since we made the STAC request, might as well save these to the cache.
-            if self.cache_dir is not None:
-                for item in candidate_items:
-                    cache_fname = self.cache_dir / f"{item.name}.json"
-                    if cache_fname.exists():
-                        continue
-                    with cache_fname.open("w") as f:
-                        json.dump(item.serialize(), f)
-
-            cur_groups = match_candidate_items_to_window(
-                geometry, candidate_items, query_config
-            )
-            groups.append(cur_groups)
-
-        return groups
-
-    def deserialize_item(self, serialized_item: Any) -> PlanetaryComputerItem:
-        """Deserializes an item from JSON-decoded data."""
-        assert isinstance(serialized_item, dict)
-        return PlanetaryComputerItem.deserialize(serialized_item)
+        self.asset_bands = asset_bands
+        self.timeout = timeout
+        self.skip_items_missing_assets = skip_items_missing_assets
 
     def ingest(
         self,
         tile_store: TileStoreWithLayer,
-        items: list[PlanetaryComputerItem],
+        items: list[SourceItem],
         geometries: list[list[STGeometry]],
     ) -> None:
         """Ingest items into the given tile store.
@@ -512,7 +283,7 @@ class PlanetaryComputer(DataSource, TileStore):
     def materialize(
         self,
         window: Window,
-        item_groups: list[list[Item]],
+        item_groups: list[list[SourceItem]],
         layer_name: str,
         layer_cfg: LayerConfig,
     ) -> None:
@@ -601,7 +372,7 @@ class Sentinel2(PlanetaryComputer):
             **kwargs,
         )
 
-    def _get_product_xml(self, item: PlanetaryComputerItem) -> ET.Element:
+    def _get_product_xml(self, item: SourceItem) -> ET.Element:
         asset_url = planetary_computer.sign(item.asset_urls["product-metadata"])
         response = requests.get(asset_url, timeout=self.timeout.total_seconds())
         response.raise_for_status()
@@ -610,7 +381,7 @@ class Sentinel2(PlanetaryComputer):
     def ingest(
         self,
         tile_store: TileStoreWithLayer,
-        items: list[PlanetaryComputerItem],
+        items: list[SourceItem],
         geometries: list[list[STGeometry]],
     ) -> None:
         """Ingest items into the given tile store.

rslearn/data_sources/soilgrids.py

@@ -0,0 +1,331 @@
+"""Data source for SoilGrids via the `soilgrids` Python package.
+
+This source is intended to be used with `ingest: false` (direct materialization),
+since data is fetched on-demand per window.
+"""
+
+from __future__ import annotations
+
+import tempfile
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+import rasterio
+import rasterio.warp
+import shapely
+from rasterio.crs import CRS
+from rasterio.enums import Resampling
+from upath import UPath
+
+from rslearn.config import LayerConfig, QueryConfig
+from rslearn.dataset import Window
+from rslearn.dataset.materialize import RasterMaterializer
+from rslearn.tile_stores import TileStore, TileStoreWithLayer
+from rslearn.utils import PixelBounds, Projection, STGeometry
+from rslearn.utils.geometry import get_global_geometry
+from rslearn.utils.raster_format import get_transform_from_projection_and_bounds
+
+from .data_source import DataSource, DataSourceContext, Item
+from .utils import match_candidate_items_to_window
+
+SOILGRIDS_NODATA_VALUE = -32768.0
+"""Default nodata value used by SoilGrids GeoTIFF responses (GEOTIFF_INT16)."""
+
+
+def _crs_to_rasterio(crs: str) -> CRS:
+    """Best-effort conversion of CRS strings used by `soilgrids` to rasterio CRS."""
+    try:
+        return CRS.from_string(crs)
+    except Exception:
+        # Fallback: if rasterio can't parse the string but it contains an EPSG code,
+        # extract the trailing integer and build a CRS from it.
+        parts = [p for p in crs.replace(":", " ").split() if p.isdigit()]
+        if parts:
+            return CRS.from_epsg(int(parts[-1]))
+        raise
+
+
+def _crs_to_soilgrids_urn(crs: str) -> str:
+    """Convert common CRS spellings to the URN form expected by `soilgrids`.
+
+    The `soilgrids` package compares CRS strings against the supported CRS URNs from
+    OWSLib (e.g. "urn:ogc:def:crs:EPSG::3857"). This helper allows users to specify
+    simpler forms like "EPSG:3857" while still working.
+    """
+    s = crs.strip()
+
+    # If already an EPSG URN, canonicalize to the form soilgrids expects.
+    if s.lower().startswith("urn:ogc:def:crs:") and "epsg" in s.lower():
+        parts = [p for p in s.replace(":", " ").split() if p.isdigit()]
+        if parts:
+            return f"urn:ogc:def:crs:EPSG::{parts[-1]}"
+        return s
+
+    # Accept "EPSG:3857", "epsg:3857", or other strings containing an EPSG code.
+    if "epsg" in s.lower():
+        parts = [p for p in s.replace(":", " ").split() if p.isdigit()]
+        if parts:
+            return f"urn:ogc:def:crs:EPSG::{parts[-1]}"
+
+    return s
+
+
+class SoilGrids(DataSource, TileStore):
+    """Access SoilGrids coverages as an rslearn raster data source."""
+
+    def __init__(
+        self,
+        service_id: str,
+        coverage_id: str,
+        crs: str = "EPSG:3857",
+        width: int | None = None,
+        height: int | None = None,
+        resx: float | None = None,
+        resy: float | None = None,
+        response_crs: str | None = None,
+        band_names: list[str] = ["B1"],
+        context: DataSourceContext = DataSourceContext(),
+    ):
+        """Create a new SoilGrids data source.
+
+        Args:
+            service_id: SoilGrids map service id (e.g., "clay", "phh2o").
+            coverage_id: coverage id within the service (e.g., "clay_0-5cm_mean").
+            crs: request CRS string passed through to `soilgrids.SoilGrids`, typically
+                a URN like "urn:ogc:def:crs:EPSG::4326" or "urn:ogc:def:crs:EPSG::152160".
+            width: optional WCS WIDTH parameter. Required by SoilGrids WCS when CRS is
+                EPSG:4326.
+            height: optional WCS HEIGHT parameter.
+            resx: optional WCS RESX parameter (projection units / pixel).
+            resy: optional WCS RESY parameter (projection units / pixel).
+            response_crs: optional response CRS (defaults to `crs`).
+            band_names: band names exposed to rslearn. For a single coverage, this
+                should have length 1.
+            context: rslearn data source context.
+        """
+        if len(band_names) != 1:
+            raise ValueError("SoilGrids currently supports only single-band coverages")
+        if (width is None) != (height is None):
+            raise ValueError("width and height must be specified together")
+        if (resx is None) != (resy is None):
+            raise ValueError("resx and resy must be specified together")
+        if width is not None and resx is not None:
+            raise ValueError("specify either width/height or resx/resy, not both")
+
+        self.service_id = service_id
+        self.coverage_id = coverage_id
+        self.crs = crs
+        self.width = width
+        self.height = height
+        self.resx = resx
+        self.resy = resy
+        self.response_crs = response_crs
+        self.band_names = band_names
+
+        # Represent the coverage as a single item that matches all windows.
+        item_name = f"{self.service_id}:{self.coverage_id}"
+        self._items = [Item(item_name, get_global_geometry(time_range=None))]
+
+    def get_items(
+        self, geometries: list[STGeometry], query_config: QueryConfig
+    ) -> list[list[list[Item]]]:
+        """Get item groups matching each requested geometry."""
+        groups = []
+        for geometry in geometries:
+            cur_groups = match_candidate_items_to_window(
+                geometry, self._items, query_config
+            )
+            groups.append(cur_groups)
+        return groups
+
+    def deserialize_item(self, serialized_item: Any) -> Item:
+        """Deserialize an item from JSON-decoded data."""
+        return Item.deserialize(serialized_item)
+
+    def ingest(
+        self,
+        tile_store: TileStoreWithLayer,
+        items: list[Item],
+        geometries: list[list[STGeometry]],
+    ) -> None:
+        """Ingest is not supported (direct materialization only)."""
+        raise NotImplementedError(
+            "SoilGrids is intended for direct materialization; set data_source.ingest=false."
+        )
+
+    def is_raster_ready(
+        self, layer_name: str, item_name: str, bands: list[str]
+    ) -> bool:
+        """Return whether the requested raster is ready (always true for direct reads)."""
+        return True
+
+    def get_raster_bands(self, layer_name: str, item_name: str) -> list[list[str]]:
+        """Return the band sets available for this coverage."""
+        return [self.band_names]
+
+    def get_raster_bounds(
+        self, layer_name: str, item_name: str, bands: list[str], projection: Projection
+    ) -> PixelBounds:
+        """Return (approximate) bounds for this raster in the requested projection."""
+        # We don't know bounds without an extra metadata request; treat as "very large"
+        # so materialization always attempts reads for windows.
+        return (-(10**9), -(10**9), 10**9, 10**9)
+
+    def _download_geotiff(
+        self,
+        west: float,
+        south: float,
+        east: float,
+        north: float,
+        output: str,
+        width: int | None,
+        height: int | None,
+        resx: float | None,
+        resy: float | None,
+    ) -> None:
+        from soilgrids import SoilGrids as SoilGridsClient
+
+        client = SoilGridsClient()
+        kwargs: dict[str, Any] = dict(
+            service_id=self.service_id,
+            coverage_id=self.coverage_id,
+            crs=_crs_to_soilgrids_urn(self.crs),
+            west=west,
+            south=south,
+            east=east,
+            north=north,
+            output=output,
+        )
+        if width is not None and height is not None:
+            kwargs["width"] = width
+            kwargs["height"] = height
+        elif resx is not None and resy is not None:
+            kwargs["resx"] = resx
+            kwargs["resy"] = resy
+
+        if self.response_crs is not None:
+            kwargs["response_crs"] = _crs_to_soilgrids_urn(self.response_crs)
+
+        client.get_coverage_data(**kwargs)
+
+    def read_raster(
+        self,
+        layer_name: str,
+        item_name: str,
+        bands: list[str],
+        projection: Projection,
+        bounds: PixelBounds,
+        resampling: Resampling = Resampling.bilinear,
+    ) -> npt.NDArray[Any]:
+        """Read and reproject a SoilGrids coverage subset into the requested grid."""
+        if bands != self.band_names:
+            raise ValueError(
+                f"expected request for bands {self.band_names} but got {bands}"
+            )
+
+        # Compute bounding box in CRS coordinates for the request.
+        request_crs = _crs_to_rasterio(self.crs)
+        request_projection = Projection(request_crs, 1.0, 1.0)
+        request_geom = STGeometry(projection, shapely.box(*bounds), None).to_projection(
+            request_projection
+        )
+        west, south, east, north = request_geom.shp.bounds
+
+        # Determine output grid for the WCS request.
+        #
+        # If the user explicitly configured an output grid (width/height or resx/resy),
+        # we respect it.
+        #
+        # Otherwise, default to requesting at ~250 m resolution in the request CRS
+        # (when it is projected), and then reprojecting to the window grid.
+        #
+        # For EPSG:4326 requests, SoilGrids WCS requires WIDTH/HEIGHT, so we default
+        # to matching the window pixel size.
+        window_width = bounds[2] - bounds[0]
+        window_height = bounds[3] - bounds[1]
+
+        out_width = self.width
+        out_height = self.height
+        out_resx = self.resx
+        out_resy = self.resy
+
+        if request_crs.to_epsg() == 4326 and out_width is None:
+            # Required by the SoilGrids WCS for EPSG:4326; resx/resy is not accepted.
+            out_width = window_width
+            out_height = window_height
+            out_resx = None
+            out_resy = None
+        elif out_width is None and out_resx is None:
+            # Default to native-ish SoilGrids resolution (~250 m) in projected CRSs.
+            out_resx = 250.0
+            out_resy = 250.0
+
+        with tempfile.TemporaryDirectory(prefix="rslearn_soilgrids_") as tmpdir:
+            output_path = str(UPath(tmpdir) / "coverage.tif")
+            self._download_geotiff(
+                west=west,
+                south=south,
+                east=east,
+                north=north,
+                output=output_path,
+                width=out_width,
+                height=out_height,
+                resx=out_resx,
+                resy=out_resy,
+            )
+
+            with rasterio.open(output_path) as src:
+                src_array = src.read(1).astype(np.float32)
+                src_nodata = src.nodata
+                scale = float(src.scales[0]) if src.scales else 1.0
+                offset = float(src.offsets[0]) if src.offsets else 0.0
+
+                if src_nodata is not None:
+                    valid_mask = src_array != float(src_nodata)
+                    src_array[valid_mask] = src_array[valid_mask] * scale + offset
+                    dst_nodata = float(src_nodata)
+                    src_nodata_val = dst_nodata
+                else:
+                    src_array = src_array * scale + offset
+                    dst_nodata = SOILGRIDS_NODATA_VALUE
+                    src_nodata_val = None
+
+                src_chw = src_array[None, :, :]
+                dst = np.full(
+                    (1, bounds[3] - bounds[1], bounds[2] - bounds[0]),
+                    dst_nodata,
+                    dtype=np.float32,
+                )
+                dst_transform = get_transform_from_projection_and_bounds(
+                    projection, bounds
+                )
+
+                rasterio.warp.reproject(
+                    source=src_chw,
+                    src_crs=src.crs,
+                    src_transform=src.transform,
+                    src_nodata=src_nodata_val,
+                    destination=dst,
+                    dst_crs=projection.crs,
+                    dst_transform=dst_transform,
+                    dst_nodata=dst_nodata,
+                    resampling=resampling,
+                )
+                return dst
+
+    def materialize(
+        self,
+        window: Window,
+        item_groups: list[list[Item]],
+        layer_name: str,
+        layer_cfg: LayerConfig,
+    ) -> None:
+        """Materialize a window by reading from SoilGrids on-demand."""
+        RasterMaterializer().materialize(
+            TileStoreWithLayer(self, layer_name),
+            window,
+            layer_name,
+            layer_cfg,
+            item_groups,
+        )