eodag 3.1.0b1__py3-none-any.whl → 3.1.0b2__py3-none-any.whl

eodag/api/core.py

@@ -24,7 +24,7 @@ import re
 import shutil
 import tempfile
 from operator import itemgetter
-from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Iterator, Optional, Union
 
 import geojson
 import pkg_resources
@@ -185,7 +185,7 @@ class EODataAccessGateway:
         self._plugins_manager.rebuild(self.providers_config)
 
         # store pruned providers configs
-        self._pruned_providers_config: Dict[str, Any] = {}
+        self._pruned_providers_config: dict[str, Any] = {}
         # filter out providers needing auth that have no credentials set
         self._prune_providers_list()
 
@@ -335,7 +335,7 @@ class EODataAccessGateway:
             new_priority = max_priority + 1
             self._plugins_manager.set_priority(provider, new_priority)
 
-    def get_preferred_provider(self) -> Tuple[str, int]:
+    def get_preferred_provider(self) -> tuple[str, int]:
         """Get the provider currently set as the preferred one for searching
         products, along with its priority.
 
@@ -351,7 +351,7 @@ class EODataAccessGateway:
     def update_providers_config(
         self,
         yaml_conf: Optional[str] = None,
-        dict_conf: Optional[Dict[str, Any]] = None,
+        dict_conf: Optional[dict[str, Any]] = None,
     ) -> None:
         """Update providers configuration with given input.
         Can be used to add a provider to existing configuration or update
@@ -397,12 +397,12 @@ class EODataAccessGateway:
         name: str,
         url: Optional[str] = None,
         priority: Optional[int] = None,
-        search: Dict[str, Any] = {"type": "StacSearch"},
-        products: Dict[str, Any] = {
+        search: dict[str, Any] = {"type": "StacSearch"},
+        products: dict[str, Any] = {
             GENERIC_PRODUCT_TYPE: {"productType": "{productType}"}
         },
-        download: Dict[str, Any] = {"type": "HTTPDownload", "auth_error_code": 401},
-        **kwargs: Dict[str, Any],
+        download: dict[str, Any] = {"type": "HTTPDownload", "auth_error_code": 401},
+        **kwargs: dict[str, Any],
     ):
         """Adds a new provider.
 
@@ -421,7 +421,7 @@ class EODataAccessGateway:
         :param download: Download :class:`~eodag.config.PluginConfig` mapping
         :param kwargs: Additional :class:`~eodag.config.ProviderConfig` mapping
         """
