mapchete-eo 2025.10.0__py2.py3-none-any.whl → 2025.11.0__py2.py3-none-any.whl

mapchete_eo/platforms/sentinel2/preconfigured_sources/metadata_xml_mappers.py

@@ -0,0 +1,217 @@
+from mapchete.path import MPath, MPathLike
+
+from mapchete_eo.platforms.sentinel2.metadata_parser.base import S2MetadataPathMapper
+from mapchete_eo.platforms.sentinel2.processing_baseline import ProcessingBaseline
+from mapchete_eo.platforms.sentinel2.types import (
+    BandQI,
+    L2ABand,
+    ProductQI,
+    ProductQIMaskResolution,
+)
+
+
+class SinergisePathMapper(S2MetadataPathMapper):
+    """
+    Return true paths of product quality assets from the Sinergise S2 bucket.
+
+    e.g.:
+    B01 detector footprints: s3://sentinel-s2-l2a/tiles/51/K/XR/2020/7/31/0/qi/MSK_DETFOO_B01.gml
+    Cloud masks: s3://sentinel-s2-l2a/tiles/51/K/XR/2020/7/31/0/qi/MSK_CLOUDS_B00.gml
+
+    newer products however:
+    B01 detector footprints: s3://sentinel-s2-l2a/tiles/51/K/XR/2022/6/6/0/qi/DETFOO_B01.jp2
+    no vector cloudmasks available anymore
+    """
+
+    _PRE_0400_MASK_PATHS = {
+        ProductQI.classification: "MSK_CLOUDS_B00.gml",
+        ProductQI.cloud_probability: "CLD_{resolution}.jp2",  # are they really there?
+        ProductQI.snow_probability: "SNW_{resolution}.jp2",  # are they really there?
+        BandQI.detector_footprints: "MSK_DETFOO_{band_identifier}.gml",
+        BandQI.technical_quality: "MSK_TECQUA_{band_identifier}.gml",
+    }
+    _POST_0400_MASK_PATHS = {
+        ProductQI.classification: "CLASSI_B00.jp2",
+        ProductQI.cloud_probability: "CLD_{resolution}.jp2",
+        ProductQI.snow_probability: "SNW_{resolution}.jp2",
+        BandQI.detector_footprints: "DETFOO_{band_identifier}.jp2",
+        BandQI.technical_quality: "QUALIT_{band_identifier}.jp2",
+    }
+
+    def __init__(
+        self,
+        url: MPathLike,
+        bucket: str = "sentinel-s2-l2a",
+        protocol: str = "s3",
+        baseline_version: str = "04.00",
+        **kwargs,
+    ):
+        url = MPath.from_inp(url)
+        tileinfo_path = url.parent / "tileInfo.json"
+        self._path = MPath(
+            "/".join(tileinfo_path.elements[-9:-1]), **tileinfo_path._kwargs
+        )
+        self._utm_zone, self._latitude_band, self._grid_square = self._path.split("/")[
+            1:-4
+        ]
+        self._baseurl = bucket
+        self._protocol = protocol
+        self.processing_baseline = ProcessingBaseline.from_version(baseline_version)
+
+    def product_qi_mask(
+        self,
+        qi_mask: ProductQI,
+        resolution: ProductQIMaskResolution = ProductQIMaskResolution["60m"],
+    ) -> MPath:
+        """Determine product QI mask according to Sinergise bucket schema."""
+        if self.processing_baseline.version < "04.00":
+            mask_path = self._PRE_0400_MASK_PATHS[qi_mask]
+        else:
+            mask_path = self._POST_0400_MASK_PATHS[qi_mask]
+        key = f"{self._path}/qi/{mask_path.format(resolution=resolution.name)}"
+        return MPath.from_inp(f"{self._protocol}://{self._baseurl}/{key}")
+
+    def classification_mask(self) -> MPath:
+        return self.product_qi_mask(ProductQI.classification)
+
+    def cloud_probability_mask(
+        self, resolution: ProductQIMaskResolution = ProductQIMaskResolution["60m"]
+    ) -> MPath:
+        return self.product_qi_mask(ProductQI.cloud_probability, resolution=resolution)
+
+    def snow_probability_mask(
+        self, resolution: ProductQIMaskResolution = ProductQIMaskResolution["60m"]
+    ) -> MPath:
+        return self.product_qi_mask(ProductQI.snow_probability, resolution=resolution)
+
+    def band_qi_mask(self, qi_mask: BandQI, band: L2ABand) -> MPath:
+        """Determine product QI mask according to Sinergise bucket schema."""
+        try:
+            if self.processing_baseline.version < "04.00":
+                mask_path = self._PRE_0400_MASK_PATHS[qi_mask]
+            else:
+                mask_path = self._POST_0400_MASK_PATHS[qi_mask]
+        except KeyError:
+            raise DeprecationWarning(
+                f"'{qi_mask.name}' quality mask not found in this product"
+            )
+        key = f"{self._path}/qi/{mask_path.format(band_identifier=band.name)}"
+        return MPath.from_inp(f"{self._protocol}://{self._baseurl}/{key}")
+
+    def technical_quality_mask(self, band: L2ABand) -> MPath:
+        return self.band_qi_mask(BandQI.technical_quality, band)
+
+    def detector_footprints(self, band: L2ABand) -> MPath:
+        return self.band_qi_mask(BandQI.detector_footprints, band)
+
+
+class EarthSearchPathMapper(SinergisePathMapper):
+    """
+    The COG archive maintained by E84 and covered by EarthSearch does not hold additional data
+    such as the GML files. This class maps the metadata masks to the current EarthSearch product.
+
+    e.g.:
+    B01 detector footprints: s3://sentinel-s2-l2a/tiles/51/K/XR/2020/7/31/0/qi/MSK_DETFOO_B01.gml
+    Cloud masks: s3://sentinel-s2-l2a/tiles/51/K/XR/2020/7/31/0/qi/MSK_CLOUDS_B00.gml
+
+    newer products however:
+    B01 detector footprints: s3://sentinel-s2-l2a/tiles/51/K/XR/2022/6/6/0/qi/DETFOO_B01.jp2
+    no vector cloudmasks available anymore
+    """
+
+    def __init__(
+        self,
+        metadata_xml: MPath,
+        alternative_metadata_baseurl: str = "sentinel-s2-l2a",
+        protocol: str = "s3",
+        baseline_version: str = "04.00",
+        **kwargs,
+    ):
+        basedir = metadata_xml.parent
+        self._path = (basedir / "tileinfo_metadata.json").read_json()["path"]
+        self._utm_zone, self._latitude_band, self._grid_square = basedir.elements[-6:-3]
+        self._baseurl = alternative_metadata_baseurl
+        self._protocol = protocol
+        self.processing_baseline = ProcessingBaseline.from_version(baseline_version)
+
+
+class EarthSearchC1PathMapper(SinergisePathMapper):
+    """
+    The newer C1 collection has cloud and snow probability masks as assets, so we only need to
+    map to the rest.
+    """
+
+    def __init__(
+        self,
+        metadata_xml: MPath,
+        alternative_metadata_baseurl: str = "sentinel-s2-l2a",
+        protocol: str = "s3",
+        baseline_version: str = "04.00",
+        **kwargs,
+    ):
+        basedir = metadata_xml.parent
+        self._path = (basedir / "tileInfo.json").read_json()["path"]
+        self._utm_zone, self._latitude_band, self._grid_square = basedir.elements[-6:-3]
+        self._baseurl = alternative_metadata_baseurl
+        self._protocol = protocol
+        self.processing_baseline = ProcessingBaseline.from_version(baseline_version)
+
+
+class CDSEPathMapper(S2MetadataPathMapper):
+    _MASK_FILENAMES = {
+        ProductQI.classification: "MSK_CLASSI_B00.jp2",
+        ProductQI.cloud_probability: "MSK_CLDPRB_{resolution}.jp2",
+        ProductQI.snow_probability: "MSK_SNWPRB_{resolution}.jp2",
+        BandQI.detector_footprints: "MSK_DETFOO_{band_identifier}.jp2",
+        BandQI.technical_quality: "MSK_QUALIT_{band_identifier}.jp2",
+    }
+
+    def __init__(
+        self,
+        url: MPathLike,
+        baseline_version: str = "04.00",
+        **kwargs,
+    ):
+        url = MPath.from_inp(url)
+        self._path = url.parent
+        self.processing_baseline = ProcessingBaseline.from_version(baseline_version)
+
+    def product_qi_mask(
+        self,
+        qi_mask: ProductQI,
+        resolution: ProductQIMaskResolution = ProductQIMaskResolution["60m"],
+    ) -> MPath:
+        """Determine product QI mask according to Sinergise bucket schema."""
+        mask_path = self._MASK_FILENAMES[qi_mask]
+        key = f"QI_DATA/{mask_path.format(resolution=resolution.name)}"
+        return self._path / key
+
+    def classification_mask(self) -> MPath:
+        return self.product_qi_mask(ProductQI.classification)
+
+    def cloud_probability_mask(
+        self, resolution: ProductQIMaskResolution = ProductQIMaskResolution["60m"]
+    ) -> MPath:
+        return self.product_qi_mask(ProductQI.cloud_probability, resolution=resolution)
+
+    def snow_probability_mask(
+        self, resolution: ProductQIMaskResolution = ProductQIMaskResolution["60m"]
+    ) -> MPath:
+        return self.product_qi_mask(ProductQI.snow_probability, resolution=resolution)
+
+    def band_qi_mask(self, qi_mask: BandQI, band: L2ABand) -> MPath:
+        """Determine product QI mask according to Sinergise bucket schema."""
+        try:
+            mask_path = self._MASK_FILENAMES[qi_mask]
+        except KeyError:
+            raise DeprecationWarning(
+                f"'{qi_mask.name}' quality mask not found in this product"
+            )
+        key = f"QI_DATA/{mask_path.format(band_identifier=band.name)}"
+        return self._path / key
+
+    def technical_quality_mask(self, band: L2ABand) -> MPath:
+        return self.band_qi_mask(BandQI.technical_quality, band)
+
+    def detector_footprints(self, band: L2ABand) -> MPath:
+        return self.band_qi_mask(BandQI.detector_footprints, band)

