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

mapchete_eo/search/stac_static.py

@@ -1,22 +1,21 @@
 from functools import cached_property
 import logging
 import warnings
-from typing import Any, Callable, Dict, Generator, List, Optional, Union
+from typing import Any, Dict, Generator, List, Optional, Union
 
 from mapchete import Bounds
 from mapchete.types import BoundsLike
 from pystac import Item, Catalog, Collection
 from mapchete.io.vector import bounds_intersect
-from mapchete.path import MPathLike
 from pystac.stac_io import StacIO
-from pystac_client import Client
+from pystac_client import CollectionClient
 from shapely.geometry import shape
 from shapely.geometry.base import BaseGeometry
 
 from mapchete_eo.search.base import (
-    CatalogSearcher,
+    CollectionSearcher,
     FSSpecStacIO,
-    StaticCatalogWriterMixin,
+    StaticCollectionWriterMixin,
     filter_items,
 )
 from mapchete_eo.search.config import StacStaticConfig
@@ -29,21 +28,42 @@ logger = logging.getLogger(__name__)
 StacIO.set_default(FSSpecStacIO)
 
 
-class STACStaticCatalog(StaticCatalogWriterMixin, CatalogSearcher):
+class STACStaticCollection(StaticCollectionWriterMixin, CollectionSearcher):
     config_cls = StacStaticConfig
 
-    def __init__(
-        self,
-        baseurl: MPathLike,
-        stac_item_modifiers: Optional[List[Callable[[Item], Item]]] = None,
-    ):
-        self.client = Client.from_file(str(baseurl), stac_io=FSSpecStacIO())
-        self.collections = [c.id for c in self.client.get_children()]
-        self.stac_item_modifiers = stac_item_modifiers
+    @cached_property
+    def client(self) -> CollectionClient:
+        return CollectionClient.from_file(str(self.collection), stac_io=FSSpecStacIO())
 
     @cached_property
     def eo_bands(self) -> List[str]:
-        return self._eo_bands()
+        eo_bands = self.client.extra_fields.get("properties", {}).get("eo:bands")
+        if eo_bands:
+            return eo_bands
+        else:
+            warnings.warn(
+                "Unable to read eo:bands definition from collection. "
+                "Trying now to get information from assets ..."
+            )
+            # see if eo:bands can be found in properties
+            try:
+                item = next(self.client.get_items(recursive=True))
+                eo_bands = item.properties.get("eo:bands")
+                if eo_bands:
+                    return eo_bands
+
+                # look through the assets and collect eo:bands
+                out = {}
+                for asset in item.assets.values():
+                    for eo_band in asset.extra_fields.get("eo:bands", []):
+                        out[eo_band["name"]] = eo_band
+                if out:
+                    return [v for v in out.values()]
+            except StopIteration:
+                pass
+
+            logger.debug("cannot find eo:bands definition")
+            return []
 
     @cached_property
     def id(self) -> str:
@@ -62,16 +82,13 @@ class STACStaticCatalog(StaticCatalogWriterMixin, CatalogSearcher):
         time: Optional[Union[TimeRange, List[TimeRange]]] = None,
         bounds: Optional[BoundsLike] = None,
         area: Optional[BaseGeometry] = None,
+        query: Optional[str] = None,
         search_kwargs: Optional[Dict[str, Any]] = None,
     ) -> Generator[Item, None, None]:
-        config = self.config_cls(**search_kwargs or {})
         if area is None and bounds:
             bounds = Bounds.from_inp(bounds)
             area = shape(bounds)
