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

mapchete_eo/__init__.py

@@ -1 +1 @@
-__version__ = "2025.10.0"
+__version__ = "2025.10.1"

mapchete_eo/array/convert.py

@@ -2,6 +2,7 @@ from typing import List, Optional, Union
 
 import numpy as np
 import numpy.ma as ma
+from numpy.typing import DTypeLike
 import xarray as xr
 from mapchete.types import NodataVal
 
@@ -19,7 +20,9 @@ _NUMPY_FLOAT_DTYPES = [
 
 
 def to_masked_array(
-    xarr: Union[xr.Dataset, xr.DataArray], copy: bool = False
+    xarr: Union[xr.Dataset, xr.DataArray],
+    copy: bool = False,
+    out_dtype: Optional[DTypeLike] = None,
 ) -> ma.MaskedArray:
     """Convert xr.DataArray to ma.MaskedArray."""
     if isinstance(xarr, xr.Dataset):
@@ -31,6 +34,9 @@ def to_masked_array(
             "Cannot create masked_array because DataArray fill value is None"
         )
 
+    if out_dtype:
+        xarr = xarr.astype(out_dtype, copy=False)
+
     if xarr.dtype in _NUMPY_FLOAT_DTYPES:
         return ma.masked_values(xarr, fill_value, copy=copy, shrink=False)
     else:

mapchete_eo/base.py

@@ -6,6 +6,7 @@ from typing import Any, Callable, List, Optional, Type, Union
 
 import croniter
 from mapchete import Bounds
+import numpy as np
 import numpy.ma as ma
 import xarray as xr
 from dateutil.tz import tzutc
@@ -18,6 +19,8 @@ from mapchete.tile import BufferedTile
 from mapchete.types import MPathLike, NodataVal, NodataVals
 from pydantic import BaseModel
 from rasterio.enums import Resampling
+from rasterio.features import geometry_mask
+from shapely.geometry import mapping
 from shapely.geometry.base import BaseGeometry
 
 from mapchete_eo.archives.base import Archive
@@ -62,6 +65,7 @@ class EODataCube(base.InputTile):
     eo_bands: dict
     time: List[TimeRange]
     area: BaseGeometry
+    area_pixelbuffer: int = 0
 
     def __init__(
         self,
@@ -367,6 +371,29 @@ class EODataCube(base.InputTile):
             nodatavals=nodatavals,
             merge_products_by=merge_products_by,
             merge_method=merge_method,
+            read_mask=self.get_read_mask(),
+        )
+
+    def get_read_mask(self) -> np.ndarray:
+        """
+        Determine read mask according to input area.
+
+        This will generate a numpy array where pixel overlapping the input area
+        are set True and thus will get filled by the read function. Pixel outside
+        of the area are not considered for reading.
+
+        On staged reading, i.e. first checking the product masks to assess valid
+        pixels, this will avoid reading product bands in cases the product only covers
+        pixels outside of the intended reading area.
+        """
+        area = self.area.buffer(self.area_pixelbuffer * self.tile.pixel_x_size)
+        if area.is_empty:
+            return np.zeros((self.tile.shape), dtype=bool)
+        return geometry_mask(
+            geometries=[mapping(area)],
+            out_shape=self.tile.shape,
+            transform=self.tile.transform,
+            invert=True,
         )
 
 
@@ -443,8 +470,9 @@ class InputData(base.InputData):
                     input_params.get("delimiters", {}).get("bounds"),
                     crs=getattr(input_params.get("pyramid"), "crs"),
                 ),
+                raise_if_empty=False,
             )