-        conf_dict: Dict[str, Any] = {
+        conf_dict: dict[str, Any] = {
             name: {
                 "url": url,
                 "search": {"type": "StacSearch", **search},
@@ -565,7 +565,7 @@ class EODataAccessGateway:
             main_locations_config = locations_config[main_key]
 
             logger.info("Locations configuration loaded from %s" % locations_conf_path)
-            self.locations_config: List[Dict[str, Any]] = main_locations_config
+            self.locations_config: list[dict[str, Any]] = main_locations_config
         else:
             logger.info(
                 "Could not load locations configuration from %s" % locations_conf_path
@@ -574,7 +574,7 @@ class EODataAccessGateway:
 
     def list_product_types(
         self, provider: Optional[str] = None, fetch_providers: bool = True
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Lists supported product types.
 
         :param provider: (optional) The name of a provider that must support the product
@@ -588,7 +588,7 @@ class EODataAccessGateway:
             # First, update product types list if possible
             self.fetch_product_types_list(provider=provider)
 
-        product_types: List[Dict[str, Any]] = []
+        product_types: list[dict[str, Any]] = []
 
         providers_configs = (
             list(self.providers_config.values())
@@ -644,7 +644,7 @@ class EODataAccessGateway:
             providers_to_fetch = [provider]
 
         # providers discovery confs that are fetchable
-        providers_discovery_configs_fetchable: Dict[str, Any] = {}
+        providers_discovery_configs_fetchable: dict[str, Any] = {}
         # check if any provider has not already been fetched for product types
         already_fetched = True
         for provider_to_fetch in providers_to_fetch:
@@ -767,7 +767,7 @@ class EODataAccessGateway:
 
     def discover_product_types(
         self, provider: Optional[str] = None
-    ) -> Optional[Dict[str, Any]]:
+    ) -> Optional[dict[str, Any]]:
         """Fetch providers for product types
 
         :param provider: The name of a provider or provider-group to fetch. Defaults to
@@ -787,7 +787,7 @@ class EODataAccessGateway:
             raise UnsupportedProvider(
                 f"The requested provider is not (yet) supported: {provider}"
             )
-        ext_product_types_conf: Dict[str, Any] = {}
+        ext_product_types_conf: dict[str, Any] = {}
         providers_to_fetch = [
             p
             for p in (
@@ -800,7 +800,7 @@ class EODataAccessGateway:
                 else self.available_providers()
             )
         ]
-        kwargs: Dict[str, Any] = {}
+        kwargs: dict[str, Any] = {}
         for provider in providers_to_fetch:
             if hasattr(self.providers_config[provider], "search"):
                 search_plugin_config = self.providers_config[provider].search
@@ -841,7 +841,7 @@ class EODataAccessGateway:
         return sort_dict(ext_product_types_conf)
 
     def update_product_types_list(
-        self, ext_product_types_conf: Dict[str, Optional[Dict[str, Dict[str, Any]]]]
+        self, ext_product_types_conf: dict[str, Optional[dict[str, dict[str, Any]]]]
     ) -> None:
         """Update eodag product types list
 
@@ -869,7 +869,7 @@ class EODataAccessGateway:
                         provider,
                     )
                     continue
-                new_product_types: List[str] = []
+                new_product_types: list[str] = []
                 for (
                     new_product_type,
                     new_product_type_conf,
@@ -932,7 +932,7 @@ class EODataAccessGateway:
 
     def available_providers(
         self, product_type: Optional[str] = None, by_group: bool = False
-    ) -> List[str]:
+    ) -> list[str]:
         """Gives the sorted list of the available providers or groups
 
         The providers or groups are sorted first by their priority level in descending order,
@@ -959,7 +959,7 @@ class EODataAccessGateway:
 
         # If by_group is True, keep only the highest priority for each group
         if by_group:
-            group_priority: Dict[str, int] = {}
+            group_priority: dict[str, int] = {}
             for name, priority in providers:
                 if name not in group_priority or priority > group_priority[name]:
                     group_priority[name] = priority
@@ -1026,7 +1026,7 @@ class EODataAccessGateway:
         missionStartDate: Optional[str] = None,
         missionEndDate: Optional[str] = None,
         **kwargs: Any,
-    ) -> List[str]:
+    ) -> list[str]:
         """
         Find EODAG product type IDs that best match a set of search parameters.
 
@@ -1084,7 +1084,7 @@ class EODataAccessGateway:
             query = p.parse(text)
             results = searcher.search(query, limit=None)
 
-            guesses: List[Dict[str, str]] = [dict(r) for r in results or []]
+            guesses: list[dict[str, str]] = [dict(r) for r in results or []]
 
         # datetime filtering
         if missionStartDate or missionEndDate:
@@ -1125,8 +1125,8 @@ class EODataAccessGateway:
         raise_errors: bool = False,
         start: Optional[str] = None,
         end: Optional[str] = None,
-        geom: Optional[Union[str, Dict[str, float], BaseGeometry]] = None,
-        locations: Optional[Dict[str, str]] = None,
+        geom: Optional[Union[str, dict[str, float], BaseGeometry]] = None,
+        locations: Optional[dict[str, str]] = None,
         provider: Optional[str] = None,
         count: bool = False,
         **kwargs: Any,
@@ -1205,7 +1205,7 @@ class EODataAccessGateway:
             items_per_page=items_per_page,
         )
 
-        errors: List[Tuple[str, Exception]] = []
+        errors: list[tuple[str, Exception]] = []
         # Loop over available providers and return the first non-empty results
         for i, search_plugin in enumerate(search_plugins):
             search_plugin.clear()
@@ -1234,8 +1234,8 @@ class EODataAccessGateway:
         items_per_page: int = DEFAULT_ITEMS_PER_PAGE,
         start: Optional[str] = None,
         end: Optional[str] = None,
-        geom: Optional[Union[str, Dict[str, float], BaseGeometry]] = None,
-        locations: Optional[Dict[str, str]] = None,
+        geom: Optional[Union[str, dict[str, float], BaseGeometry]] = None,
+        locations: Optional[dict[str, str]] = None,
         **kwargs: Any,
     ) -> Iterator[SearchResult]:
         """Iterate over the pages of a products search.
@@ -1411,8 +1411,8 @@ class EODataAccessGateway:
         items_per_page: Optional[int] = None,
         start: Optional[str] = None,
         end: Optional[str] = None,
-        geom: Optional[Union[str, Dict[str, float], BaseGeometry]] = None,
-        locations: Optional[Dict[str, str]] = None,
+        geom: Optional[Union[str, dict[str, float], BaseGeometry]] = None,
+        locations: Optional[dict[str, str]] = None,
         **kwargs: Any,
     ) -> SearchResult:
         """Search and return all the products matching the search criteria.
@@ -1633,7 +1633,7 @@ class EODataAccessGateway:
         if not getattr(plugin.config, "discover_product_types", {}).get("fetch_url"):
             return None
 
-        kwargs: Dict[str, Any] = {"productType": product_type}
+        kwargs: dict[str, Any] = {"productType": product_type}
 
         # append auth if needed
         if getattr(plugin.config, "need_auth", False):
@@ -1651,11 +1651,11 @@ class EODataAccessGateway:
         self,
         start: Optional[str] = None,
         end: Optional[str] = None,
-        geom: Optional[Union[str, Dict[str, float], BaseGeometry]] = None,
-        locations: Optional[Dict[str, str]] = None,
+        geom: Optional[Union[str, dict[str, float], BaseGeometry]] = None,
+        locations: Optional[dict[str, str]] = None,
         provider: Optional[str] = None,
         **kwargs: Any,
-    ) -> Tuple[List[Union[Search, Api]], Dict[str, Any]]:
+    ) -> tuple[list[Union[Search, Api]], dict[str, Any]]:
         """Internal method to prepare the search kwargs and get the search plugins.
 
         Product query:
@@ -1763,7 +1763,7 @@ class EODataAccessGateway:
 
         preferred_provider = self.get_preferred_provider()[0]
 
-        search_plugins: List[Union[Search, Api]] = []
+        search_plugins: list[Union[Search, Api]] = []
         for plugin in self._plugins_manager.get_search_plugins(
             product_type=product_type, provider=provider
         ):
@@ -1833,10 +1833,10 @@ class EODataAccessGateway:
                 max_items_per_page,
             )
 
-        results: List[EOProduct] = []
+        results: list[EOProduct] = []
         total_results: Optional[int] = 0 if count else None
 
-        errors: List[Tuple[str, Exception]] = []
+        errors: list[tuple[str, Exception]] = []
 
         try:
             prep = PreparedSearch(count=count)
@@ -1984,7 +1984,7 @@ class EODataAccessGateway:
         return results
 
     @staticmethod
-    def group_by_extent(searches: List[SearchResult]) -> List[SearchResult]:
+    def group_by_extent(searches: list[SearchResult]) -> list[SearchResult]:
         """Combines multiple SearchResults and return a list of SearchResults grouped
         by extent (i.e. bounding box).
 