-        for item in filter_items(
-            self._raw_search(time=time, area=area),
-            max_cloud_cover=config.max_cloud_cover,
-        ):
+        for item in filter_items(self._raw_search(time=time, area=area), query=query):
             yield item
 
     def _raw_search(
@@ -82,83 +99,22 @@ class STACStaticCatalog(StaticCatalogWriterMixin, CatalogSearcher):
         if area is not None and area.is_empty:
             return
         logger.debug("iterate through children")
-        for collection in self.client.get_collections():
-            if time:
-                for time_range in time if isinstance(time, list) else [time]:
-                    for item in _all_intersecting_items(
-                        collection,
-                        area=area,
-                        time_range=time_range,
-                    ):
-                        item.make_asset_hrefs_absolute()
-                        yield item
-            else:
+        if time:
+            for time_range in time if isinstance(time, list) else [time]:
                 for item in _all_intersecting_items(
-                    collection,
+                    self.client,
                     area=area,
+                    time_range=time_range,
                 ):
                     item.make_asset_hrefs_absolute()
                     yield item
-
-    def _eo_bands(self) -> List[str]:
-        for collection in self.client.get_children():
-            eo_bands = collection.extra_fields.get("properties", {}).get("eo:bands")
-            if eo_bands:
-                return eo_bands
-        else:
-            warnings.warn(
-                "Unable to read eo:bands definition from collections. "
-                "Trying now to get information from assets ..."
-            )
-
-            # see if eo:bands can be found in properties
-            item = _get_first_item(self.client.get_children())
-            eo_bands = item.properties.get("eo:bands")
-            if eo_bands:
-                return eo_bands
-
-            # look through the assets and collect eo:bands
-            out = {}
-            for asset in item.assets.values():
-                for eo_band in asset.extra_fields.get("eo:bands", []):
-                    out[eo_band["name"]] = eo_band
-            if out:
-                return [v for v in out.values()]
-
-            logger.debug("cannot find eo:bands definition")
-            return []
-
-    def get_collections(
-        self,
-        time: Optional[Union[TimeRange, List[TimeRange]]] = None,
-        bounds: Optional[BoundsLike] = None,
-        area: Optional[BaseGeometry] = None,
-    ):
-        if area is None and bounds is not None:
-            area = Bounds.from_inp(bounds).geometry
-        for collection in self.client.get_children():
-            if time:
-                for time_range in time if isinstance(time, list) else [time]:
-                    if _collection_extent_intersects(
-                        collection,
-                        area=area,
-                        time_range=time_range,
-                    ):
-                        yield collection
-            else:
-                if _collection_extent_intersects(collection, area=area):
-                    yield collection
-
-
-def _get_first_item(collections):
-    for collection in collections:
-        for item in collection.get_all_items():
-            return item
         else:
-            for child in collection.get_children():
-                return _get_first_item(child)
-    else:
-        raise ValueError("collections contain no items")
+            for item in _all_intersecting_items(
+                self.client,
+                area=area,
+            ):
+                item.make_asset_hrefs_absolute()
+                yield item
 
 
 def _all_intersecting_items(

mapchete_eo/search/utm_search.py

@@ -1,7 +1,7 @@
 import datetime
 from functools import cached_property
 import logging
-from typing import Any, Callable, Dict, Generator, List, Optional, Set, Union
+from typing import Any, Dict, Generator, List, Optional, Set, Union
 
 from mapchete.io.vector import fiona_open
 from mapchete.path import MPath, MPathLike
@@ -15,8 +15,8 @@ from shapely.geometry.base import BaseGeometry
 from mapchete_eo.exceptions import ItemGeometryError
 from mapchete_eo.product import blacklist_products
 from mapchete_eo.search.base import (
-    CatalogSearcher,
-    StaticCatalogWriterMixin,
+    CollectionSearcher,
+    StaticCollectionWriterMixin,
     filter_items,
 )
 from mapchete_eo.search.config import UTMSearchConfig
@@ -28,7 +28,7 @@ from mapchete_eo.types import TimeRange
 logger = logging.getLogger(__name__)
 
 
-class UTMSearchCatalog(StaticCatalogWriterMixin, CatalogSearcher):
+class UTMSearchCatalog(StaticCollectionWriterMixin, CollectionSearcher):
     endpoint: str
     id: str
     day_subdir_schema: str
@@ -42,36 +42,41 @@ class UTMSearchCatalog(StaticCatalogWriterMixin, CatalogSearcher):
     )
     config_cls = UTMSearchConfig
 
-    def __init__(
-        self,
-        endpoint: Optional[MPathLike] = None,
-        collections: List[str] = [],
-        stac_item_modifiers: Optional[List[Callable[[Item], Item]]] = None,
-    ):
-        self.endpoint = endpoint or self.endpoint
-        if len(collections) == 0:  # pragma: no cover
-            raise ValueError("no collections provided")
-        self.collections = collections
-        self.stac_item_modifiers = stac_item_modifiers
-
     @cached_property
     def eo_bands(self) -> List[str]:  # pragma: no cover
-        return self._eo_bands()
+        for (
+            collection_properties
+        ) in UTMSearchConfig().sinergise_aws_collections.values():
+            if collection_properties["id"] == self.collection.split("/")[-1]:
+                collection = Collection.from_dict(
+                    collection_properties["path"].read_json()
+                )
+                if collection:
+                    summary = collection.summaries.to_dict()
+                    if "eo:bands" in summary:
+                        return summary["eo:bands"]
+                else:
+                    raise ValueError(f"cannot find collection {collection}")
+        else:
+            logger.debug(
+                "cannot find eo:bands definition from collection %s",
+                self.collection,
+            )
+            return []
 
     def search(
         self,
         time: Optional[Union[TimeRange, List[TimeRange]]] = None,
         bounds: Optional[BoundsLike] = None,
         area: Optional[BaseGeometry] = None,
+        query: Optional[str] = None,
         search_kwargs: Optional[Dict[str, Any]] = None,
     ) -> Generator[Item, None, None]:
-        config = self.config_cls(**search_kwargs or {})
-        if bounds:
-            bounds = Bounds.from_inp(bounds)
-
         for item in filter_items(
-            self._raw_search(time=time, bounds=bounds, area=area),
-            max_cloud_cover=config.max_cloud_cover,
+            self._raw_search(
+                time=time, bounds=Bounds.from_inp(bounds) if bounds else None, area=area
+            ),
+            query=query,
         ):
             yield item
 
@@ -92,7 +97,12 @@ class UTMSearchCatalog(StaticCatalogWriterMixin, CatalogSearcher):
         elif bounds is not None:
             bounds = Bounds.from_inp(bounds)
             area = shape(bounds)
-        for time_range in time if isinstance(time, list) else [time]:
+
+        # Cleaner time list in case None present as time (undefined)
+        time_list: list[TimeRange] = (
+            [t for t in time if t is not None] if isinstance(time, list) else [time]
+        )
+        for time_range in time_list:
             start_time = (
                 time_range.start
                 if isinstance(time_range.start, datetime.date)
@@ -151,28 +161,6 @@ class UTMSearchCatalog(StaticCatalogWriterMixin, CatalogSearcher):
                     elif area.intersects(shape(item.geometry)):
                         yield item
 
-    def _eo_bands(self) -> list:
-        for collection_name in self.collections:
-            for (
-                collection_properties
-            ) in UTMSearchConfig().sinergise_aws_collections.values():
-                if collection_properties["id"] == collection_name:
-                    collection = Collection.from_dict(
-                        collection_properties["path"].read_json()
-                    )
-                    if collection:
-                        summary = collection.summaries.to_dict()
-                        if "eo:bands" in summary:
-                            return summary["eo:bands"]
-                    else:
-                        raise ValueError(f"cannot find collection {collection}")
-        else:
-            logger.debug(
-                "cannot find eo:bands definition from collections %s",
-                self.collections,
-            )
-            return []
-
     def get_collections(self):
         """
         yeild transformed collection from:
@@ -182,9 +170,8 @@ class UTMSearchCatalog(StaticCatalogWriterMixin, CatalogSearcher):
         """
         for collection_properties in self.config.sinergise_aws_collections.values():
             collection = Collection.from_dict(collection_properties["path"].read_json())
-            for collection_name in self.collections:
-                if collection_name == collection.id:
-                    yield collection
+            if self.collection.split("/")[-1] == collection.id:
+                yield collection
 
 
 def items_from_static_index(

mapchete_eo/settings.py

@@ -16,6 +16,7 @@ class Settings(BaseSettings):
     default_cache_location: MPathLike = MPath("s3://eox-mhub-cache/")
     default_catalog_crs: CRS = CRS.from_epsg(4326)
     blacklist: Optional[MPathLike] = None
+    lazy_load_stac_items: bool = True
 
     # read from environment
     model_config = SettingsConfigDict(env_prefix="MAPCHETE_EO_")

mapchete_eo/sort.py

@@ -5,10 +5,8 @@ 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.protocols import DateTimeProtocol, GetPropertyProtocol
 from mapchete_eo.time import timedelta, to_datetime
 from mapchete_eo.types import DateTimeLike
 
@@ -51,11 +49,11 @@ class TargetDateSort(SortMethodConfig):
 
 
 def sort_objects_by_cloud_cover(
-    objects: List[Item], reverse: bool = False
-) -> List[Item]:
+    objects: List[GetPropertyProtocol], reverse: bool = False
+) -> List[GetPropertyProtocol]:
     if len(objects) == 0:  # pragma: no cover
         return objects
-    objects.sort(key=lambda x: get_item_property(x, "eo:cloud_cover"), reverse=reverse)
+    objects.sort(key=lambda x: x.get_property("eo:cloud_cover"), reverse=reverse)
     return objects
 
 

mapchete_eo/source.py

@@ -0,0 +1,107 @@
+from functools import cached_property
+from typing import Any, Dict, List, Literal, Optional, Generator, Union, Callable
+
+from mapchete.bounds import Bounds
+from mapchete.path import MPath
+from mapchete.types import BoundsLike, CRSLike, MPathLike
+from pydantic import BaseModel, ConfigDict, model_validator
+from pystac import Item
+from shapely.geometry.base import BaseGeometry
+from shapely.errors import GEOSException
+
+from mapchete_eo.exceptions import ItemGeometryError
+from mapchete_eo.search.base import CollectionSearcher
+from mapchete_eo.search import STACSearchCollection, STACStaticCollection
+from mapchete_eo.settings import mapchete_eo_settings
+from mapchete_eo.types import TimeRange
+
+
+class Source(BaseModel):
+    """All information required to consume EO products."""
+
+    collection: str
+    catalog_crs: Optional[CRSLike] = mapchete_eo_settings.default_catalog_crs
+    query: Optional[str] = None
+    area: Optional[Union[MPathLike, dict, type[BaseGeometry]]] = None
+    bounds: Optional[BoundsLike] = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    @property
+    def item_modifier_funcs(self) -> List[Callable]:
+        return []
+
+    @cached_property
+    def catalog_type(self) -> Literal["search", "static"]:
+        # TODO: stupid test but probably sufficient
+        return "static" if self.collection.endswith(".json") else "search"
+
+    def _spatial_subset(
+        self,
+        bounds: Optional[BoundsLike] = None,
+        area: Optional[BaseGeometry] = None,
+    ) -> Dict[str, Any]:
+        """Combine bounds and area with bounds defined in Source if any."""
+        if self.bounds is None:
+            return {"bounds": bounds, "area": area}
+        self_bounds = Bounds.from_inp(self.bounds)
+        out = dict()
+        if bounds is not None:
+            bounds = Bounds.from_inp(bounds)
+            if bounds.intersects(self_bounds):
+                out["bounds"] = Bounds.from_inp(
+                    bounds.geometry.intersection(self_bounds.geometry)
+                )
+        if area is not None:
+            out["area"] = area.intersection(self_bounds.geometry)
+        return out
+
+    def search(
+        self,
+        time: Optional[Union[TimeRange, List[TimeRange]]] = None,
+        bounds: Optional[BoundsLike] = None,
+        area: Optional[BaseGeometry] = None,
+        base_dir: Optional[MPathLike] = None,
+    ) -> Generator[Item, None, None]:
+        for item in self.get_catalog(base_dir=base_dir).search(
+            time=time,
+            query=self.query,
+            search_kwargs=dict(query=self.query) if self.query else None,
+            **self._spatial_subset(
+                bounds=bounds,
+                area=area,
+            ),
+        ):
+            yield self.apply_item_modifier_funcs(item)
+
+    def apply_item_modifier_funcs(self, item: Item) -> Item:
+        try:
+            for modifier in self.item_modifier_funcs:
+                item = modifier(item)
+        except GEOSException as exc:
+            raise ItemGeometryError(
+                f"item {item.get_self_href()} geometry could not be resolved: {str(exc)}"
+            )
+        return item
+
+    def get_catalog(self, base_dir: Optional[MPathLike] = None) -> CollectionSearcher:
+        match self.catalog_type:
+            case "search":
+                return STACSearchCollection(self.collection)
+            case "static":
+                return STACStaticCollection(
+                    collection=MPath(self.collection).absolute_path(base_dir=base_dir)
+                )
+
+    def eo_bands(self, base_dir: Optional[MPathLike] = None) -> List[str]:
+        return self.get_catalog(base_dir=base_dir).eo_bands
+
+    @model_validator(mode="before")
+    def deprecate_max_cloud_cover(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        if "max_cloud_cover" in values:
+            raise DeprecationWarning(
+                "'max_cloud_cover' will be deprecated soon. Please use 'eo:cloud_cover<=...' in the source 'query' field.",
+            )
+        elif "area" in values:  # pragma: no cover
+            raise NotImplementedError("please use 'bounds' as spatial subset for now")
+        return values

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapchete-eo
-Version: 2025.10.1
+Version: 2025.11.0
 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>
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: GIS
 Requires-Dist: click
+Requires-Dist: cql2
 Requires-Dist: croniter
 Requires-Dist: lxml
 Requires-Dist: mapchete[complete]>=2025.10.0

mapchete_eo-2025.11.0.dist-info/RECORD

@@ -0,0 +1,89 @@
+mapchete_eo/__init__.py,sha256=2E0oLwEHFZUcghiMB3GjI_PKEVs-4pasu50WwMW-H2A,26
+mapchete_eo/base.py,sha256=_6wbR9IZBBBdRBbZY4FEQ0uu603C-tMPYK4MGQ5xSYY,21953
+mapchete_eo/blacklist.txt,sha256=6KhBY0jNjXgRpKRvKJoOTswvNUoP56IrIcNeCYnd2qo,17471
+mapchete_eo/eostac.py,sha256=M-EL8y8pPw8H9hb85FPxSl-1FL_kIYOzxsTIhkrbBZY,570
+mapchete_eo/exceptions.py,sha256=ul7_9o6_SfJXQPsDOQqRBhh09xv2t4AwHl6YJ7yWN5s,2150
+mapchete_eo/product.py,sha256=0GJDk4pPvdCLxuJkZCMQnM7LIjvOBRUhIzchcQCqMjI,9644
+mapchete_eo/protocols.py,sha256=KUbteFTOCSYEiSUJZj2MeckmrJHfJFrXCvZE70tByP8,1617
+mapchete_eo/settings.py,sha256=lbwYoqiQXBRexxL7Y524Ry0dk4vBKpjN1u09UOP1_CM,734
+mapchete_eo/sort.py,sha256=DfYAGEM6vzHJOFhaKxcKr-GwH5xM5ar4_mlp0uiVUK0,1787
+mapchete_eo/source.py,sha256=Tfo5IIYdRWpS06K-M7mzesl4WIUEt4onGmc1uKJ0F14,4158
+mapchete_eo/time.py,sha256=mCIrn6C-B7CDoFIIM4u8pG15nVV8KWQixF2fuhdDTdE,1799
+mapchete_eo/types.py,sha256=yIHKZHlGCSerJzDBS2AH7yYLun4rY3rZZ73SCKiN26U,1814
+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=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=6VqiwswEKpr5bS0w1ugRSf2z7rMKA-wiEFZdcmri94c,6916
+mapchete_eo/cli/s2_brdf.py,sha256=siUGau8HzXNyQZkDUx1zAeaLcCfonJG5kWHSCvwJOhA,2729
+mapchete_eo/cli/s2_cat_results.py,sha256=tR5Qm6kiCAcDO5V9AkYhoUbHyEx7OItSf6IqtIjhRLg,4648
+mapchete_eo/cli/s2_find_broken_products.py,sha256=4nhtMLkys75enPV5lETw4iOn3CxxNnc-sMyhk_kaKx0,2946
+mapchete_eo/cli/s2_jp2_static_catalog.py,sha256=_j_rfFnYHtE8k79TS9KFuX_IxOx_e-r7u6beoLYyxPY,5911
+mapchete_eo/cli/s2_mask.py,sha256=1K5BiyTKyClGBdh6-Vh_ORTcgJOr6R5JfXtpEpDEQvk,2243
+mapchete_eo/cli/s2_mgrs.py,sha256=EJxbrg4I8IttWIcLUEmmqkjsTUbVLufgrkDVrRbbkYE,1276
+mapchete_eo/cli/s2_rgb.py,sha256=nzK5m4s0m2VOXgtit0uUOOhNJ14wquikWmbEQON5WJw,3747
+mapchete_eo/cli/s2_verify.py,sha256=atfJA5luHZjDSqiM2udaufmnQ2B4uW2Tur_OgtYLa2g,4080
+mapchete_eo/cli/static_catalog.py,sha256=O7oCJB6mxWwnEMowPBo6UMtWOu52mSNUBB9tpSw91a4,3005
+mapchete_eo/image_operations/__init__.py,sha256=c36Vs53mT5UQR9Iwd2Ln_vnT4K_Ni8g-K7J9Fl6UsJo,432
+mapchete_eo/image_operations/blend_functions.py,sha256=YaKLOEapMbsUR-_mkBatXwPcmim8GKpIAVua_GOdaHs,24131
+mapchete_eo/image_operations/color_correction.py,sha256=vMXxcdyH3qOJDSKcXGU3FgXWIcgQxMy-QVe2fGQTbdk,4447
+mapchete_eo/image_operations/compositing.py,sha256=K0bGCZqJuS39IBsjrRiJz5zowItI6RsiA-EBUVlbboo,8449
+mapchete_eo/image_operations/dtype_scale.py,sha256=_CCdTBkMLDkZdjV_PsVEkqLWT6jWuTJPeMzCcRwBOns,1243
+mapchete_eo/image_operations/fillnodata.py,sha256=Xdd-kacfo7VKqX7HRP0hqnnvV5OwNqnHLRTW64QhG24,4856
+mapchete_eo/image_operations/filters.py,sha256=sa_Igv0zMIANHLEALVi8mxohZMoSrdQc6XVjXDYwzy8,7201
+mapchete_eo/image_operations/linear_normalization.py,sha256=-eQX3WLCUYWUv-um3s1u33rgjAwCz84Ht8gcPsMWtJE,2468
+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=E7phBOu8JaqyRhuEwl7wnmWHvG1yY1sw38QaMCuYkB4,16998
+mapchete_eo/io/items.py,sha256=5H2xWAyLptDuuHh0rjY1MXReJomV0XBZgMr_rpdpYXU,6244
+mapchete_eo/io/levelled_cubes.py,sha256=ZF7BLn9MHnJCCDjAoR9D7MNbHdusjJ9EACdM7rKNlyM,9018
+mapchete_eo/io/path.py,sha256=fCjvowd9rGJbGio5Z-jDLxa49M2BVurYM9hJy53Im48,4831
+mapchete_eo/io/products.py,sha256=2gELjHoEe4QH-Yjk82tA2nZUnBgfPbaGvk5GMHUWs4w,14642
+mapchete_eo/io/profiles.py,sha256=l9YiXbKYs674xz6NLy5EAq3fBEvHTVSf_gopXD-CuSY,935
+mapchete_eo/platforms/sentinel2/__init__.py,sha256=dviB4f5k45t_iOScTtnPc1kaWcohWKRq-8RaQzdggmU,401
+mapchete_eo/platforms/sentinel2/_mapper_registry.py,sha256=3kuyW2g_xJoFUzZrAmhKn9ASHl4gBKuOlHsSZnpt21w,2746
+mapchete_eo/platforms/sentinel2/bandpass_adjustment.py,sha256=DA0cQtjr8UH7r_kizAD-EmBsZvEtVVThf0hD0SCY7b4,3202
+mapchete_eo/platforms/sentinel2/config.py,sha256=ifmzxDEuOFfoGAvbGyWyUWwF3Dw0NxEUEA3bWNByNR0,8482
+mapchete_eo/platforms/sentinel2/driver.py,sha256=hNc9jmLQMmnA2ciVBPSTmVW6H8clL6sydkxcy6BjO40,1166
+mapchete_eo/platforms/sentinel2/masks.py,sha256=6ig8sQhXkm1u6Bwbe7n8ewW8gTdbVJp-iaDCk780Qxg,11220
+mapchete_eo/platforms/sentinel2/preprocessing_tasks.py,sha256=DJhbvYhNDGZ2Er5polK2LXWcg-MASZMFparNOw56yDk,1645
+mapchete_eo/platforms/sentinel2/processing_baseline.py,sha256=uTE7zgzgi_W3NENLIAnJbWjyUD5_znpGa3cV-VoaEws,5179
+mapchete_eo/platforms/sentinel2/product.py,sha256=UUbngHI2qPri5GkMPdmaw-ZS0y6aIQUtgZ5oZXUcIJc,28095
+mapchete_eo/platforms/sentinel2/source.py,sha256=qSziCNTpInGy2LWIMiC3M4EP9G9_VtbCRNXB1XAO1P4,4269
+mapchete_eo/platforms/sentinel2/types.py,sha256=EV7TleKZnCNuDlEMJ0UtJjDsvOUGbvh_pZToeOULQ18,2122
+mapchete_eo/platforms/sentinel2/brdf/__init__.py,sha256=W7zAJZ5F5Xla7j4ua2opRANUbcD3jZbhTwhW5_cpOUI,242
+mapchete_eo/platforms/sentinel2/brdf/config.py,sha256=v3WCEu4r-tEPQgWBEkYNAPLgCQobvYtQ2YiDeAdImMk,1133
+mapchete_eo/platforms/sentinel2/brdf/correction.py,sha256=vi-BwAA6Cbayzk6WOuOESLhRkGLhiUAbVYfJUSfYhXA,8651
+mapchete_eo/platforms/sentinel2/brdf/hls.py,sha256=pzrRTNfJhuqRLidLQvKJpSnaz816x7jUesXt_aRgFjc,8818
+mapchete_eo/platforms/sentinel2/brdf/models.py,sha256=BBwGX1OLMRLncK1jD2reidaF82IKR4sjgNGHdTgBXaw,1446
+mapchete_eo/platforms/sentinel2/brdf/protocols.py,sha256=fxLDFeaL44eIPC2UwcbEQ-AXPREWgBv6Iytc74AQ5eA,752
+mapchete_eo/platforms/sentinel2/brdf/ross_thick.py,sha256=OvuuQxqWN8qrKpz8kDhmCd8R1uMLa8h5LISJSJ_NvYk,4685
+mapchete_eo/platforms/sentinel2/brdf/sun_angle_arrays.py,sha256=RxhQ8vBU0r5vsQ3FnyfDdYS0EGDGKCwAXND0Gn1m5mQ,2148
+mapchete_eo/platforms/sentinel2/metadata_parser/__init__.py,sha256=Vio87daAQ1eBQfDfA97c9byVnAUEPCidjTBg6jnZhXk,167
+mapchete_eo/platforms/sentinel2/metadata_parser/base.py,sha256=AvPfsQEAyXOrwOQ_MQgWLUFFJL0VhTzzWHpuSe14IS0,1520
+mapchete_eo/platforms/sentinel2/metadata_parser/default_path_mapper.py,sha256=Gt9jUZwO3u_p6iH3hkOGNS5Tad5yn-Y1F7uADtalBSo,5344
+mapchete_eo/platforms/sentinel2/metadata_parser/models.py,sha256=FOdEeIKk_Sa_O3iGRqoR-5YLQuwjPG6pNbdFRgQVYm8,2325
+mapchete_eo/platforms/sentinel2/metadata_parser/s2metadata.py,sha256=i6O9t0Bbb5BCiktKmXgDBKWdzdtVoGJ-Nt-xib-w3qw,23786
+mapchete_eo/platforms/sentinel2/preconfigured_sources/__init__.py,sha256=W-PFNuC0zXfF07uTUH_-r2Macv-_5qlz_YsP04Jxh8Y,1821
+mapchete_eo/platforms/sentinel2/preconfigured_sources/guessers.py,sha256=lkftO9NCJqwV663K3YqUFkNQxQWrCuwp_enbfTkjdbQ,3746
+mapchete_eo/platforms/sentinel2/preconfigured_sources/item_mappers.py,sha256=b_lvs6-rKQjb-8vBjOLV0Zi4a2ZXZxMqinyeRljA5lY,5957
+mapchete_eo/platforms/sentinel2/preconfigured_sources/metadata_xml_mappers.py,sha256=8UbF5Riox1FZIYGuDMBiGgxNfAQkOmu07ZMc2Eqiel0,8647
+mapchete_eo/processes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=jSXUI8pEWXbQWrM9iMtrH4ACH2VkCaBUH9CQg4z6zLA,8486
+mapchete_eo/search/__init__.py,sha256=bHvaqoHrtoNyO8_3kyJfvhh1yCz0hYvU2fzXhjOXNhU,528
+mapchete_eo/search/base.py,sha256=Xdhq7js96erhV5qgAeKviUakF4qJmzUkbvprrTCP6Zc,9107
+mapchete_eo/search/config.py,sha256=-3TzCBzjTIkCVpuoJMDDShHh4rm_9_QFKYruedEwbjY,2241
+mapchete_eo/search/s2_mgrs.py,sha256=x12m-tJZNc41lFHNR2h7eSyEZ-ceBO4Gdz785btcVN8,10859
+mapchete_eo/search/stac_search.py,sha256=p38veJiUZtEzXq7KJJ0YzqeEG1L87Q3CLdPIME1RQ3A,10504
+mapchete_eo/search/stac_static.py,sha256=nPvJPayImPHkjVr4XEDp7ucOOhbDpUTlGyMJeaRFmAI,7260
+mapchete_eo/search/utm_search.py,sha256=6T9HtbgT8mrWjzX_7_fkggmQBCWDBhf5i7BJ9dk6BZw,9230
+mapchete_eo-2025.11.0.dist-info/METADATA,sha256=TkqXdAgVkEPhNiAbMS4VSXUwuhKGnITHET5MyvgGwDQ,3257
+mapchete_eo-2025.11.0.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+mapchete_eo-2025.11.0.dist-info/entry_points.txt,sha256=edU29CA3j8hwBafEd6jO2Zcou1sGkyjNro-y4_LnAnw,320
+mapchete_eo-2025.11.0.dist-info/licenses/LICENSE,sha256=TC5JwvBnFrUgsSQSCDFPc3cqlbth2N0q8MWrhY1EVd0,1089
+mapchete_eo-2025.11.0.dist-info/RECORD,,

{mapchete_eo-2025.10.1.dist-info → mapchete_eo-2025.11.0.dist-info}/entry_points.txt

@@ -2,7 +2,7 @@
 eo = mapchete_eo.cli:eo
 
 [mapchete.formats.drivers]
-eostac_dev = mapchete_eo.eostac
+eostac = mapchete_eo.eostac
 sentinel2 = mapchete_eo.platforms.sentinel2
 
 [mapchete.processes]

mapchete_eo/archives/base.py

@@ -1,65 +0,0 @@
-from abc import ABC
-import logging
-from typing import Any, Callable, Dict, Generator, List, Optional, Union
-
-from mapchete.io.vector import IndexedFeatures
-from mapchete.types import Bounds
-from pystac import Item
-from shapely.errors import GEOSException
-from shapely.geometry.base import BaseGeometry
-
-from mapchete_eo.exceptions import ItemGeometryError
-from mapchete_eo.search.base import CatalogSearcher
-from mapchete_eo.types import TimeRange
-
-logger = logging.getLogger(__name__)
-
-
-class Archive(ABC):
-    """
-    An archive combines a Catalog and a Storage.
-    """
-
-    time: Union[TimeRange, List[TimeRange]]
-    area: BaseGeometry
-    catalog: CatalogSearcher
-    search_kwargs: Dict[str, Any]
-    _items: Optional[IndexedFeatures] = None
-    item_modifier_funcs: Optional[List[Callable[[Item], Item]]] = None
-
-    def __init__(
-        self,
-        time: Union[TimeRange, List[TimeRange]],
-        bounds: Optional[Bounds] = None,
-        area: Optional[BaseGeometry] = None,
-        search_kwargs: Optional[Dict[str, Any]] = None,
-        catalog: Optional[CatalogSearcher] = None,
-    ):
-        if bounds is None and area is None:
-            raise ValueError("either bounds or area have to be provided")
-        elif area is None:
-            area = Bounds.from_inp(bounds).geometry
-        self.time = time
-        self.area = area
-        self.search_kwargs = search_kwargs or {}
-        if catalog:
-            self.catalog = catalog
-
-    def get_catalog_config(self):
-        return self.catalog.config_cls(**self.search_kwargs)
-
-    def apply_item_modifier_funcs(self, item: Item) -> Item:
-        try:
-            for modifier in self.item_modifier_funcs or []:
-                item = modifier(item)
-        except GEOSException as exc:
-            raise ItemGeometryError(
-                f"item {item.get_self_href()} geometry could not be resolved: {str(exc)}"
-            )
-        return item
-
-    def items(self) -> Generator[Item, None, None]:
-        for item in self.catalog.search(
-            time=self.time, area=self.area, search_kwargs=self.search_kwargs
-        ):
-            yield self.apply_item_modifier_funcs(item)