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

mapchete_eo/geometry.py

@@ -1,271 +0,0 @@
-import logging
-import math
-from functools import partial
-from typing import Callable, Iterable, Tuple
-
-from fiona.crs import CRS
-from fiona.transform import transform as fiona_transform
-from mapchete.geometry import reproject_geometry
-from mapchete.types import Bounds, CRSLike
-from shapely.geometry import (
-    GeometryCollection,
-    LinearRing,
-    LineString,
-    MultiLineString,
-    MultiPoint,
-    MultiPolygon,
-    Point,
-    Polygon,
-    box,
-    shape,
-)
-from shapely.geometry.base import BaseGeometry
-from shapely.ops import unary_union
-
-CoordArrays = Tuple[Iterable[float], Iterable[float]]
-
-
-logger = logging.getLogger(__name__)
-
-
-def transform_to_latlon(
-    geometry: BaseGeometry, src_crs: CRSLike, width_threshold: float = 180.0
-) -> BaseGeometry:
-    """Transforms a geometry to lat/lon coordinates.
-
-    If resulting geometry crosses the Antimeridian it will be fixed by moving coordinates
-    from the Western Hemisphere to outside of the lat/lon bounds on the East, making sure
-    the correct geometry shape is preserved.
-
-    As a next step, repair_antimeridian_geometry() can be applied, which then splits up
-    this geometry into a multipart geometry where all of its subgeometries are within the
-    lat/lon bounds again.
-    """
-    latlon_crs = CRS.from_epsg(4326)
-
-    def transform_shift_coords(coords: CoordArrays) -> CoordArrays:
-        out_x_coords, out_y_coords = fiona_transform(src_crs, latlon_crs, *coords)
-        if max(out_x_coords) - min(out_x_coords) > width_threshold:
-            # we probably have an antimeridian crossing here!
-            out_x_coords, out_y_coords = coords_longitudinal_shift(
-                coords_transform(coords, src_crs, latlon_crs), only_negative_coords=True
-            )
-        return (out_x_coords, out_y_coords)
-
-    return custom_transform(geometry, transform_shift_coords)
-
-
-def repair_antimeridian_geometry(
-    geometry: BaseGeometry, width_threshold: float = 180.0
-) -> BaseGeometry:
-    """
-    Repair geometry and apply fix if it crosses the Antimeridian.
-
-    A geometry crosses the Antimeridian if it is at least partly outside of the
-    lat/lon bounding box or if its width exceeds a certain threshold. This can happen
-    after reprojection if the geometry coordinates are transformed separately and land
-    left and right of the Antimeridian, thus resulting in a polygon spanning almost the
-    whole lat/lon bounding box width.
-    """
-    # repair geometry if it is broken
-    geometry = geometry.buffer(0)
-    latlon_bbox = box(-180, -90, 180, 90)
-
-    # only attempt to fix if geometry is too wide or reaches over the lat/lon bounds
-    if (
-        Bounds.from_inp(geometry).width >= width_threshold
-        or not geometry.difference(latlon_bbox).is_empty
-    ):
-        # (1) shift only coordinates on the western hemisphere by 360°, thus "fixing"
-        # the footprint, but letting it cross the antimeridian
-        shifted_geometry = longitudinal_shift(geometry, only_negative_coords=True)
-
-        # (2) split up geometry in one outside of latlon bounds and one inside
-        inside = shifted_geometry.intersection(latlon_bbox)
-        outside = shifted_geometry.difference(latlon_bbox)
-
-        # (3) shift back only the polygon outside of latlon bounds by -360, thus moving
-        # it back to the western hemisphere
-        outside_shifted = longitudinal_shift(
-            outside, offset=-360, only_negative_coords=False
-        )
-
-        # (4) create a MultiPolygon out from these two polygons
-        geometry = unary_union([inside, outside_shifted])
-
-    return geometry
-
-
-def buffer_antimeridian_safe(
-    footprint: BaseGeometry, buffer_m: float = 0
-) -> BaseGeometry:
-    """Buffer geometry by meters and make it Antimeridian-safe.
-
-    Safe means that if it crosses the Antimeridian and is a MultiPolygon,
-    the buffer will only be applied to the edges facing away from the Antimeridian
-    thus leaving the polygon intact if shifted back.
-    """
-    if footprint.is_empty:
-        return footprint
-
-    # repair geometry if it is broken
-    footprint = footprint.buffer(0)
-
-    if not buffer_m:
-        return footprint
-
-    if isinstance(footprint, MultiPolygon):
-        # we have a shifted footprint here!
-        # (1) unshift one part
-        subpolygons = []
-        for polygon in footprint.geoms:
-            lon = polygon.centroid.x
-            if lon < 0:
-                polygon = longitudinal_shift(polygon)
-            subpolygons.append(polygon)
-        # (2) merge to single polygon
-        merged = unary_union(subpolygons)
-
-        # (3) apply buffer
-        if isinstance(merged, MultiPolygon):
-            buffered = unary_union(
-                [
-                    buffer_antimeridian_safe(polygon, buffer_m=buffer_m)
-                    for polygon in merged.geoms
-                ]
-            )
-        else:
-            buffered = buffer_antimeridian_safe(merged, buffer_m=buffer_m)
-
-        # (4) fix again
-        return repair_antimeridian_geometry(buffered)
-
-    # UTM zone CRS
-    utm_crs = latlon_to_utm_crs(footprint.centroid.y, footprint.centroid.x)
-    latlon_crs = CRS.from_string("EPSG:4326")
-
-    return transform_to_latlon(
-        reproject_geometry(
-            footprint, src_crs=latlon_crs, dst_crs=utm_crs, clip_to_crs_bounds=False
-        ).buffer(buffer_m),
-        src_crs=utm_crs,
-    )
-
-
-def longitudinal_shift(
-    geometry: BaseGeometry, offset: float = 360.0, only_negative_coords: bool = False
-) -> BaseGeometry:
-    """Return geometry with either all or Western hemisphere coordinates shifted by some offset."""
-    return custom_transform(
-        geometry,
-        partial(
-            coords_longitudinal_shift,
-            by=offset,
-            only_negative_coords=only_negative_coords,
-        ),
-    )
-
-
-def latlon_to_utm_crs(lat: float, lon: float) -> CRS:
-    min_zone = 1
-    max_zone = 60
-    utm_zone = (
-        f"{max([min([(math.floor((lon + 180) / 6) + 1), max_zone]), min_zone]):02}"
-    )
-    hemisphere_code = "7" if lat <= 0 else "6"
-    return CRS.from_string(f"EPSG:32{hemisphere_code}{utm_zone}")
-
-
-def bounds_to_geom(bounds: Bounds) -> BaseGeometry:
-    # TODO: move into core package
-    if bounds.left < -180:
-        part1 = Bounds(-180, bounds.bottom, bounds.right, bounds.top)
-        part2 = Bounds(bounds.left + 360, bounds.bottom, 180, bounds.top)
-        return unary_union([shape(part1), shape(part2)])
-    elif bounds.right > 180:
-        part1 = Bounds(-180, bounds.bottom, bounds.right - 360, bounds.top)
-        part2 = Bounds(bounds.left, bounds.bottom, 180, bounds.top)
-        return unary_union([shape(part1), shape(part2)])
-    else:
-        return shape(bounds)
-
-
-def custom_transform(geometry: BaseGeometry, func: Callable) -> BaseGeometry:
-    # todo: shapely.transform.transform maybe can make this code more simple
-    # https://shapely.readthedocs.io/en/stable/reference/shapely.transform.html#shapely.transform
-    def _point(point: Point) -> Point:
-        return Point(zip(*func(point.xy)))
-
-    def _multipoint(multipoint: MultiPoint) -> MultiPoint:
-        return MultiPoint([_point(point) for point in multipoint])
-
-    def _linestring(linestring: LineString) -> LineString:
-        return LineString(zip(*func(linestring.xy)))
-
-    def _multilinestring(multilinestring: MultiLineString) -> MultiLineString:
-        return MultiLineString(
-            [_linestring(linestring) for linestring in multilinestring.geoms]
-        )
-
-    def _linearring(linearring: LinearRing) -> LinearRing:
-        return LinearRing(((x, y) for x, y in zip(*func(linearring.xy))))
-
-    def _polygon(polygon: Polygon) -> Polygon:
-        return Polygon(
-            _linearring(polygon.exterior),
-            holes=list(map(_linearring, polygon.interiors)),
-        )
-
-    def _multipolygon(multipolygon: MultiPolygon) -> MultiPolygon:
-        return MultiPolygon([_polygon(polygon) for polygon in multipolygon.geoms])
-
-    def _geometrycollection(
-        geometrycollection: GeometryCollection,
-    ) -> GeometryCollection:
-        return GeometryCollection(
-            [_any_geometry(subgeometry) for subgeometry in geometrycollection.geoms]
-        )
-
-    def _any_geometry(geometry: BaseGeometry) -> BaseGeometry:
-        transform_funcs = {
-            Point: _point,
-            MultiPoint: _multipoint,
-            LineString: _linestring,
-            MultiLineString: _multilinestring,
-            Polygon: _polygon,
-            MultiPolygon: _multipolygon,
-            GeometryCollection: _geometrycollection,
-        }
-        try:
-            return transform_funcs[type(geometry)](geometry)
-        except KeyError:
-            raise TypeError(f"unknown geometry {geometry} of type {type(geometry)}")
-
-    if geometry.is_empty:
-        return geometry
-
-    # make valid by buffering
-    return _any_geometry(geometry).buffer(0)
-
-
-def coords_transform(
-    coords: CoordArrays, src_crs: CRSLike, dst_crs: CRSLike
-) -> CoordArrays:
-    return fiona_transform(src_crs, dst_crs, *coords)
-
-
-def coords_longitudinal_shift(
-    coords: CoordArrays,
-    by: float = 360,
-    only_negative_coords: bool = False,
-) -> CoordArrays:
-    x_coords, y_coords = coords
-    x_coords = (
-        (
-            x_coord + by
-            if (only_negative_coords and x_coord < 0) or not only_negative_coords
-            else x_coord
-        )
-        for x_coord in x_coords
-    )
-    return x_coords, y_coords