@@ -1993,7 +1993,7 @@ class EODataAccessGateway:
         """
         # Dict with extents as keys, each extent being defined by a str
         # "{minx}{miny}{maxx}{maxy}" (each float rounded to 2 dec).
-        products_grouped_by_extent: Dict[str, Any] = {}
+        products_grouped_by_extent: dict[str, Any] = {}
 
         for search in searches:
             for product in search:
@@ -2015,7 +2015,7 @@ class EODataAccessGateway:
         wait: float = DEFAULT_DOWNLOAD_WAIT,
         timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
-    ) -> List[str]:
+    ) -> list[str]:
         """Download all products resulting from a search.
 
         :param search_result: A collection of EO products resulting from a search
@@ -2273,7 +2273,7 @@ class EODataAccessGateway:
                   properties, associating parameters to their annotated type, and a additional_properties attribute
         """
         # only fetch providers if product type is not found
-        available_product_types = [
+        available_product_types: list[str] = [
             pt["ID"]
             for pt in self.list_product_types(provider=provider, fetch_providers=False)
         ]
@@ -2304,13 +2304,13 @@ class EODataAccessGateway:
                 **model_fields_to_annotated(CommonQueryables.model_fields),
             )
 
-        queryables: QueryablesDict = QueryablesDict(
-            additional_properties=True, additional_information="", **{}
-        )
+        additional_properties = False
+        additional_information = []
+        queryable_properties: dict[str, Any] = {}
 
         for plugin in self._plugins_manager.get_search_plugins(product_type, provider):
             # attach product type config
-            product_type_configs = {}
+            product_type_configs: dict[str, Any] = {}
             if product_type:
                 self._attach_product_type_config(plugin, product_type)
                 product_type_configs[product_type] = plugin.config.product_type_config
@@ -2330,6 +2330,7 @@ class EODataAccessGateway:
                         "queryables from provider %s could not be fetched due to an authentication error",
                         plugin.provider,
                     )
+
             plugin_queryables = plugin.list_queryables(
                 kwargs,
                 available_product_types,
@@ -2337,17 +2338,23 @@ class EODataAccessGateway:
                 product_type,
                 pt_alias,
             )
-            queryables.update(plugin_queryables)
-            if not plugin_queryables.additional_properties:
-                queryables.additional_properties = False
+
             if plugin_queryables.additional_information:
-                queryables.additional_information += (
-                    f"{provider}: {plugin_queryables.additional_information}"
+                additional_information.append(
+                    f"{plugin.provider}: {plugin_queryables.additional_information}"
                 )
+            queryable_properties = {**plugin_queryables, **queryable_properties}
+            additional_properties = (
+                additional_properties or plugin_queryables.additional_properties
+            )
 
-        return queryables
+        return QueryablesDict(
+            additional_properties=additional_properties,
+            additional_information=" | ".join(additional_information),
+            **queryable_properties,
+        )
 
-    def available_sortables(self) -> Dict[str, Optional[ProviderSortables]]:
+    def available_sortables(self) -> dict[str, Optional[ProviderSortables]]:
         """For each provider, gives its available sortable parameter(s) and its maximum
         number of them if it supports the sorting feature, otherwise gives None.
 