mapchete_eo/platforms/sentinel2/preprocessing_tasks.py

@@ -4,9 +4,12 @@ from typing import Optional, Union
 import pystac
 
 from mapchete_eo.exceptions import CorruptedProductMetadata
+from mapchete_eo.io.items import get_item_property
 from mapchete_eo.platforms.sentinel2.config import CacheConfig
 from mapchete_eo.platforms.sentinel2.product import S2Product
+from mapchete_eo.platforms.sentinel2.source import Sentinel2Source
 from mapchete_eo.product import add_to_blacklist
+from mapchete_eo.settings import mapchete_eo_settings
 
 logger = logging.getLogger(__name__)
 
@@ -16,9 +19,27 @@ def parse_s2_product(
     cache_config: Optional[CacheConfig] = None,
     cache_all: bool = False,
 ) -> Union[S2Product, CorruptedProductMetadata]:
+    # use mapper from source if applickable
+    source: Union[Sentinel2Source, None] = item.properties.pop(
+        "mapchete_eo:source", None
+    )
     try:
         s2product = S2Product.from_stac_item(
-            item, cache_config=cache_config, cache_all=cache_all
+            item,
+            cache_config=cache_config,
+            cache_all=cache_all,
+            metadata_mapper=None if source is None else source.get_s2metadata_mapper(),
+            item_modifier_funcs=None if source is None else source.item_modifier_funcs,
+            lazy_load_item=mapchete_eo_settings.lazy_load_stac_items,
+            item_property_cache={
+                key: get_item_property(item, key)
+                for key in [
+                    "datetime",
+                    "eo:cloud_cover",
+                    "id",
+                    "s2:datastrip_id",
+                ]
+            },
         )
     except CorruptedProductMetadata as exc:
         add_to_blacklist(item.get_self_href())