mapchete_eo/known_catalogs.py

@@ -1,42 +0,0 @@
-"""
-Catalogs define access to a search interface which provide products
-as pystac Items.
-"""
-
-from typing import List
-
-from mapchete_eo.search import STACSearchCatalog, UTMSearchCatalog
-
-
-class EarthSearchV1S2L2A(STACSearchCatalog):
-    """Earth-Search catalog for Sentinel-2 Level 2A COGs."""
-
-    endpoint: str = "https://earth-search.aws.element84.com/v1/"
-
-
-class CDSESearch(STACSearchCatalog):
-    """Copernicus Data Space Ecosystem (CDSE) STAC API."""
-
-    endpoint: str = "https://stac.dataspace.copernicus.eu/v1"
-
-
-class PlanetaryComputerSearch(STACSearchCatalog):
-    """Planetary Computer Search."""
-
-    endpoint: str = "https://planetarycomputer.microsoft.com/api/stac/v1/"
-
-
-class AWSSearchCatalogS2L2A(UTMSearchCatalog):
-    """
-    Not a search endpoint, just hanging STAC collection with items separately.
-    Need custom parser/browser to find scenes based on date and UTM MGRS Granule
-
-    https://sentinel-s2-l2a-stac.s3.amazonaws.com/sentinel-s2-l2a.json
-    """
-
-    id: str = "sentinel-s2-l2a"
-    endpoint: str = "s3://sentinel-s2-l2a-stac/"
-    day_subdir_schema: str = "{year}/{month:02d}/{day:02d}"
-    stac_json_endswith: str = "T{tile_id}.json"
-    description: str = "Sentinel-2 L2A JPEG2000 archive on AWS."
-    stac_extensions: List[str] = []