-            return process_area.intersection(
+            process_area = process_area.intersection(
                 reproject_geometry(
                     configured_area,
                     src_crs=configured_area_crs or self.crs,

mapchete_eo/io/items.py

@@ -56,7 +56,7 @@ def item_to_np_array(
     return out
 
 
-def expand_params(param, length):
+def expand_params(param: Any, length: int) -> List[Any]:
     """
     Expand parameters if they are not a list.
     """
@@ -104,8 +104,10 @@ def get_item_property(
     | ``collection``     | The collection ID of an Item's collection.             |
     +--------------------+--------------------------------------------------------+
     """
-    if property in ["year", "month", "day", "date", "datetime"]:
-        if item.datetime is None:
+    if property == "id":
+        return item.id
+    elif property in ["year", "month", "day", "date", "datetime"]:
+        if item.datetime is None:  # pragma: no cover
             raise ValueError(
                 f"STAC item has no datetime attached, thus cannot get property {property}"
             )

mapchete_eo/io/levelled_cubes.py

@@ -40,27 +40,50 @@ def read_levelled_cube_to_np_array(
     raise_empty: bool = True,
     out_dtype: DTypeLike = np.uint16,
     out_fill_value: NodataVal = 0,
+    read_mask: Optional[np.ndarray] = None,
 ) -> ma.MaskedArray:
     """
     Read products as slices into a cube by filling up nodata gaps with next slice.
+
+    If a read_mask is provided, only the pixels marked True are considered to be read.
     """
-    if len(products) == 0:
+    if len(products) == 0:  # pragma: no cover
         raise NoSourceProducts("no products to read")
-
     bands = assets or eo_bands
-    if bands is None:
+    if bands is None:  # pragma: no cover
         raise ValueError("either assets or eo_bands have to be set")
-
     out_shape = (target_height, len(bands), *grid.shape)
+
+    # 2D read_mask shape
+    if read_mask is None:
+        read_mask = np.ones(grid.shape, dtype=bool)
+    elif read_mask.ndim != 2:  # pragma: no cover
+        raise ValueError(
+            "read_mask must be 2-dimensional, not %s-dimensional",
+            read_mask.ndim,
+        )
     out: ma.MaskedArray = ma.masked_array(
-        data=np.zeros(out_shape, dtype=out_dtype),
-        mask=np.ones(out_shape, dtype=out_dtype),
+        data=np.full(out_shape, out_fill_value, dtype=out_dtype),
+        mask=np.ones(out_shape, dtype=bool),
         fill_value=out_fill_value,
     )
+
+    if not read_mask.any():
+        logger.debug("nothing to read")
+        return out
+
+    # extrude mask to match each layer
+    layer_read_mask = np.stack([read_mask for _ in bands])
+
+    def _cube_read_mask() -> np.ndarray:
+        # This is only needed for debug output, thus there is no need to materialize always
+        return np.stack([layer_read_mask for _ in range(target_height)])
+
     logger.debug(
-        "empty cube with shape %s has %s",
+        "empty cube with shape %s has %s and %s pixels to be filled",
         out.shape,
         pretty_bytes(out.size * out.itemsize),
+        _cube_read_mask().sum(),
     )
 
     logger.debug("sort products into slices ...")
@@ -76,25 +99,25 @@ def read_levelled_cube_to_np_array(
     slices_read_count, slices_skip_count = 0, 0
 
     # pick slices one by one
-    for slice_count, slice in enumerate(slices, 1):
+    for slice_count, slice_ in enumerate(slices, 1):
         # all filled up? let's get outta here!
         if not out.mask.any():
-            logger.debug("cube is full, quitting!")
+            logger.debug("cube has no pixels to be filled, quitting!")
             break
 
         # generate 2D mask of holes to be filled in output cube
-        cube_nodata_mask = out.mask.any(axis=0).any(axis=0)
+        cube_nodata_mask = np.logical_and(out.mask.any(axis=0).any(axis=0), read_mask)
 
         # read slice
         try:
             logger.debug(
                 "see if slice %s %s has some of the %s unmasked pixels for cube",
                 slice_count,
-                slice,
+                slice_,
                 cube_nodata_mask.sum(),
             )
-            with slice.cached():
-                slice_array = slice.read(
+            with slice_.cached():
+                slice_array = slice_.read(
                     merge_method=merge_method,
                     product_read_kwargs=dict(
                         product_read_kwargs,
@@ -104,17 +127,18 @@ def read_levelled_cube_to_np_array(
                         resampling=resampling,
                         nodatavals=nodatavals,
                         raise_empty=raise_empty,
-                        target_mask=~cube_nodata_mask.copy(),
+                        read_mask=cube_nodata_mask.copy(),
+                        out_dtype=out_dtype,
                     ),
                 )
             slices_read_count += 1
         except (EmptySliceException, CorruptedSlice) as exc:
-            logger.debug("skipped slice %s: %s", slice, str(exc))
+            logger.debug("skipped slice %s: %s", slice_, str(exc))
             slices_skip_count += 1
             continue
 
         # if slice was not empty, fill pixels into cube
-        logger.debug("add slice %s array to cube", slice)
+        logger.debug("add slice %s array to cube", slice_)
 
         # iterate through layers of cube
         for layer_index in range(target_height):
@@ -124,34 +148,35 @@ def read_levelled_cube_to_np_array(
                 continue
 
             # determine empty patches of current layer
-            empty_patches = out[layer_index].mask.copy()
-            pixels_for_layer = (~slice_array[empty_patches].mask).sum()
+            empty_patches = np.logical_and(out[layer_index].mask, layer_read_mask)
+            remaining_pixels_for_layer = (~slice_array[empty_patches].mask).sum()
 
             # when slice has nothing to offer for this layer, skip
-            if pixels_for_layer == 0:
+            if remaining_pixels_for_layer == 0:
                 logger.debug(
                     "layer %s: slice has no pixels for this layer, jump to next",
                     layer_index,
                 )
                 continue
 
+            # insert slice data into empty patches of layer
             logger.debug(
                 "layer %s: fill with %s pixels ...",
                 layer_index,
-                pixels_for_layer,
+                remaining_pixels_for_layer,
             )
-            # insert slice data into empty patches of layer
             out[layer_index][empty_patches] = slice_array[empty_patches]
-            masked_pixels = out[layer_index].mask.sum()
-            total_pixels = out[layer_index].size
-            percent_full = round(
-                100 * ((total_pixels - masked_pixels) / total_pixels), 2
-            )
+
+            # report on layer fill status
             logger.debug(
-                "layer %s: %s%% filled (%s empty pixels remaining)",
+                "layer %s: %s",
                 layer_index,
-                percent_full,
-                out[layer_index].mask.sum(),
+                _percent_full(
+                    remaining=np.logical_and(
+                        out[layer_index].mask, layer_read_mask
+                    ).sum(),
+                    total=layer_read_mask.sum(),
+                ),
             )
 
             # remove slice values which were just inserted for next layer
@@ -161,13 +186,13 @@ def read_levelled_cube_to_np_array(
                 logger.debug("slice fully inserted into cube, skipping")
                 break
 
-        masked_pixels = out.mask.sum()
-        total_pixels = out.size
-        percent_full = round(100 * ((total_pixels - masked_pixels) / total_pixels), 2)
+        # report on layer fill status
         logger.debug(
-            "cube is %s%% filled (%s empty pixels remaining)",
-            percent_full,
-            masked_pixels,
+            "cube is %s",
+            _percent_full(
+                remaining=np.logical_and(out.mask, _cube_read_mask()).sum(),
+                total=_cube_read_mask().sum(),
+            ),
         )
 
     logger.debug(
@@ -197,6 +222,7 @@ def read_levelled_cube_to_xarray(
     band_axis_name: str = "bands",
     x_axis_name: str = "x",
     y_axis_name: str = "y",
+    read_mask: Optional[np.ndarray] = None,
 ) -> xr.Dataset:
     """
     Read products as slices into a cube by filling up nodata gaps with next slice.
@@ -218,6 +244,7 @@ def read_levelled_cube_to_xarray(
             sort=sort,
             product_read_kwargs=product_read_kwargs,
             raise_empty=raise_empty,
+            read_mask=read_mask,
         ),
         slice_names=[f"layer-{ii}" for ii in range(target_height)],
         band_names=variables,
@@ -226,3 +253,7 @@ def read_levelled_cube_to_xarray(
         x_axis_name=x_axis_name,
         y_axis_name=y_axis_name,
     )
+
+
+def _percent_full(remaining: int, total: int, ndigits: int = 2) -> str:
+    return f"{round(100 * (total - remaining) / total, ndigits=ndigits)}% full ({remaining} remaining emtpy pixels)"

mapchete_eo/io/products.py

@@ -10,6 +10,7 @@ from typing import Any, Dict, Generator, Iterator, List, Optional, Sequence
 from mapchete import Timer
 import numpy as np
 import numpy.ma as ma
+from numpy.typing import DTypeLike
 import xarray as xr
 from mapchete.config import get_hash
 from mapchete.geometry import to_shape
@@ -49,11 +50,13 @@ def products_to_np_array(
     sort: Optional[SortMethodConfig] = None,
     product_read_kwargs: dict = {},
     raise_empty: bool = True,
+    out_dtype: Optional[DTypeLike] = None,
+    read_mask: Optional[np.ndarray] = None,
 ) -> ma.MaskedArray:
     """Read grid window of EOProducts and merge into a 4D xarray."""
     return ma.stack(
         [
-            to_masked_array(s)
+            to_masked_array(s, out_dtype=out_dtype)
             for s in generate_slice_dataarrays(
                 products=products,
                 assets=assets,
@@ -66,6 +69,7 @@ def products_to_np_array(
                 sort=sort,
                 product_read_kwargs=product_read_kwargs,
                 raise_empty=raise_empty,
+                read_mask=read_mask,
             )
         ]
     )
@@ -87,6 +91,7 @@ def products_to_xarray(
     sort: Optional[SortMethodConfig] = None,
     raise_empty: bool = True,
     product_read_kwargs: dict = {},
+    read_mask: Optional[np.ndarray] = None,
 ) -> xr.Dataset:
     """Read grid window of EOProducts and merge into a 4D xarray."""
     data_vars = [
@@ -103,6 +108,7 @@ def products_to_xarray(
             sort=sort,
             product_read_kwargs=product_read_kwargs,
             raise_empty=raise_empty,
+            read_mask=read_mask,
         )
     ]
     if merge_products_by and merge_products_by not in ["date", "datetime"]:
@@ -322,8 +328,11 @@ def merge_products(
         valid_arrays = [a for a in arrays if not ma.getmaskarray(a).all()]
 
         if valid_arrays:
-            stacked = ma.stack(valid_arrays, dtype=out.dtype)
-            out = stacked.mean(axis=0, dtype=out.dtype)
+            out_dtype = out.dtype
+            out_fill_value = out.fill_value
+            stacked = ma.stack(valid_arrays, dtype=out_dtype)
+            out = stacked.mean(axis=0, dtype=out_dtype).astype(out_dtype, copy=False)
+            out.set_fill_value(out_fill_value)
         else:
             # All arrays were fully masked — return fully masked output
             out = ma.masked_all(out.shape, dtype=out.dtype)
@@ -351,10 +360,12 @@ def generate_slice_dataarrays(
     sort: Optional[SortMethodConfig] = None,
     product_read_kwargs: dict = {},
     raise_empty: bool = True,
+    read_mask: Optional[np.ndarray] = None,
 ) -> Iterator[xr.DataArray]:
     """
     Yield products or merged products into slices as DataArrays.
     """
+
     if len(products) == 0:
         raise NoSourceProducts("no products to read")
 
@@ -396,6 +407,7 @@ def generate_slice_dataarrays(
                             resampling=resampling,
                             nodatavals=nodatavals,
                             raise_empty=raise_empty,
+                            read_mask=read_mask,
                         ),
                         raise_empty=raise_empty,
                     ),

mapchete_eo/platforms/sentinel2/metadata_parser.py

@@ -161,10 +161,8 @@ class S2Metadata:
         return f"<S2Metadata id={self.product_id}, processing_baseline={self.processing_baseline}>"
 
     def clear_cached_data(self):
-        logger.debug("clear S2Metadata internal caches")
         self._cache = dict(viewing_incidence_angles=dict(), detector_footprints=dict())
         if self._cached_xml_root is not None:
-            logger.debug("clear S2Metadata xml cache")
             self._cached_xml_root.clear()
             self._cached_xml_root = None
         self.path_mapper.clear_cached_data()

mapchete_eo/platforms/sentinel2/product.py

@@ -195,7 +195,6 @@ class S2Product(EOProduct, EOProductProtocol):
         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
@@ -215,7 +214,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 +227,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:
@@ -464,13 +465,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!

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

mapchete_eo/product.py

@@ -113,7 +113,6 @@ class EOProduct(EOProductProtocol):
         nodatavals: NodataVals = None,
         raise_empty: bool = True,
         apply_offset: bool = True,
-        apply_scale: bool = False,
         **kwargs,
     ) -> ma.MaskedArray:
         assets = assets or []

mapchete_eo/search/base.py

@@ -1,3 +1,4 @@
+from functools import cached_property
 import json
 import logging
 from abc import ABC, abstractmethod
@@ -48,13 +49,25 @@ class CatalogSearcher(ABC):
     This class serves as a bridge between an Archive and a catalog implementation.
     """
 
-    eo_bands: List[str]
-    id: str
-    description: str
-    stac_extensions: List[str]
     collections: List[str]
     config_cls: Type[BaseModel]
 
+    @abstractmethod
+    @cached_property
+    def eo_bands(self) -> List[str]: ...
+
+    @abstractmethod
+    @cached_property
+    def id(self) -> str: ...
+
+    @abstractmethod
+    @cached_property
+    def description(self) -> str: ...
+
+    @abstractmethod
+    @cached_property
+    def stac_extensions(self) -> List[str]: ...
+
     @abstractmethod
     def search(
         self,
@@ -66,10 +79,10 @@ class CatalogSearcher(ABC):
 
 
 class StaticCatalogWriterMixin(CatalogSearcher):
-    client: Client
-    id: str
-    description: str
-    stac_extensions: List[str]
+    # client: Client
+    # id: str
+    # description: str
+    # stac_extensions: List[str]
 
     @abstractmethod
     def get_collections(self) -> List[Collection]:  # pragma: no cover

mapchete_eo/search/stac_search.py

@@ -36,17 +36,34 @@ class STACSearchCatalog(StaticCatalogWriterMixin, CatalogSearcher):
         stac_item_modifiers: Optional[List[Callable[[Item], Item]]] = None,
         endpoint: Optional[MPathLike] = None,
     ):
+        if endpoint is not None:
+            self.endpoint = endpoint
         if collections:
             self.collections = collections
         else:  # pragma: no cover
             raise ValueError("collections must be given")
-        self.client = Client.open(endpoint or self.endpoint)
-        self.id = self.client.id
-        self.description = self.client.description
-        self.stac_extensions = self.client.stac_extensions
-        self.eo_bands = self._eo_bands()
         self.stac_item_modifiers = stac_item_modifiers
 
+    @cached_property
+    def client(self) -> Client:
+        return Client.open(self.endpoint)
+
+    @cached_property
+    def eo_bands(self) -> List[str]:
+        return self._eo_bands()
+
+    @cached_property
+    def id(self) -> str:
+        return self.client.id
+
+    @cached_property
+    def description(self) -> str:
+        return self.client.description
+
+    @cached_property
+    def stac_extensions(self) -> List[str]:
+        return self.client.stac_extensions
+
     def search(
         self,
         time: Optional[Union[TimeRange, List[TimeRange]]] = None,

mapchete_eo/search/stac_static.py

@@ -1,3 +1,4 @@
+from functools import cached_property
 import logging
 import warnings
 from typing import Any, Callable, Dict, Generator, List, Optional, Union
@@ -37,13 +38,25 @@ class STACStaticCatalog(StaticCatalogWriterMixin, CatalogSearcher):
         stac_item_modifiers: Optional[List[Callable[[Item], Item]]] = None,
     ):
         self.client = Client.from_file(str(baseurl), stac_io=FSSpecStacIO())
-        self.id = self.client.id
-        self.description = self.client.description
-        self.stac_extensions = self.client.stac_extensions
         self.collections = [c.id for c in self.client.get_children()]
-        self.eo_bands = self._eo_bands()
         self.stac_item_modifiers = stac_item_modifiers
 
+    @cached_property
+    def eo_bands(self) -> List[str]:
+        return self._eo_bands()
+
+    @cached_property
+    def id(self) -> str:
+        return self.client.id
+
+    @cached_property
+    def description(self) -> str:
+        return self.client.description
+
+    @cached_property
+    def stac_extensions(self) -> List[str]:
+        return self.client.stac_extensions
+
     def search(
         self,
         time: Optional[Union[TimeRange, List[TimeRange]]] = None,

mapchete_eo/search/utm_search.py

@@ -1,4 +1,5 @@
 import datetime
+from functools import cached_property
 import logging
 from typing import Any, Callable, Dict, Generator, List, Optional, Set, Union
 
@@ -51,9 +52,12 @@ class UTMSearchCatalog(StaticCatalogWriterMixin, CatalogSearcher):
         if len(collections) == 0:  # pragma: no cover
             raise ValueError("no collections provided")
         self.collections = collections
-        self.eo_bands = self._eo_bands()
         self.stac_item_modifiers = stac_item_modifiers
 
+    @cached_property
+    def eo_bands(self) -> List[str]:  # pragma: no cover
+        return self._eo_bands()
+
     def search(
         self,
         time: Optional[Union[TimeRange, List[TimeRange]]] = None,

mapchete_eo/sort.py

@@ -5,7 +5,9 @@ This module holds all code required to sort products or slices.
 from typing import Callable, List, Optional
 
 from pydantic import BaseModel
+from pystac import Item
 
+from mapchete_eo.io.items import get_item_property
 from mapchete_eo.protocols import DateTimeProtocol
 from mapchete_eo.time import timedelta, to_datetime
 from mapchete_eo.types import DateTimeLike
@@ -22,7 +24,7 @@ def sort_objects_by_target_date(
     **kwargs,
 ) -> List[DateTimeProtocol]:
     """
-    Return sorted list of onjects according to their distance to the target_date.
+    Return sorted list of objects according to their distance to the target_date.
 
     Default for target date is the middle between the objects start date and end date.
     """
@@ -46,3 +48,17 @@ class TargetDateSort(SortMethodConfig):
     func: Callable = sort_objects_by_target_date
     target_date: Optional[DateTimeLike] = None
     reverse: bool = False
+
+
+def sort_objects_by_cloud_cover(
+    objects: List[Item], reverse: bool = False
+) -> List[Item]:
+    if len(objects) == 0:  # pragma: no cover
+        return objects
+    objects.sort(key=lambda x: get_item_property(x, "eo:cloud_cover"), reverse=reverse)
+    return objects
+
+
+class CloudCoverSort(SortMethodConfig):
+    func: Callable = sort_objects_by_cloud_cover
+    reverse: bool = False

{mapchete_eo-2025.10.0.dist-info → mapchete_eo-2025.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapchete-eo
-Version: 2025.10.0
+Version: 2025.10.1
 Summary: mapchete EO data reader
 Project-URL: Homepage, https://gitlab.eox.at/maps/mapchete_eo
 Author-email: Joachim Ungar <joachim.ungar@eox.at>, Petr Sevcik <petr.sevcik@eox.at>

{mapchete_eo-2025.10.0.dist-info → mapchete_eo-2025.10.1.dist-info}/RECORD

@@ -1,14 +1,14 @@
-mapchete_eo/__init__.py,sha256=HtoUGacYQ9lSC7EssjuZ7xIyD0DlTBcOEDAUU3Qep04,26
-mapchete_eo/base.py,sha256=Ka1HDqKeeTZYgnhW2LFpgR1AaI9buXCrbNztXWkxU78,19164
+mapchete_eo/__init__.py,sha256=r2vzraIeM6daquybaheJf__iYb9hpxuEfM5uy2Ygulg,26
+mapchete_eo/base.py,sha256=G4DFwU9AjzWLfF_8hWPKmjsBhpwtJxQ_Z31-uZjAeFc,20294
 mapchete_eo/blacklist.txt,sha256=6KhBY0jNjXgRpKRvKJoOTswvNUoP56IrIcNeCYnd2qo,17471
 mapchete_eo/eostac.py,sha256=5K08Mr4wm-VOXTEvTB6DQHX7rbFLYw8mjW1wlpPltC0,574
 mapchete_eo/exceptions.py,sha256=ul7_9o6_SfJXQPsDOQqRBhh09xv2t4AwHl6YJ7yWN5s,2150
 mapchete_eo/geometry.py,sha256=NiLeXSnp2c_AsBin8XUFzlr_ndqHbKos-dHQSDApIro,9420
 mapchete_eo/known_catalogs.py,sha256=dlxImeNwaUVuss-sGddixTcxjcrznyR-XWKfkX9S5PA,1274
-mapchete_eo/product.py,sha256=t7Hj_0FEIK_yboXcSm3sEUD2tpUMROLMsJBBen-MncE,9558
+mapchete_eo/product.py,sha256=_KULHdTWbUw0TkRfpm8xvD2qukhuMmm9ov7cJz9aY18,9523
 mapchete_eo/protocols.py,sha256=_WxiHPgErDjiJ0dzWJiWjHm0ZgoDlG16oEw1X1fzUXc,1512
 mapchete_eo/settings.py,sha256=-i4UPX0KJ7NWGpGzOUkhzCABOMz2xc-q3sVLBFT4JAM,696
-mapchete_eo/sort.py,sha256=k2QgZyn4xZ2vx8MgfbAZBA5YM4P-tQOzzsQ1mSTESUc,1350
+mapchete_eo/sort.py,sha256=puj3YBTL-AikC--CZwvfYCKVQWy7URMUzobf2rm9FGU,1817
 mapchete_eo/time.py,sha256=mCIrn6C-B7CDoFIIM4u8pG15nVV8KWQixF2fuhdDTdE,1799
 mapchete_eo/types.py,sha256=yIHKZHlGCSerJzDBS2AH7yYLun4rY3rZZ73SCKiN26U,1814
 mapchete_eo/archives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -16,7 +16,7 @@ mapchete_eo/archives/base.py,sha256=32NCFg46p95Uv3rO-M0Y-W6iCH4BzLtfUHpHfyzzrC4,
 mapchete_eo/array/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mapchete_eo/array/buffer.py,sha256=GeeM7RVQ-Z_SKlkaeztWUrxEsa_yck-nXwXRIM3w0_I,483
 mapchete_eo/array/color.py,sha256=ArJ3-0qjJJGAlRQodLios6JwD0uHLSRRb9BwfB31v-U,810
-mapchete_eo/array/convert.py,sha256=LhNlTtAeZpDy2zI58zvqOmQLw9GYjvgroHMiD7Y0PiE,5238
+mapchete_eo/array/convert.py,sha256=oimklMfyS2XxQLd73zQ2cr9aE-39z1UIt6ry_2ZQI10,5390
 mapchete_eo/cli/__init__.py,sha256=SRRilPKUtwsUCi1GdMNPxjIrCM-XyYM2hK1T9vvKUI8,946
 mapchete_eo/cli/bounds.py,sha256=QcOXOXMcnd8ecwiCFVWukTLUFIkpj9SbB3ot-GA4heA,551
 mapchete_eo/cli/options_arguments.py,sha256=6rnnABT8WU6DF6vvy7lGDj5-OpMMo1Vb36fL1oan56c,7344
@@ -40,10 +40,10 @@ mapchete_eo/image_operations/linear_normalization.py,sha256=-eQX3WLCUYWUv-um3s1u
 mapchete_eo/image_operations/sigmoidal.py,sha256=IKU8F89HhQJWGUVmIrnkuhqzn_ztlGrTf8xXZaVQWzU,3575
 mapchete_eo/io/__init__.py,sha256=1-1g4cESZZREvyumEUABZhDwgVuSxtxdqbNlLuVKlow,950
 mapchete_eo/io/assets.py,sha256=8OrqvrCzJOY0pExh_vKRL7Bz_RGk6M_LfayQqxHo8ag,17014
-mapchete_eo/io/items.py,sha256=FDDMRtFvNNL3Iwf0xiaSI8G3s-54vhqfYKo7xzCQq-w,5657
-mapchete_eo/io/levelled_cubes.py,sha256=Bhl4LM39eueKHW-BOT2LlXkWn7Kgdhp22mfLAkYrK9A,7782
+mapchete_eo/io/items.py,sha256=7l6A5E6fDNOAx7cjvu3VDP1WlD-ufEUBzt1uBBRD80Q,5750
+mapchete_eo/io/levelled_cubes.py,sha256=ZF7BLn9MHnJCCDjAoR9D7MNbHdusjJ9EACdM7rKNlyM,9018
 mapchete_eo/io/path.py,sha256=y5aYr-dE-0BafgF1_RCSXCvbF3taCI-EOz0R58rNxO8,4413
-mapchete_eo/io/products.py,sha256=3tsMCv3ksKL5DSIdSPN6_1e58gHXA0khzURTGuQD7TY,14121
+mapchete_eo/io/products.py,sha256=2IdReyvVNY06BHUgdb7EwePqrUL0bL070c6Dnv6RhB0,14627
 mapchete_eo/io/profiles.py,sha256=l9YiXbKYs674xz6NLy5EAq3fBEvHTVSf_gopXD-CuSY,935
 mapchete_eo/platforms/sentinel2/__init__.py,sha256=zAyBzOhwKSIyNJyfEpyY6G-PxPDhLvOCky8aA2PsW_k,390
 mapchete_eo/platforms/sentinel2/archives.py,sha256=uhIY0EUta45Ka94ky35NZ33Hxi0qPA2yIu21ad1z6CQ,5830
@@ -51,10 +51,10 @@ mapchete_eo/platforms/sentinel2/bandpass_adjustment.py,sha256=DA0cQtjr8UH7r_kizA
 mapchete_eo/platforms/sentinel2/config.py,sha256=Mn_uw2bdR6gcIWPS_istY6E5HaN6JLuxQO05HtEovNU,5974
 mapchete_eo/platforms/sentinel2/driver.py,sha256=ny9Rfnvi07NeB29RwimqBIF7BbCxPPRfZO_rfDJyWzI,2776
 mapchete_eo/platforms/sentinel2/masks.py,sha256=6ig8sQhXkm1u6Bwbe7n8ewW8gTdbVJp-iaDCk780Qxg,11220
-mapchete_eo/platforms/sentinel2/metadata_parser.py,sha256=M1w6sdKx0u_BFxHMsjx8TsSx1v7p5C16cZc8_FOQpns,26835
+mapchete_eo/platforms/sentinel2/metadata_parser.py,sha256=czh-2M_r79sWFbZETk_-0eOyvonbhaY7Hkb3tRTeF5A,26723
 mapchete_eo/platforms/sentinel2/preprocessing_tasks.py,sha256=eJh1wSDsQkEKtQ6G6vmVkFBoBl5nZUV5vNHQM4RifQg,772
 mapchete_eo/platforms/sentinel2/processing_baseline.py,sha256=B2-t5H7xC54g2aIvcdBSRQPHygfqccbKEhXSgClAADY,5085
-mapchete_eo/platforms/sentinel2/product.py,sha256=2FvHSS52Bqur1dn-D1RHnPeTVzqVv3XpfHWf2MeGes8,25368
+mapchete_eo/platforms/sentinel2/product.py,sha256=9grX6TGCryVxS8TH6Lzc-yca-8zKzCx_WD1r3_bPK9E,25376
 mapchete_eo/platforms/sentinel2/types.py,sha256=Cd0bmDT1mLETuSJYEAoF8Kl4-QOPv2fFrwgR8xHTka0,2009
 mapchete_eo/platforms/sentinel2/brdf/__init__.py,sha256=W7zAJZ5F5Xla7j4ua2opRANUbcD3jZbhTwhW5_cpOUI,242
 mapchete_eo/platforms/sentinel2/brdf/config.py,sha256=v3WCEu4r-tEPQgWBEkYNAPLgCQobvYtQ2YiDeAdImMk,1133
@@ -73,16 +73,16 @@ mapchete_eo/processes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 mapchete_eo/processes/config.py,sha256=WorMzHJzJaZPh-aEyEEwcXN08ALxn6zAhVMrjkDUWDU,1745
 mapchete_eo/processes/dtype_scale.py,sha256=7hJlIe2DsE6Kmk1c3PLwLr8rnn_4_9S6Cz7bmRuzP9M,4176
 mapchete_eo/processes/eo_to_xarray.py,sha256=Gcp4qju2C9S8KeUnVY5f3nAsrdckPhGRguzsgRtWBFs,514
-mapchete_eo/processes/merge_rasters.py,sha256=f9QG8_nIJRIVYC-hkq9hcmQOZIdoRzAWsJp1OlRS4qQ,8316
+mapchete_eo/processes/merge_rasters.py,sha256=jSXUI8pEWXbQWrM9iMtrH4ACH2VkCaBUH9CQg4z6zLA,8486
 mapchete_eo/search/__init__.py,sha256=71VuR1BFFbFiV9rae5qXt0RLtwWk1DP_CYbZflMZDWA,516
-mapchete_eo/search/base.py,sha256=8B7bg6dj3n79lv9SalVMVjjLth12AIcTuqJjyggZLCk,8601
+mapchete_eo/search/base.py,sha256=LQfCwsZW5YFZx5pvyNSpfDbcObB-UGypjfrvL-3VUZE,8883
 mapchete_eo/search/config.py,sha256=0idsjXt2T8scerlw-PzNVc0u8JxpOxHgrEO2asSRtNE,1122
 mapchete_eo/search/s2_mgrs.py,sha256=5LWl9c7WzFvXODr9f8m37cv-8yyf-LvnN0-TSSPcXKM,10868
-mapchete_eo/search/stac_search.py,sha256=YnISHpdvMJfrY_wfM1dHOtHYqgsbXsYLMYrRdJlAZTo,9551
-mapchete_eo/search/stac_static.py,sha256=P1C2OC33UopV80xIvFeL-HbOuaxxe7qsPDdnkU8IXcA,8613
-mapchete_eo/search/utm_search.py,sha256=wKrG2KwqL2fjSrkDUTZuRayiVAR27BtWpX-PFab0Dng,9646
-mapchete_eo-2025.10.0.dist-info/METADATA,sha256=IUBh6j50RcAjOSWYsJ5UPME5ahbnaFAf9H0YtLK-1sM,3237
-mapchete_eo-2025.10.0.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-mapchete_eo-2025.10.0.dist-info/entry_points.txt,sha256=ewk6R4FGdAclOnUpikhlPZGWI40MWeksVIIwu4jVebk,324
-mapchete_eo-2025.10.0.dist-info/licenses/LICENSE,sha256=TC5JwvBnFrUgsSQSCDFPc3cqlbth2N0q8MWrhY1EVd0,1089
-mapchete_eo-2025.10.0.dist-info/RECORD,,
+mapchete_eo/search/stac_search.py,sha256=TXsCSMi3PBst80_vexXv0pvY5DNcD8sgtsw3zOQtoRA,9844
+mapchete_eo/search/stac_static.py,sha256=3PA1uUIQy0bHywFA3_hmyn65pjlWEqeCW4Gx2DdZMZI,8839
+mapchete_eo/search/utm_search.py,sha256=__HZCw5no9_8Rb6kO1pCfCEUS_ZwmgrVwlcyE78SY6k,9754
+mapchete_eo-2025.10.1.dist-info/METADATA,sha256=edkh71VZo0bygu4yQ44RIeR9CnshfudaH-HOx76lg7w,3237
+mapchete_eo-2025.10.1.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+mapchete_eo-2025.10.1.dist-info/entry_points.txt,sha256=ewk6R4FGdAclOnUpikhlPZGWI40MWeksVIIwu4jVebk,324
+mapchete_eo-2025.10.1.dist-info/licenses/LICENSE,sha256=TC5JwvBnFrUgsSQSCDFPc3cqlbth2N0q8MWrhY1EVd0,1089
+mapchete_eo-2025.10.1.dist-info/RECORD,,