mapchete_eo/platforms/sentinel2/processing_baseline.py

@@ -152,6 +152,9 @@ class ProcessingBaseline:
         self.band_mask_types = self.item_mapping.band_mask_types
         self.band_mask_extension = self.item_mapping.band_mask_extension
 
+    def __repr__(self) -> str:
+        return f"<ProcessingBaseline version={self.version}>"
+
     @staticmethod
     def from_version(version: Union[BaselineVersion, str]) -> "ProcessingBaseline":
         if isinstance(version, BaselineVersion):

mapchete_eo/platforms/sentinel2/product.py

@@ -1,22 +1,23 @@
 from __future__ import annotations
 
 import logging
-from typing import Dict, List, Optional, Union
+from typing import Any, Callable, Dict, List, Optional, Union
 
 import numpy as np
 import numpy.ma as ma
-import pystac
 from mapchete.io.raster import ReferencedRaster, read_raster_window, resample_from_array
-from mapchete.geometry import reproject_geometry
+from mapchete.geometry import reproject_geometry, buffer_antimeridian_safe
 from mapchete.path import MPath
 from mapchete.protocols import GridProtocol
 from mapchete.types import Bounds, Grid, NodataVals
+from pystac import Item
 from rasterio.enums import Resampling
 from rasterio.features import rasterize
 from shapely.geometry import shape
 
 
 from mapchete_eo.array.buffer import buffer_array