@@ -2355,7 +2362,7 @@ class EODataAccessGateway:
                   its (their) maximum number as value(s).
         :raises: :class:`~eodag.utils.exceptions.UnsupportedProvider`
         """
-        sortables: Dict[str, Optional[ProviderSortables]] = {}
+        sortables: dict[str, Optional[ProviderSortables]] = {}
         provider_search_plugins = self._plugins_manager.get_search_plugins()
         for provider_search_plugin in provider_search_plugins:
             provider = provider_search_plugin.provider

eodag/api/product/_assets.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 
 import re
 from collections import UserDict
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from eodag.utils.exceptions import NotAvailableError
 from eodag.utils.repr import dict_to_html_table
@@ -45,10 +45,10 @@ class AssetsDict(UserDict):
         self.product = product
         super(AssetsDict, self).__init__(*args, **kwargs)
 
-    def __setitem__(self, key: str, value: Dict[str, Any]) -> None:
+    def __setitem__(self, key: str, value: dict[str, Any]) -> None:
         super().__setitem__(key, Asset(self.product, key, value))
 
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         """Builds a representation of AssetsDict to enable its serialization
 
         :returns: The representation of a :class:`~eodag.api.product._assets.AssetsDict`
@@ -56,7 +56,7 @@ class AssetsDict(UserDict):
         """
         return {k: v.as_dict() for k, v in self.data.items()}
 
-    def get_values(self, asset_filter: str = "") -> List[Asset]:
+    def get_values(self, asset_filter: str = "") -> list[Asset]:
         """
         retrieves the assets matching the given filter
 