mapchete_eo/platforms/sentinel2/archives.py

@@ -1,190 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from typing import Any, Type
-
-from mapchete.path import MPath
-from pydantic import ValidationError
-from pydantic.functional_validators import BeforeValidator
-from pystac import Item
-from typing_extensions import Annotated
-
-from mapchete_eo.archives.base import Archive
-from mapchete_eo.io.items import item_fix_footprint
-from mapchete_eo.known_catalogs import (
-    AWSSearchCatalogS2L2A,
-    CDSESearch,
-    EarthSearchV1S2L2A,
-)
-from mapchete_eo.platforms.sentinel2.types import ProcessingLevel
-from mapchete_eo.search.s2_mgrs import S2Tile
-
-
-def known_archive(v: Any, **args) -> Type[Archive]:
-    if isinstance(v, str):
-        return KnownArchives[v].value
-    elif isinstance(v, type(Archive)):
-        return v
-    else:
-        raise ValidationError(f"cannot validate {v} to archive")
-
-
-ArchiveClsFromString = Annotated[Type[Archive], BeforeValidator(known_archive)]
-
-
-def add_datastrip_id(item: Item) -> Item:
-    """Make sure item metadata is following the standard."""
-    # change 'sentinel2' prefix to 's2'
-    properties = {k.replace("sentinel2:", "s2:"): v for k, v in item.properties.items()}
-
-    # add datastrip id as 's2:datastrip_id'
-    if not properties.get("s2:datastrip_id"):
-        from mapchete_eo.platforms.sentinel2 import S2Metadata
-
-        s2_metadata = S2Metadata.from_stac_item(item)
-        properties["s2:datastrip_id"] = s2_metadata.datastrip_id
-
-    item.properties = properties
-    return item
-
-
-def map_cdse_paths_to_jp2_archive(item: Item) -> Item:
-    """
-    CSDE has the following assets:
-    AOT_10m, AOT_20m, AOT_60m, B01_20m, B01_60m, B02_10m, B02_20m, B02_60m, B03_10m, B03_20m,
-    B03_60m, B04_10m, B04_20m, B04_60m, B05_20m, B05_60m, B06_20m, B06_60m, B07_20m, B07_60m,
-    B08_10m, B09_60m, B11_20m, B11_60m, B12_20m, B12_60m, B8A_20m, B8A_60m, Product, SCL_20m,
-    SCL_60m, TCI_10m, TCI_20m, TCI_60m, WVP_10m, WVP_20m, WVP_60m, thumbnail, safe_manifest,
-    granule_metadata, inspire_metadata, product_metadata, datastrip_metadata
-
-    sample path for AWS JP2:
-    s3://sentinel-s2-l2a/tiles/51/K/XR/2020/7/31/0/R10m/
-    """
-    band_name_mapping = {
-        "AOT_10m": "aot",
-        "B01_20m": "coastal",
-        "B02_10m": "blue",
-        "B03_10m": "green",
-        "B04_10m": "red",
-        "B05_20m": "rededge1",
-        "B06_20m": "rededge2",
-        "B07_20m": "rededge3",
-        "B08_10m": "nir",
-        "B09_60m": "nir09",
-        "B11_20m": "swir16",
-        "B12_20m": "swir22",
-        "B8A_20m": "nir08",
-        "SCL_20m": "scl",
-        "TCI_10m": "visual",
-        "WVP_10m": "wvp",
-    }
-    path_base_scheme = "s3://sentinel-s2-l2a/tiles/{utm_zone}/{latitude_band}/{grid_square}/{year}/{month}/{day}/{count}"
-    s2tile = S2Tile.from_grid_code(item.properties["grid:code"])
-    if item.datetime is None:
-        raise ValueError(f"product {item.get_self_href()} does not have a timestamp")
-    product_basepath = MPath(
-        path_base_scheme.format(
-            utm_zone=s2tile.utm_zone,
-            latitude_band=s2tile.latitude_band,
-            grid_square=s2tile.grid_square,
-            year=item.datetime.year,
-            month=item.datetime.month,
-            day=item.datetime.day,
-            count=0,  # TODO: get count dynamically from metadata
-        )
-    )
-    new_assets = {}
-    for asset_name, asset in item.assets.items():
-        # ignore these assets
-        if asset_name in [
-            "Product",
-            "safe_manifest",
-            "product_metadata",
-            "inspire_metadata",
-            "datastrip_metadata",
-        ]:
-            continue
-        # set thumbnnail
-        elif asset_name == "thumbnail":
-            asset.href = str(product_basepath / "R60m" / "TCI.jp2")
-        # point to proper metadata
-        elif asset_name == "granule_metadata":
-            asset.href = str(product_basepath / "metadata.xml")
-        # change band asset names and point to their new locations
-        elif asset_name in band_name_mapping:
-            name, resolution = asset_name.split("_")
-            asset.href = product_basepath / f"R{resolution}" / f"{name}.jp2"
-            asset_name = band_name_mapping[asset_name]
-        else:
-            continue
-        new_assets[asset_name] = asset
-
-    item.assets = new_assets
-
-    item.properties["s2:datastrip_id"] = item.properties.get("eopf:datastrip_id")
-    return item
-
-
-class AWSL2ACOGv1(Archive):
-    """COG archive on AWS using E84 STAC search endpoint."""
-
-    catalog = EarthSearchV1S2L2A(
-        collections=["sentinel-2-l2a"],
-    )
-    item_modifier_funcs = [
-        item_fix_footprint,
-    ]
-    processing_level = ProcessingLevel.level2a
-
-
-class AWSL2AJP2(Archive):
-    """
-    JP2000 archive on AWS using dumb S3 path guesser.
-    """
-
-    catalog = AWSSearchCatalogS2L2A(
-        collections=["sentinel-s2-l2a"],
-    )
-    item_modifier_funcs = [
-        item_fix_footprint,
-        add_datastrip_id,
-    ]
-    processing_level = ProcessingLevel.level2a
-
-
-class AWSL2AJP2CSDE(Archive):
-    """
-    JP2000 archive on AWS using CDSE STAC search endpoint.
-    """
-
-    catalog = CDSESearch(
-        collections=["sentinel-2-l2a"],
-    )
-    item_modifier_funcs = [
-        item_fix_footprint,
-        map_cdse_paths_to_jp2_archive,
-        add_datastrip_id,
-    ]
-    processing_level = ProcessingLevel.level2a
-
-
-class CDSEL2AJP2CSDE(Archive):
-    """
-    JP2000 archive on CDSE (EODATA s3) using CDSE STAC search endpoint.
-    """
-
-    catalog = CDSESearch(
-        collections=["sentinel-2-l2a"],
-    )
-    item_modifier_funcs = [
-        item_fix_footprint,
-        add_datastrip_id,
-    ]
-    processing_level = ProcessingLevel.level2a
-
-
-class KnownArchives(Enum):
-    S2AWS_COG = AWSL2ACOGv1
-    S2AWS_JP2 = AWSL2AJP2
-    S2CDSE_AWSJP2 = AWSL2AJP2CSDE
-    S2CDSE_JP2 = CDSEL2AJP2CSDE