+from mapchete_eo.io.items import get_item_property
 from mapchete_eo.platforms.sentinel2.brdf.config import BRDFModels
 from mapchete_eo.platforms.sentinel2.brdf.correction import apply_correction
 from mapchete_eo.exceptions import (
@@ -27,7 +28,6 @@ from mapchete_eo.exceptions import (
     EmptyFootprintException,
     EmptyProductException,
 )
-from mapchete_eo.geometry import buffer_antimeridian_safe
 from mapchete_eo.io.assets import get_assets, read_mask_as_raster
 from mapchete_eo.io.path import asset_mpath, get_product_cache_path
 from mapchete_eo.io.profiles import COGDeflateProfile
@@ -41,7 +41,7 @@ from mapchete_eo.platforms.sentinel2.config import (
     CacheConfig,
     MaskConfig,
 )
-from mapchete_eo.platforms.sentinel2.metadata_parser import S2Metadata
+from mapchete_eo.platforms.sentinel2.metadata_parser.s2metadata import S2Metadata
 from mapchete_eo.platforms.sentinel2.types import (
     CloudType,
     L2ABand,
@@ -56,11 +56,11 @@ logger = logging.getLogger(__name__)
 
 
 class Cache:
-    item: pystac.Item
+    item: Item
     config: CacheConfig
     path: MPath
 
-    def __init__(self, item: pystac.Item, config: CacheConfig):
+    def __init__(self, item: Item, config: CacheConfig):
         self.item = item
         self.config = config
         # TODO: maybe move this function here
@@ -143,21 +143,33 @@ class Cache:
 
 
 class S2Product(EOProduct, EOProductProtocol):
-    item_dict: dict
+    _item_dict: Optional[dict] = None
     cache: Optional[Cache] = None
     _scl_cache: Dict[GridProtocol, np.ndarray]
+    _item_property_cache: Dict[str, Any]
 
     def __init__(
         self,
-        item: pystac.Item,
+        item: Item,
         metadata: Optional[S2Metadata] = None,
         cache_config: Optional[CacheConfig] = None,
+        metadata_mapper: Optional[Callable[[Item], S2Metadata]] = None,
+        item_modifier_funcs: Optional[List[Callable[[Item], Item]]] = None,
+        lazy_load_item: bool = False,
+        item_property_cache: Optional[Dict[str, Any]] = None,
     ):
-        self.item_dict = item.to_dict()
+        if lazy_load_item:
+            self._item_dict = None
+        else:
+            self._item_dict = item.to_dict()
+        self.item_href = item.self_href
         self.id = item.id
 
         self._metadata = metadata
+        self._metadata_mapper = metadata_mapper
+        self._item_modifier_funcs = item_modifier_funcs
         self._scl_cache = dict()
+        self._item_property_cache = item_property_cache or dict()
         self.cache = Cache(item, cache_config) if cache_config else None
 
         self.__geo_interface__ = item.geometry
@@ -167,12 +179,12 @@ class S2Product(EOProduct, EOProductProtocol):
     @classmethod
     def from_stac_item(
         self,
-        item: pystac.Item,
+        item: Item,
         cache_config: Optional[CacheConfig] = None,
         cache_all: bool = False,
         **kwargs,
     ) -> S2Product:
-        s2product = S2Product(item, cache_config=cache_config)
+        s2product = S2Product(item, cache_config=cache_config, **kwargs)
 
         if cache_all:
             # cache assets if configured
@@ -183,22 +195,37 @@ class S2Product(EOProduct, EOProductProtocol):
 
         return s2product
 
+    @property
+    def item(self) -> Item:
+        if not self._item:
+            if self._item_dict:
+                self._item = Item.from_dict(self._item_dict)
+            else:
+                item = Item.from_file(self.item_href)
+                for modifier in self._item_modifier_funcs or []:
+                    item = modifier(item)
+                self._item = item
+        return self._item
+
     @property
     def metadata(self) -> S2Metadata:
         if not self._metadata:
-            self._metadata = S2Metadata.from_stac_item(
-                pystac.Item.from_dict(self.item_dict)
-            )
+            if self._metadata_mapper:
+                self._metadata = self._metadata_mapper(self.item)
+            else:
+                self._metadata = S2Metadata.from_stac_item(self.item)
         return self._metadata
 
     def __repr__(self):
         return f"<S2Product product_id={self.id}>"
 
     def clear_cached_data(self):
-        logger.debug("clear S2Product caches")
         if self._metadata is not None:
             self._metadata.clear_cached_data()
             self._metadata = None
+        if self._item is not None:
+            self._item = None
+        self._item_property_cache = dict()
         self._scl_cache = dict()
 
     def read_np_array(
@@ -215,7 +242,7 @@ class S2Product(EOProduct, EOProductProtocol):
         mask_config: MaskConfig = MaskConfig(),
         brdf_config: Optional[BRDFConfig] = None,
         fill_value: int = 0,
-        target_mask: Optional[np.ndarray] = None,
+        read_mask: Optional[np.ndarray] = None,
         **kwargs,
     ) -> ma.MaskedArray:
         assets = assets or []
@@ -228,7 +255,9 @@ class S2Product(EOProduct, EOProductProtocol):
             count = len(assets)
         if isinstance(grid, Resolution):
             grid = self.metadata.grid(grid)
-        mask = self.get_mask(grid, mask_config, target_mask=target_mask).data
+        mask = self.get_mask(
+            grid, mask_config, target_mask=None if read_mask is None else ~read_mask
+        ).data
         if nodatavals is None:
             nodatavals = fill_value
         elif fill_value is None and nodatavals is not None:
@@ -361,7 +390,23 @@ class S2Product(EOProduct, EOProductProtocol):
         cached_read: bool = False,
     ) -> ReferencedRaster:
         """Return cloud probability mask."""
-        logger.debug("read cloud probability mask for %s", str(self))
+        if "cloud" in self.item.assets:
+            logger.debug("read cloud probability mask for %s from asset", str(self))
+            return read_mask_as_raster(
+                path=asset_mpath(item=self.item, asset="cloud"),
+                dst_grid=(
+                    self.metadata.grid(grid)
+                    if isinstance(grid, Resolution)
+                    else Grid.from_obj(grid)
+                ),
+                resampling=resampling,
+                rasterize_value_func=lambda feature: True,
+                masked=False,
+                cached_read=cached_read,
+            )
+        logger.debug(
+            "read cloud probability mask for %s from metadata archive", str(self)
+        )
         return self.metadata.cloud_probability(
             dst_grid=grid,
             resampling=resampling,
@@ -377,7 +422,23 @@ class S2Product(EOProduct, EOProductProtocol):
         cached_read: bool = False,
     ) -> ReferencedRaster:
         """Return classification snow and ice mask."""
-        logger.debug("read snow probability mask for %s", str(self))
+        if "snow" in self.item.assets:
+            logger.debug("read snow probability mask for %s from asset", str(self))
+            return read_mask_as_raster(
+                path=asset_mpath(item=self.item, asset="cloud"),
+                dst_grid=(
+                    self.metadata.grid(grid)
+                    if isinstance(grid, Resolution)
+                    else Grid.from_obj(grid)
+                ),
+                resampling=resampling,
+                rasterize_value_func=lambda feature: True,
+                masked=False,
+                cached_read=cached_read,
+            )
+        logger.debug(
+            "read snow probability mask for %s from metadata archive", str(self)
+        )
         return self.metadata.snow_probability(
             dst_grid=grid,
             resampling=resampling,
@@ -464,13 +525,12 @@ class S2Product(EOProduct, EOProductProtocol):
             if isinstance(grid, Resolution)
             else Grid.from_obj(grid)
         )
-
         if target_mask is None:
             target_mask = np.zeros(shape=grid.shape, dtype=bool)
         else:
             if target_mask.shape != grid.shape:
                 raise ValueError("a target mask must have the same shape as the grid")
-            logger.debug("got custom target mask to start with: %s", target_mask)
+            logger.debug("got custom target mask to start with: %s", target_mask.shape)
 
         def _check_full(arr):
             # ATTENTION: target_mask and out have to be combined *after* mask was buffered!
@@ -569,6 +629,11 @@ class S2Product(EOProduct, EOProductProtocol):
             bounds=grid.bounds,
         )
 