@@ -138,7 +138,7 @@ class Asset(UserDict):
         self.key = key
         super(Asset, self).__init__(*args, **kwargs)
 
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         """Builds a representation of Asset to enable its serialization
 
         :returns: The representation of a :class:`~eodag.api.product._assets.Asset` as a

eodag/api/product/_product.py

@@ -22,7 +22,7 @@ import logging
 import os
 import re
 import tempfile
-from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import requests
 from requests import RequestException
@@ -38,7 +38,7 @@ try:
 except ImportError:
     from eodag.api.product._assets import AssetsDict
 
-from eodag.api.product.drivers import DRIVERS, NoDriver
+from eodag.api.product.drivers import DRIVERS, LEGACY_DRIVERS, NoDriver
 from eodag.api.product.metadata_mapping import (
     DEFAULT_GEOMETRY,
     NOT_AVAILABLE,
@@ -113,7 +113,7 @@ class EOProduct:
     """
 
     provider: str
-    properties: Dict[str, Any]
+    properties: dict[str, Any]
     product_type: Optional[str]
     location: str
     filename: str
@@ -122,9 +122,11 @@ class EOProduct:
     geometry: BaseGeometry
     search_intersection: Optional[BaseGeometry]
     assets: AssetsDict
+    #: Driver enables additional methods to be called on the EOProduct
+    driver: DatasetDriver
 
     def __init__(
-        self, provider: str, properties: Dict[str, Any], **kwargs: Any
+        self, provider: str, properties: dict[str, Any], **kwargs: Any
     ) -> None:
         self.provider = provider
         self.product_type = kwargs.get("productType")
@@ -175,7 +177,7 @@ class EOProduct:
         self.downloader: Optional[Union[Api, Download]] = None
         self.downloader_auth: Optional[Authentication] = None
 
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         """Builds a representation of EOProduct as a dictionary to enable its geojson
         serialization
 
@@ -186,7 +188,7 @@ class EOProduct:
         if self.search_intersection is not None:
             search_intersection = geometry.mapping(self.search_intersection)
 
-        geojson_repr: Dict[str, Any] = {
+        geojson_repr: dict[str, Any] = {
             "type": "Feature",
             "geometry": geometry.mapping(self.geometry),
             "id": self.properties["id"],
@@ -206,7 +208,7 @@ class EOProduct:
         return geojson_repr
 
     @classmethod
-    def from_geojson(cls, feature: Dict[str, Any]) -> EOProduct:
+    def from_geojson(cls, feature: dict[str, Any]) -> EOProduct:
         """Builds an :class:`~eodag.api.product._product.EOProduct` object from its
         representation as geojson
 
@@ -356,7 +358,7 @@ class EOProduct:
 
     def _init_progress_bar(
         self, progress_callback: Optional[ProgressCallback]
-    ) -> Tuple[ProgressCallback, bool]:
+    ) -> tuple[ProgressCallback, bool]:
         # progress bar init
         if progress_callback is None:
             progress_callback = ProgressCallback(position=1)
@@ -463,12 +465,20 @@ class EOProduct:
             )
             if not isinstance(auth, AuthBase):
                 auth = None
+            # Read the ssl_verify parameter used on the provider config
+            # to ensure the same behavior for get_quicklook as other download functions
+            ssl_verify = (
+                getattr(self.downloader.config, "ssl_verify", True)
+                if self.downloader
+                else True
+            )
             with requests.get(
                 self.properties["quicklook"],
                 stream=True,
                 auth=auth,
                 headers=USER_AGENT,
                 timeout=DEFAULT_STREAM_REQUESTS_TIMEOUT,
+                verify=ssl_verify,
             ) as stream:
                 try:
                     stream.raise_for_status()
