eodag 2.12.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

eodag/plugins/manager.py

@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import logging
+import re
 from operator import attrgetter
 from pathlib import Path
 from typing import (
@@ -35,17 +36,28 @@ from typing import (
 
 import pkg_resources
 
-from eodag.config import load_config, merge_configs
+from eodag.config import (
+    AUTH_TOPIC_KEYS,
+    PLUGINS_TOPICS_KEYS,
+    load_config,
+    merge_configs,
+)
 from eodag.plugins.apis.base import Api
 from eodag.plugins.authentication.base import Authentication
 from eodag.plugins.base import EODAGPluginMount
 from eodag.plugins.crunch.base import Crunch
 from eodag.plugins.download.base import Download
 from eodag.plugins.search.base import Search
-from eodag.utils import GENERIC_PRODUCT_TYPE
-from eodag.utils.exceptions import UnsupportedProvider
+from eodag.utils import GENERIC_PRODUCT_TYPE, deepcopy, dict_md5sum
+from eodag.utils.exceptions import (
+    AuthenticationError,
+    MisconfiguredError,
+    UnsupportedProvider,
+)
 
 if TYPE_CHECKING:
+    from requests.auth import AuthBase
+
     from eodag.api.product import EOProduct
     from eodag.config import PluginConfig, ProviderConfig
     from eodag.plugins.base import PluginTopic
@@ -68,12 +80,16 @@ class PluginManager:
 
     :param providers_config: The configuration with all information about the providers
                              supported by ``eodag``
-    :type providers_config: dict[str, :class:`~eodag.config.ProviderConfig`]
     """
 
-    supported_topics = {"search", "download", "crunch", "auth", "api"}
+    supported_topics = set(PLUGINS_TOPICS_KEYS)
+
+    product_type_to_provider_config_map: Dict[str, List[ProviderConfig]]
+
+    skipped_plugins: List[str]
 
     def __init__(self, providers_config: Dict[str, ProviderConfig]) -> None:
+        self.skipped_plugins = []
         self.providers_config = providers_config
         # Load all the plugins. This will make all plugin classes of a particular
         # type to be available in the base plugin class's 'plugins' attribute.
@@ -90,6 +106,13 @@ class PluginManager:
             ):
                 try:
                     entry_point.load()
+                except pkg_resources.DistributionNotFound:
+                    logger.debug(
+                        "%s plugin skipped, eodag[%s] or eodag[all] needed",
+                        entry_point.name,
+                        ",".join(entry_point.extras),
+                    )
+                    self.skipped_plugins.append(entry_point.name)
                 except ImportError:
                     import traceback as tb
 
@@ -99,7 +122,11 @@ class PluginManager:
                         "Check that the plugin module (%s) is importable",
                         entry_point.module_name,
                     )
-                if entry_point.dist and entry_point.dist.key != "eodag":
+                if (
+                    entry_point.dist
+                    and entry_point.dist.key != "eodag"
+                    and entry_point.dist.location is not None
+                ):
                     # use plugin providers if any
                     plugin_providers_config_path = [
                         str(x)
@@ -116,23 +143,25 @@ class PluginManager:
                         self.providers_config = plugin_providers_config
         self.rebuild()
 
-    def rebuild(self, providers_config=None):
+    def rebuild(
+        self, providers_config: Optional[Dict[str, ProviderConfig]] = None
+    ) -> None:
         """(Re)Build plugin manager mapping and cache"""
         if providers_config is not None:
             self.providers_config = providers_config
 
         self.build_product_type_to_provider_config_map()
-        self._built_plugins_cache: Dict[Tuple[str, str], Any] = {}
+        self._built_plugins_cache: Dict[Tuple[str, str, str], Any] = {}
 
     def build_product_type_to_provider_config_map(self) -> None:
         """Build mapping conf between product types and providers"""
-        self.product_type_to_provider_config_map: Dict[str, List[ProviderConfig]] = {}
+        self.product_type_to_provider_config_map = {}
         for provider in list(self.providers_config):
             provider_config = self.providers_config[provider]
             if not hasattr(provider_config, "products") or not provider_config.products:
                 logger.info(
-                    "%s: provider has no product configured and will be skipped"
-                    % provider
+                    "%s: provider has no product configured and will be skipped",
+                    provider,
                 )
                 self.providers_config.pop(provider)
                 continue
@@ -158,103 +187,211 @@ class PluginManager:
 
         :param product_type: (optional) The product type that the constructed plugins
                              must support
-        :type product_type: str
-        :param provider: (optional) The provider on which to get the search plugin
-        :type provider: str
+        :param provider: (optional) The provider or the provider group on which to get
+            the search plugins
         :returns: All the plugins supporting the product type, one by one (a generator
                   object)
-        :rtype: types.GeneratorType(:class:`~eodag.plugins.search.Search` or :class:`~eodag.plugins.download.Api`)
+            or :class:`~eodag.plugins.download.Api`)
         :raises: :class:`~eodag.utils.exceptions.UnsupportedProvider`
-        :raises: :class:`~eodag.utils.exceptions.UnsupportedProductType`
         """
 
         def get_plugin() -> Union[Search, Api]:
             plugin: Union[Search, Api]
-            try:
+            if search := getattr(config, "search", None):
                 config.search.products = config.products
                 config.search.priority = config.priority
-                plugin = cast(
-                    Search, self._build_plugin(config.name, config.search, Search)
-                )
-            except AttributeError:
+                plugin = cast(Search, self._build_plugin(config.name, search, Search))
+            elif api := getattr(config, "api", None):
                 config.api.products = config.products
                 config.api.priority = config.priority
-                plugin = cast(Api, self._build_plugin(config.name, config.api, Api))
+                plugin = cast(Api, self._build_plugin(config.name, api, Api))
+            else:
+                raise MisconfiguredError(
+                    f"No search plugin configureed for {config.name}."
+                )
             return plugin
 
-        if provider is not None:
-            try:
-                config = self.providers_config[provider]
-            except KeyError:
-                raise UnsupportedProvider
-            yield get_plugin()
-            # Signal the end of iteration as we already have what we wanted (see PEP-479)
-            return
-
-        if product_type is None:
-            for config in sorted(
-                self.providers_config.values(), key=attrgetter("priority"), reverse=True
-            ):
-                yield get_plugin()
-            # Signal the end of iteration as we already have what we wanted (see PEP-479)
-            return
-        try:
-            for config in self.product_type_to_provider_config_map[product_type]:
-                yield get_plugin()
-        except KeyError:
-            logger.info(
-                "UnsupportedProductType: %s, using generic settings", product_type
+        configs: Optional[List[ProviderConfig]]
+        if product_type:
+            configs = self.product_type_to_provider_config_map.get(product_type)
+            if not configs:
+                logger.info(
+                    "UnsupportedProductType: %s, using generic settings", product_type
+                )
+                configs = self.product_type_to_provider_config_map[GENERIC_PRODUCT_TYPE]
+        else:
+            configs = list(self.providers_config.values())
+
+        if provider:
+            configs = [
+                c for c in configs if provider in [getattr(c, "group", None), c.name]
+            ]
+
+        if not configs and product_type:
+            raise UnsupportedProvider(
+                f"{provider} is not (yet) supported for {product_type}"
             )
-            for config in self.product_type_to_provider_config_map[
-                GENERIC_PRODUCT_TYPE
-            ]:
-                yield get_plugin()
+        if not configs:
+            raise UnsupportedProvider(f"{provider} is not (yet) supported")
+
+        for config in sorted(configs, key=attrgetter("priority"), reverse=True):
+            yield get_plugin()
 
     def get_download_plugin(self, product: EOProduct) -> Union[Download, Api]:
         """Build and return the download plugin capable of downloading the given
         product.
 
         :param product: The product to get a download plugin for
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :returns: The download plugin capable of downloading the product
-        :rtype: :class:`~eodag.plugins.download.Download` or :class:`~eodag.plugins.download.Api`
         """
         plugin_conf = self.providers_config[product.provider]
-        try:
+        if download := getattr(plugin_conf, "download", None):
             plugin_conf.download.priority = plugin_conf.priority
             plugin = cast(
                 Download,
-                self._build_plugin(product.provider, plugin_conf.download, Download),
+                self._build_plugin(product.provider, download, Download),
             )
-            return plugin
-        except AttributeError:
+        elif api := getattr(plugin_conf, "api", None):
+            plugin_conf.api.products = plugin_conf.products
             plugin_conf.api.priority = plugin_conf.priority
-            plugin = cast(
-                Api, self._build_plugin(product.provider, plugin_conf.api, Api)
+            plugin = cast(Api, self._build_plugin(product.provider, api, Api))
+        else:
+            raise MisconfiguredError(
+                f"No download plugin configured for provider {plugin_conf.name}."
             )
-            return plugin
+        return plugin
+
+    def get_auth_plugin(
+        self, associated_plugin: PluginTopic, product: Optional[EOProduct] = None
+    ) -> Optional[Authentication]:
+        """Build and return the authentication plugin associated to the given
+        search/download plugin
+
+        .. versionchanged:: v3.0.0
+            ``get_auth_plugin()`` now needs ``associated_plugin`` instead of ``provider``
+            as argument.
 
-    def get_auth_plugin(self, provider: str) -> Optional[Authentication]:
+        :param associated_plugin: The search/download plugin to which the authentication
+                                  plugin is linked
+        :param product: The product to download. ``None`` for search authentication
+        :returns: The Authentication plugin
+        """
+        # matching url from product to download
+        if product is not None and len(product.assets) > 0:
+            matching_url = next(iter(product.assets.values()))["href"]
+        elif product is not None:
+            matching_url = product.properties.get(
+                "downloadLink"
+            ) or product.properties.get("orderLink")
+        else:
+            # search auth
+            matching_url = getattr(associated_plugin.config, "api_endpoint", None)
+
+        try:
+            auth_plugin = next(
+                self.get_auth_plugins(
+                    associated_plugin.provider,
+                    matching_url=matching_url,
+                    matching_conf=associated_plugin.config,
+                )
+            )
+        except StopIteration:
+            auth_plugin = None
+        return auth_plugin
+
+    def get_auth_plugins(
+        self,
+        provider: str,
+        matching_url: Optional[str] = None,
+        matching_conf: Optional[PluginConfig] = None,
+    ) -> Iterator[Authentication]:
         """Build and return the authentication plugin for the given product_type and
         provider
 
         :param provider: The provider for which to get the authentication plugin
-        :type provider: str
-        :returns: The Authentication plugin for the provider
-        :rtype: :class:`~eodag.plugins.authentication.Authentication`
+        :param matching_url: url to compare with plugin matching_url pattern
+        :param matching_conf: configuration to compare with plugin matching_conf
+        :returns: All the Authentication plugins for the given criteria
         """
-        plugin_conf = self.providers_config[provider]
-        try:
-            plugin_conf.auth.priority = plugin_conf.priority
-            plugin = cast(
-                Authentication,
-                self._build_plugin(provider, plugin_conf.auth, Authentication),
-            )
-            return plugin
-        except AttributeError:
-            # We guess the plugin being built is of type Api, therefore no need
-            # for an Auth plugin.
-            return None
+        auth_conf: Optional[PluginConfig] = None
+
+        def _is_auth_plugin_matching(
+            auth_conf: PluginConfig,
+            matching_url: Optional[str],
+            matching_conf: Optional[PluginConfig],
+        ) -> bool:
+            plugin_matching_conf = getattr(auth_conf, "matching_conf", {})
+            if matching_conf:
+                if (
+                    plugin_matching_conf
+                    and matching_conf.__dict__.items() >= plugin_matching_conf.items()
+                ):
+                    # conf matches
+                    return True
+            plugin_matching_url = getattr(auth_conf, "matching_url", None)
+            if matching_url:
+                if plugin_matching_url and re.match(
+                    rf"{plugin_matching_url}", matching_url
+                ):
+                    # url matches
+                    return True
+            if not plugin_matching_conf and not plugin_matching_url:
+                # plugin without match criteria
+                return True
+            else:
+                # no match
+                return False
+
+        # providers configs with given provider at first
+        sorted_providers_config = deepcopy(self.providers_config)
+        sorted_providers_config = {
+            provider: sorted_providers_config.pop(provider),
+            **sorted_providers_config,
+        }
+
+        for plugin_provider, provider_conf in sorted_providers_config.items():
+            for key in AUTH_TOPIC_KEYS:
+                auth_conf = getattr(provider_conf, key, None)
+                if auth_conf is None:
+                    continue
+                if _is_auth_plugin_matching(auth_conf, matching_url, matching_conf):
+                    auth_conf.priority = provider_conf.priority
+                    plugin = cast(
+                        Authentication,
+                        self._build_plugin(plugin_provider, auth_conf, Authentication),
+                    )
+                    yield plugin
+                else:
+                    continue
+
+    def get_auth(
+        self,
+        provider: str,
+        matching_url: Optional[str] = None,
+        matching_conf: Optional[PluginConfig] = None,
+    ) -> Optional[Union[AuthBase, Dict[str, str]]]:
+        """Authenticate and return the authenticated object for the first matching
+        authentication plugin
+
+        :param provider: The provider for which to get the authentication plugin
+        :param matching_url: url to compare with plugin matching_url pattern
+        :param matching_conf: configuration to compare with plugin matching_conf
+        :returns: All the Authentication plugins for the given criteria
+        """
+        for auth_plugin in self.get_auth_plugins(provider, matching_url, matching_conf):
+            if auth_plugin and callable(getattr(auth_plugin, "authenticate", None)):
+                try:
+                    auth = auth_plugin.authenticate()
+                    return auth
+                except (AuthenticationError, MisconfiguredError) as e:
+                    logger.debug(f"Could not authenticate on {provider}: {str(e)}")
+                    continue
+            else:
+                logger.debug(
+                    f"Could not authenticate on {provider} using {auth_plugin} plugin"
+                )
+                continue
+        return None
 
     @staticmethod
     def get_crunch_plugin(name: str, **options: Any) -> Crunch:
@@ -262,14 +399,11 @@ class PluginManager:
         it with the `options`
 
         :param name: The name of the Crunch plugin to instantiate
-        :type name: str
         :param options: The configuration parameters of the cruncher
-        :type options: dict
         :returns: The cruncher named `name`
-        :rtype: :class:`~eodag.plugins.crunch.Crunch`
         """
-        Klass = Crunch.get_plugin_by_class_name(name)
-        return Klass(options)
+        klass = Crunch.get_plugin_by_class_name(name)
+        return klass(options)
 
     def sort_providers(self) -> None:
         """Sort providers taking into account current priority order"""
@@ -280,9 +414,7 @@ class PluginManager:
         """Set the priority of the given provider
 
         :param provider: The provider which is assigned the priority
-        :type provider: str
         :param priority: The priority to assign to the provider
-        :type priority: int
         """
         # Update the priority in the configurations so that it is taken into account
         # when a plugin of this provider is latterly built
@@ -296,9 +428,11 @@ class PluginManager:
             # Sort the provider configs, taking into account the new priority order
             provider_configs.sort(key=attrgetter("priority"), reverse=True)
         # Update the priority of already built plugins of the given provider
-        for provider_name, topic_class in self._built_plugins_cache:
+        for provider_name, topic_class, auth_match_md5 in self._built_plugins_cache:
             if provider_name == provider:
-                self._built_plugins_cache[(provider, topic_class)].priority = priority
+                self._built_plugins_cache[
+                    (provider, topic_class, auth_match_md5)
+                ].priority = priority
 
     def _build_plugin(
         self,
@@ -310,19 +444,23 @@ class PluginManager:
         registered as the given provider
 
         :param provider: The provider for which to build the plugin
-        :type provider: str
         :param plugin_conf: The configuration of the plugin to be built
-        :type plugin_conf: :class:`~eodag.config.PluginConfig`
         :param topic_class: The type of plugin to build
-        :type topic_class: :class:`~eodag.plugin.base.PluginTopic`
         :returns: The built plugin
-        :rtype: :class:`~eodag.plugin.search.Search` or
                 :class:`~eodag.plugin.download.Download` or
                 :class:`~eodag.plugin.authentication.Authentication` or
                 :class:`~eodag.plugin.crunch.Crunch`
         """
+        # md5 hash to helps identifying an auth plugin within several for a given provider
+        # (each has distinct matching settings)
+        auth_match_md5 = dict_md5sum(
+            {
+                "matching_url": getattr(plugin_conf, "matching_url", None),
+                "matching_conf": getattr(plugin_conf, "matching_conf", None),
+            }
+        )
         cached_instance = self._built_plugins_cache.setdefault(
-            (provider, topic_class.__name__), None
+            (provider, topic_class.__name__, auth_match_md5), None
         )
         if cached_instance is not None:
             return cached_instance
@@ -332,5 +470,7 @@ class PluginManager:
         plugin: Union[Api, Search, Download, Authentication, Crunch] = plugin_class(
             provider, plugin_conf
         )
-        self._built_plugins_cache[(provider, topic_class.__name__)] = plugin
+        self._built_plugins_cache[
+            (provider, topic_class.__name__, auth_match_md5)
+        ] = plugin
         return plugin

eodag/plugins/search/__init__.py

@@ -16,3 +16,39 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """EODAG search package"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE
+
+if TYPE_CHECKING:
+    from typing import Any, Dict, List, Optional, Union
+
+    from requests.auth import AuthBase
+
+    from eodag.plugins.authentication.base import Authentication
+
+
+@dataclass
+class PreparedSearch:
+    """An object collecting needed information for search."""
+
+    product_type: Optional[str] = None
+    page: Optional[int] = DEFAULT_PAGE
+    items_per_page: Optional[int] = DEFAULT_ITEMS_PER_PAGE
+    auth: Optional[Union[AuthBase, Dict[str, str]]] = None
+    auth_plugin: Optional[Authentication] = None
+    count: bool = True
+    url: Optional[str] = None
+    info_message: Optional[str] = None
+    exception_message: Optional[str] = None
+
+    need_count: bool = field(init=False, repr=False)
+    query_params: Dict[str, Any] = field(init=False, repr=False)
+    query_string: str = field(init=False, repr=False)
+    search_urls: List[str] = field(init=False, repr=False)
+    product_type_def_params: Dict[str, Any] = field(init=False, repr=False)
+    total_items_nb: int = field(init=False, repr=False)
+    sort_by_qs: str = field(init=False, repr=False)