+    def get_property(self, name: str) -> Any:
+        if name not in self._item_property_cache:
+            self._item_property_cache[name] = get_item_property(self.item, name)
+        return self._item_property_cache[name]
+
     def _apply_sentinel2_bandpass_adjustment(
         self, uncorrected: ma.MaskedArray, assets: List[str], computing_dtype=np.float32
     ) -> ma.MaskedArray:
@@ -662,7 +727,7 @@ class S2Product(EOProduct, EOProductProtocol):
         return out_arr
 
 
-def asset_name_to_l2a_band(item: pystac.Item, asset_name: str) -> L2ABand:
+def asset_name_to_l2a_band(item: Item, asset_name: str) -> L2ABand:
     asset = item.assets[asset_name]
     asset_path = MPath(asset.href)
     band_name = asset_path.name.split(".")[0]

mapchete_eo/platforms/sentinel2/source.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from typing import Optional, List, Callable, Dict, Any, Union
+import warnings
+
+from pydantic import model_validator
+from pystac import Item
+
+from mapchete_eo.platforms.sentinel2.metadata_parser.s2metadata import S2Metadata
+from mapchete_eo.source import Source
+from mapchete_eo.platforms.sentinel2.preconfigured_sources import (
+    DEPRECATED_ARCHIVES,
+    KNOWN_SOURCES,
+)
+from mapchete_eo.platforms.sentinel2.types import (
+    DataArchive,
+    MetadataArchive,
+)
+from mapchete_eo.platforms.sentinel2._mapper_registry import MAPPER_REGISTRIES
+
+
+def known_collection_to_url(collection: str) -> str:
+    if collection in KNOWN_SOURCES:
+        return KNOWN_SOURCES[collection]["collection"]
+    return collection
+
+
+class Sentinel2Source(Source):
+    """All information required to consume Sentinel-2 products."""
+
+    # extends base model with those properties
+    data_archive: Optional[DataArchive] = None
+    metadata_archive: MetadataArchive = "roda"
+
+    @property
+    def item_modifier_funcs(self) -> List[Callable]:
+        return [
+            func
+            for func in (self.get_id_mapper(), *self.get_stac_metadata_mappers())
+            if func is not None
+        ]
+
+    @model_validator(mode="before")
+    def determine_data_source(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """Handles short names of sources."""
+        if isinstance(values, str):
+            values = dict(collection=values)
+        collection = values.get("collection", None)
+        if collection in KNOWN_SOURCES:
+            values.update(KNOWN_SOURCES[collection])
+        elif collection in DEPRECATED_ARCHIVES:
+            warnings.warn(
+                f"deprecated archive '{collection}' found",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+            values.update(DEPRECATED_ARCHIVES[collection])
+        return values
+
+    @model_validator(mode="after")
+    def verify_mappers(self) -> Sentinel2Source:
+        # make sure all required mappers are registered
+        self.get_id_mapper()
+        self.get_stac_metadata_mappers()
+        self.get_s2metadata_mapper()
+        return self
+
+    def get_id_mapper(self) -> Union[Callable[[Item], Item], None]:
+        if self.catalog_type == "static":
+            return None
+        for key in MAPPER_REGISTRIES["ID"].keys():
+            if self.collection == known_collection_to_url(key):
+                return MAPPER_REGISTRIES["ID"][key]
+        else:
+            raise ValueError(f"no ID mapper for {self.collection} found")
+
+    def get_stac_metadata_mappers(self) -> List[Callable[[Item], Item]]:
+        """Find mapper function.
+
+        A mapper function must be provided if a custom data_archive was configured.
+        """
+        mappers: List[Callable] = []
+        if self.catalog_type == "static":
+            return mappers
+        for key in MAPPER_REGISTRIES["STAC metadata"]:
+            if isinstance(key, tuple):
+                collection, data_archive = key
+                if (
+                    self.collection == known_collection_to_url(collection)
+                    and data_archive == self.data_archive
+                ):
+                    mappers.append(MAPPER_REGISTRIES["STAC metadata"][key])
+            elif self.collection == known_collection_to_url(key):
+                mappers.append(MAPPER_REGISTRIES["STAC metadata"][key])
+        if mappers or self.data_archive is None:
+            return mappers
+        raise ValueError(
+            f"no STAC metadata mapper from {self.collection} to {self.data_archive} found"
+        )
+
+    def get_s2metadata_mapper(self) -> Union[Callable[[Item], S2Metadata], None]:
+        if self.catalog_type == "static" or self.metadata_archive is None:
+            return None
+        for key in MAPPER_REGISTRIES["S2Metadata"]:
+            collection, metadata_archive = key
+            if (
+                self.collection == known_collection_to_url(collection)
+                and metadata_archive == self.metadata_archive
+            ):
+                return MAPPER_REGISTRIES["S2Metadata"][key]
+        else:
+            raise ValueError(
+                f"no S2Metadata mapper from {self.collection} to {self.metadata_archive} found"
+            )

mapchete_eo/platforms/sentinel2/types.py

@@ -1,4 +1,5 @@
 from enum import Enum
+from typing import Literal
 
 Resolution = Enum(
     "Resolution",
@@ -107,3 +108,7 @@ class SceneClassification(int, Enum):
     cloud_high_probability = 9
     thin_cirrus = 10
     snow = 11
+
+
+DataArchive = Literal["AWSCOG", "AWSJP2"]
+MetadataArchive = Literal["roda", "CDSE"]

mapchete_eo/processes/merge_rasters.py

@@ -181,15 +181,19 @@ def gradient_merge(
         # footprint coverage)
         # set 1 to 0:
         gradient_1band[gradient_1band == 1] = 0
-        logger.debug(f"gradient_1band: {gradient_1band}")
+        logger.debug(
+            f"gradient_1band; min: {np.min(gradient_1band)}, max: {np.max(gradient_1band)}"
+        )
 
         # extrude array to match number of raster bands
         gradient_8bit = np.stack([gradient_1band for _ in range(raster.shape[0])])
-        logger.debug(f"gradient_8bit: {gradient_8bit}")
+        logger.debug(
+            f"gradient_8bit; min: {np.min(gradient_8bit)}, max: {np.max(gradient_8bit)}"
+        )
 
         # scale gradient from 0 to 1
         gradient = gradient_8bit / 255
-        logger.debug(f"gradient: {gradient}")
+        logger.debug(f"gradient; min: {np.min(gradient)} , max: {np.max(gradient)}")
 
         # now only apply the gradient where out and raster have values
         # otherwise pick the remaining existing value or keep a masked