mapchete_eo/platforms/sentinel2/path_mappers/__init__.py

@@ -1,29 +0,0 @@
-from mapchete_eo.platforms.sentinel2.path_mappers.base import S2PathMapper
-from mapchete_eo.platforms.sentinel2.path_mappers.earthsearch import (
-    EarthSearchPathMapper,
-)
-from mapchete_eo.platforms.sentinel2.path_mappers.metadata_xml import XMLMapper
-from mapchete_eo.platforms.sentinel2.path_mappers.sinergise import SinergisePathMapper
-
-
-def default_path_mapper_guesser(
-    url: str,
-    **kwargs,
-) -> S2PathMapper:
-    """Guess S2PathMapper based on URL.
-
-    If a new path mapper is added in this module, it should also be added to this function
-    in order to be detected.
-    """
-    if url.startswith(
-        ("https://roda.sentinel-hub.com/sentinel-s2-l2a/", "s3://sentinel-s2-l2a/")
-    ) or url.startswith(
-        ("https://roda.sentinel-hub.com/sentinel-s2-l1c/", "s3://sentinel-s2-l1c/")
-    ):
-        return SinergisePathMapper(url, **kwargs)
-    elif url.startswith(
-        "https://sentinel-cogs.s3.us-west-2.amazonaws.com/sentinel-s2-l2a-cogs/"
-    ):
-        return EarthSearchPathMapper(url, **kwargs)
-    else:
-        return XMLMapper(url, **kwargs)

mapchete_eo/platforms/sentinel2/path_mappers/earthsearch.py

@@ -1,34 +0,0 @@
-from mapchete.path import MPath
-
-from mapchete_eo.platforms.sentinel2.path_mappers.sinergise import SinergisePathMapper
-from mapchete_eo.platforms.sentinel2.processing_baseline import ProcessingBaseline
-
-
-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)

mapchete_eo/platforms/sentinel2/path_mappers/sinergise.py

@@ -1,105 +0,0 @@
-from mapchete.path import MPath, MPathLike
-
-from mapchete_eo.platforms.sentinel2.path_mappers.base import S2PathMapper
-from mapchete_eo.platforms.sentinel2.processing_baseline import ProcessingBaseline
-from mapchete_eo.platforms.sentinel2.types import (
-    BandQI,
-    L2ABand,
-    ProductQI,
-    ProductQIMaskResolution,
-)
-
-
-class SinergisePathMapper(S2PathMapper):
-    """
-    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)