@@ -498,11 +508,16 @@ class EOProduct:
         try:
             for driver_conf in DRIVERS:
                 if all([criteria(self) for criteria in driver_conf["criteria"]]):
-                    return driver_conf["driver"]
+                    driver = driver_conf["driver"]
+                    break
+            # use legacy driver for deprecated get_data method usage
+            for lecacy_conf in LEGACY_DRIVERS:
+                if all([criteria(self) for criteria in lecacy_conf["criteria"]]):
+                    driver.legacy = lecacy_conf["driver"]
+                    break
+            return driver
         except TypeError:
-            logger.warning(
-                "Drivers definition seems out-of-date, please update eodag-cube"
-            )
+            logger.info("No driver matching")
             pass
         return NoDriver()
 

eodag/api/product/drivers/__init__.py

@@ -16,14 +16,91 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """EODAG drivers package"""
+from __future__ import annotations
+
+from typing import Callable, TypedDict
+
 from eodag.api.product.drivers.base import DatasetDriver, NoDriver
+from eodag.api.product.drivers.generic import GenericDriver
+from eodag.api.product.drivers.sentinel1 import Sentinel1Driver
+from eodag.api.product.drivers.sentinel2 import Sentinel2Driver
 
 try:
-    from eodag_cube.api.product.drivers import (  # pyright: ignore[reportMissingImports]
-        DRIVERS,
+    # import from eodag-cube if installed
+    from eodag_cube.api.product.drivers.generic import (  # pyright: ignore[reportMissingImports]; isort: skip
+        GenericDriver as GenericDriver_cube,
+    )
+    from eodag_cube.api.product.drivers.sentinel2_l1c import (  # pyright: ignore[reportMissingImports]; isort: skip
+        Sentinel2L1C as Sentinel2L1C_cube,
+    )
+    from eodag_cube.api.product.drivers.stac_assets import (  # pyright: ignore[reportMissingImports]; isort: skip
+        StacAssets as StacAssets_cube,
     )
 except ImportError:
-    DRIVERS = []
+    GenericDriver_cube = NoDriver
+    Sentinel2L1C_cube = NoDriver
+    StacAssets_cube = NoDriver
+
+
+class DriverCriteria(TypedDict):
+    """Driver criteria definition"""
+
+    #: Function that returns True if the driver is suitable for the given :class:`~eodag.api.product._product.EOProduct`
+    criteria: list[Callable[..., bool]]
+    #: driver to use
+    driver: DatasetDriver
+
+
+#: list of drivers and their criteria
+DRIVERS: list[DriverCriteria] = [
+    {
+        "criteria": [
+            lambda prod: True
+            if (prod.product_type or "").startswith("S2_MSI_")
+            else False
+        ],
+        "driver": Sentinel2Driver(),
+    },
+    {
+        "criteria": [
+            lambda prod: True
+            if (prod.product_type or "").startswith("S1_SAR_")
+            else False
+        ],
+        "driver": Sentinel1Driver(),
+    },
+    {
+        "criteria": [lambda prod: True],
+        "driver": GenericDriver(),
+    },
+]
+
+
+#: list of legacy drivers and their criteria
+LEGACY_DRIVERS: list[DriverCriteria] = [
+    {
+        "criteria": [
+            lambda prod: True if len(getattr(prod, "assets", {})) > 0 else False
+        ],
+        "driver": StacAssets_cube(),
+    },
+    {
+        "criteria": [lambda prod: True if "assets" in prod.properties else False],
+        "driver": StacAssets_cube(),
+    },
+    {
+        "criteria": [
+            lambda prod: True
+            if getattr(prod, "product_type") == "S2_MSI_L1C"
+            else False
+        ],
+        "driver": Sentinel2L1C_cube(),
+    },
+    {
+        "criteria": [lambda prod: True],
+        "driver": GenericDriver_cube(),
+    },
+]
 
 # exportable content
-__all__ = ["DRIVERS", "DatasetDriver", "NoDriver"]
+__all__ = ["DRIVERS", "DatasetDriver", "GenericDriver", "NoDriver", "Sentinel2Driver"]