eodag 3.0.0b1__py3-none-any.whl → 3.0.0b3__py3-none-any.whl

eodag/config.py

@@ -47,6 +47,7 @@ from pkg_resources import resource_filename
 from requests.auth import AuthBase
 from typing_extensions import Doc
 
+from eodag.api.product.metadata_mapping import mtd_cfg_as_conversion_and_querypath
 from eodag.utils import (
     HTTP_REQ_TIMEOUT,
     USER_AGENT,
@@ -110,22 +111,14 @@ class ProviderConfig(yaml.YAMLObject):
     """Representation of eodag configuration.
 
     :param name: The name of the provider
-    :type name: str
     :param priority: (optional) The priority of the provider while searching a product.
                      Lower value means lower priority. (Default: 0)
-    :type priority: int
     :param api: (optional) The configuration of a plugin of type Api
-    :type api: :class:`~eodag.config.PluginConfig`
     :param search: (optional) The configuration of a plugin of type Search
-    :type search: :class:`~eodag.config.PluginConfig`
     :param products: (optional) The products types supported by the provider
-    :type products: dict
     :param download: (optional) The configuration of a plugin of type Download
-    :type download: :class:`~eodag.config.PluginConfig`
     :param auth: (optional) The configuration of a plugin of type Authentication
-    :type auth: :class:`~eodag.config.PluginConfig`
     :param kwargs: Additional configuration variables for this provider
-    :type kwargs: Any
     """
 
     name: str
@@ -171,7 +164,6 @@ class ProviderConfig(yaml.YAMLObject):
         """Validate a :class:`~eodag.config.ProviderConfig`
 
         :param config_keys: The configurations keys to validate
-        :type config_keys: dict
         """
         if "name" not in config_keys:
             raise ValidationError("Provider config must have name key")
@@ -189,7 +181,6 @@ class ProviderConfig(yaml.YAMLObject):
         """Update the configuration parameters with values from `mapping`
 
         :param mapping: The mapping from which to override configuration parameters
-        :type mapping: dict
         """
         if mapping is None:
             mapping = {}
@@ -215,12 +206,9 @@ class PluginConfig(yaml.YAMLObject):
     """Representation of a plugin config
 
     :param name: The name of the plugin class to use to instantiate the plugin object
-    :type name: str
     :param metadata_mapping: (optional) The mapping between eodag metadata and
                                   the plugin specific metadata
-    :type metadata_mapping: dict
     :param free_params: (optional) Additional configuration parameters
-    :type free_params: dict
     """
 
     class Pagination(TypedDict):
@@ -246,6 +234,14 @@ class PluginConfig(yaml.YAMLObject):
         sort_order_mapping: Dict[Literal["ascending", "descending"], str]
         max_sort_params: Annotated[int, Gt(0)]
 
+    class DiscoverMetadata(TypedDict):
+        """Configuration for metadata discovery"""
+
+        auto_discovery: bool
+        metadata_pattern: str
+        search_param: str
+        metadata_path: str
+
     class OrderOnResponse(TypedDict):
         """Configuration for order on-response during download"""
 
@@ -319,7 +315,7 @@ class PluginConfig(yaml.YAMLObject):
     pagination: PluginConfig.Pagination
     sort: PluginConfig.Sort
     query_params_key: str
-    discover_metadata: Dict[str, Union[str, bool]]
+    discover_metadata: PluginConfig.DiscoverMetadata
     discover_product_types: Dict[str, Any]
     discover_queryables: Dict[str, Any]
     metadata_mapping: Dict[str, Union[str, List[str]]]
@@ -343,9 +339,9 @@ class PluginConfig(yaml.YAMLObject):
 
     # download -------------------------------------------------------------------------
     base_uri: str
-    outputs_prefix: str
+    output_dir: str
     extract: bool
-    outputs_extension: str
+    output_extension: str
     order_enabled: bool  # HTTPDownload
     order_method: str  # HTTPDownload
     order_headers: Dict[str, str]  # HTTPDownload
@@ -419,7 +415,6 @@ class PluginConfig(yaml.YAMLObject):
         """Update the configuration parameters with values from `mapping`
 
         :param mapping: The mapping from which to override configuration parameters
-        :type mapping: dict
         """
         if mapping is None:
             mapping = {}
@@ -435,7 +430,6 @@ def load_default_config() -> Dict[str, ProviderConfig]:
     variable if exists.
 
     :returns: The default provider's configuration
-    :rtype: dict
     """
     eodag_providers_cfg_file = os.getenv(
         "EODAG_PROVIDERS_CFG_FILE"
@@ -447,9 +441,7 @@ def load_config(config_path: str) -> Dict[str, ProviderConfig]:
     """Load the providers configuration into a dictionnary from a given file
 
     :param config_path: The path to the provider config file
-    :type config_path: str
     :returns: The default provider's configuration
-    :rtype: dict
     """
     logger.debug("Loading configuration from %s", config_path)
     config: Dict[str, ProviderConfig] = {}
@@ -475,17 +467,15 @@ def provider_config_init(
     """Applies some default values to provider config
 
     :param provider_config: An eodag provider configuration
-    :type provider_config: :class:`~eodag.config.ProviderConfig`
     :param stac_search_default_conf: default conf to overwrite with provider_config if STAC
-    :type stac_search_default_conf: dict
     """
-    # For the provider, set the default outputs_prefix of its download plugin
+    # For the provider, set the default output_dir of its download plugin
     # as tempdir in a portable way
     for param_name in ("download", "api"):
         if param_name in vars(provider_config):
             param_value = getattr(provider_config, param_name)
-            if not getattr(param_value, "outputs_prefix", None):
-                param_value.outputs_prefix = tempfile.gettempdir()
+            if not getattr(param_value, "output_dir", None):
+                param_value.output_dir = tempfile.gettempdir()
             if not getattr(param_value, "delete_archive", None):
                 param_value.delete_archive = True
 
@@ -514,9 +504,7 @@ def override_config_from_file(config: Dict[str, Any], file_path: str) -> None:
     """Override a configuration with the values in a file
 
     :param config: An eodag providers configuration dictionary
-    :type config: dict
     :param file_path: The path to the file from where the new values will be read
-    :type file_path: str
     """
     logger.info("Loading user configuration from: %s", os.path.abspath(file_path))
     with open(os.path.abspath(os.path.realpath(file_path)), "r") as fh:
@@ -534,7 +522,6 @@ def override_config_from_env(config: Dict[str, Any]) -> None:
     """Override a configuration with environment variables values
 
     :param config: An eodag providers configuration dictionary
-    :type config: dict
     """
 
     def build_mapping_from_env(
@@ -554,11 +541,8 @@ def override_config_from_env(config: Dict[str, Any]) -> None:
             }
 
         :param env_var: The environment variable to be transformed into a dictionary
-        :type env_var: str
         :param env_value: The value from environment variable
-        :type env_value: str
         :param mapping: The mapping in which the value will be created
-        :type mapping: dict
         """
         parts = env_var.split("__")
         iter_parts = iter(parts)
@@ -610,11 +594,39 @@ def override_config_from_mapping(
     """Override a configuration with the values in a mapping
 
     :param config: An eodag providers configuration dictionary
-    :type config: dict
     :param mapping: The mapping containing the values to be overriden
-    :type mapping: dict
     """
     for provider, new_conf in mapping.items():
+        # check if metada-mapping as already been built as jsonpath in providers_config
+        if not isinstance(new_conf, dict):
+            continue
+        new_conf_search = new_conf.get("search", {}) or {}
+        new_conf_api = new_conf.get("api", {}) or {}
+        if provider in config and "metadata_mapping" in {
+            **new_conf_search,
+            **new_conf_api,
+        }:
+            search_plugin_key = (
+                "search" if "metadata_mapping" in new_conf_search else "api"
+            )
+            # get some already configured value
+            configured_metadata_mapping = getattr(
+                config[provider], search_plugin_key
+            ).metadata_mapping
+            some_configured_value = next(iter(configured_metadata_mapping.values()))
+            # check if the configured value has already been built as jsonpath
+            if (
+                isinstance(some_configured_value, list)
+                and isinstance(some_configured_value[1], tuple)
+                or isinstance(some_configured_value, tuple)
+            ):
+                # also build as jsonpath the incoming conf
+                mtd_cfg_as_conversion_and_querypath(
+                    deepcopy(mapping[provider][search_plugin_key]["metadata_mapping"]),
+                    mapping[provider][search_plugin_key]["metadata_mapping"],
+                )
+
+        # try overriding conf
         old_conf: Optional[Dict[str, Any]] = config.get(provider)
         if old_conf is not None:
             old_conf.update(new_conf)
@@ -640,9 +652,7 @@ def merge_configs(config: Dict[str, Any], other_config: Dict[str, Any]) -> None:
     """Override a configuration with the values of another configuration
 
     :param config: An eodag providers configuration dictionary
-    :type config: dict
     :param other_config: An eodag providers configuration dictionary
-    :type other_config: dict
     """
     # configs union with other_config values as default
     other_config = dict(config, **other_config)
@@ -674,7 +684,6 @@ def load_yml_config(yml_path: str) -> Dict[Any, Any]:
     """Load a conf dictionnary from given yml absolute path
 
     :returns: The yml configuration file
-    :rtype: dict
     """
     config = SimpleYamlProxyConfig(yml_path)
     return dict_items_recursive_apply(config.source, string_to_jsonpath)
@@ -684,7 +693,6 @@ def load_stac_config() -> Dict[str, Any]:
     """Load the stac configuration into a dictionnary
 
     :returns: The stac configuration
-    :rtype: dict
     """
     return load_yml_config(
         resource_filename("eodag", os.path.join("resources/", "stac.yml"))
@@ -695,7 +703,6 @@ def load_stac_api_config() -> Dict[str, Any]:
     """Load the stac API configuration into a dictionnary
 
     :returns: The stac API configuration
-    :rtype: dict
     """
     return load_yml_config(
         resource_filename("eodag", os.path.join("resources/", "stac_api.yml"))
@@ -706,7 +713,6 @@ def load_stac_provider_config() -> Dict[str, Any]:
     """Load the stac provider configuration into a dictionnary
 
     :returns: The stac provider configuration
-    :rtype: dict
     """
     return SimpleYamlProxyConfig(
         resource_filename("eodag", os.path.join("resources/", "stac_provider.yml"))
@@ -719,9 +725,7 @@ def get_ext_product_types_conf(
     """Read external product types conf
 
     :param conf_uri: URI to local or remote configuration file
-    :type conf_uri: str
     :returns: The external product types configuration
-    :rtype: dict
     """
     logger.info("Fetching external product types from %s", conf_uri)
     if conf_uri.lower().startswith("http"):

eodag/plugins/apis/base.py

@@ -33,17 +33,17 @@ class Api(Search, Download):
 
     The download methods must:
 
-    - download data in the ``outputs_prefix`` folder defined in the plugin's
+    - download data in the ``output_dir`` folder defined in the plugin's
       configuration or passed through kwargs
     - extract products from their archive (if relevant) if ``extract`` is set to True
       (True by default)
-    - save a product in an archive/directory (in ``outputs_prefix``) whose name must be
+    - save a product in an archive/directory (in ``output_dir``) whose name must be
       the product's ``title`` property
     - update the product's ``location`` attribute once its data is downloaded (and
       eventually after it's extracted) to the product's location given as a file URI
       (e.g. 'file:///tmp/product_folder' on Linux or
       'file:///C:/Users/username/AppData/LOcal/Temp' on Windows)
-    - save a *record* file in the directory ``outputs_prefix/.downloaded`` whose name
+    - save a *record* file in the directory ``output_dir/.downloaded`` whose name
       is built on the MD5 hash of the product's ``product_type`` and ``properties['id']``
       attributes (``hashlib.md5((product.product_type+"-"+product.properties['id']).encode("utf-8")).hexdigest()``)
       and whose content is the product's ``remote_location`` attribute itself.

eodag/plugins/apis/ecmwf.py

@@ -128,7 +128,6 @@ class EcmwfApi(Api, BuildPostSearchResult):
         """Check credentials and returns information needed for auth
 
         :returns: {key, url, email} dictionary
-        :rtype: dict
         :raises: :class:`~eodag.utils.exceptions.AuthenticationError`
         """
         # Get credentials from eodag or using ecmwf conf
@@ -165,8 +164,8 @@ class EcmwfApi(Api, BuildPostSearchResult):
         """Download data from ECMWF MARS"""
         product_format = product.properties.get("format", "grib")
         product_extension = ECMWF_MARS_KNOWN_FORMATS.get(product_format, product_format)
-        kwargs["outputs_extension"] = kwargs.get(
-            "outputs_extension", f".{product_extension}"
+        kwargs["output_extension"] = kwargs.get(
+            "output_extension", f".{product_extension}"
         )
 
         # Prepare download

eodag/plugins/apis/usgs.py

@@ -128,13 +128,14 @@ class UsgsApi(Api):
             raise NoMatchingProductType(
                 "Cannot search on USGS without productType specified"
             )
-        if kwargs.get("sortBy"):
+        if kwargs.get("sort_by"):
             raise ValidationError("USGS does not support sorting feature")
 
         self.authenticate()
 
         product_type_def_params = self.config.products.get(  # type: ignore
-            product_type, self.config.products[GENERIC_PRODUCT_TYPE]  # type: ignore
+            product_type,
+            self.config.products[GENERIC_PRODUCT_TYPE],  # type: ignore
         )
         usgs_dataset = format_dict_items(product_type_def_params, **kwargs)["dataset"]
         start_date = kwargs.pop("startTimeFromAscendingNode", None)
@@ -172,11 +173,39 @@ class UsgsApi(Api):
                 max_results=items_per_page,
                 starting_number=(1 + (page - 1) * items_per_page),
             )
-            logger.info(
-                f"Sending search request for {usgs_dataset} with {api_search_kwargs}"
-            )
 
-            results = api.scene_search(usgs_dataset, **api_search_kwargs)
+            # search by id
+            if searched_id := kwargs.get("id"):
+                dataset_filters = api.dataset_filters(usgs_dataset)
+                # ip pattern set as parameter queryable (first element of param conf list)
+                id_pattern = self.config.metadata_mapping["id"][0]
+                # loop on matching dataset_filters until one returns expected results
+                for dataset_filter in dataset_filters["data"]:
+                    if id_pattern in dataset_filter["searchSql"]:
+                        logger.debug(
+                            f"Try using {dataset_filter['searchSql']} dataset filter to search by id on {usgs_dataset}"
+                        )
+                        full_api_search_kwargs = {
+                            "where": {
+                                "filter_id": dataset_filter["id"],
+                                "value": searched_id,
+                            },
+                            **api_search_kwargs,
+                        }
+                        logger.info(
+                            f"Sending search request for {usgs_dataset} with {full_api_search_kwargs}"
+                        )
+                        results = api.scene_search(
+                            usgs_dataset, **full_api_search_kwargs
+                        )
+                        if len(results["data"]["results"]) == 1:
+                            # search by id using this dataset_filter succeeded
+                            break
+            else:
+                logger.info(
+                    f"Sending search request for {usgs_dataset} with {api_search_kwargs}"
+                )
+                results = api.scene_search(usgs_dataset, **api_search_kwargs)
 
             # update results with storage info from download_options()
             results_by_entity_id = {
@@ -257,13 +286,13 @@ class UsgsApi(Api):
             )
             progress_callback = ProgressCallback(disable=True)
 
-        outputs_extension = cast(
+        output_extension = cast(
             str,
             self.config.products.get(  # type: ignore
                 product.product_type, self.config.products[GENERIC_PRODUCT_TYPE]  # type: ignore
-            ).get("outputs_extension", ".tar.gz"),
+            ).get("output_extension", ".tar.gz"),
         )
-        kwargs["outputs_extension"] = kwargs.get("outputs_extension", outputs_extension)
+        kwargs["output_extension"] = kwargs.get("output_extension", output_extension)
 
         fs_path, record_filename = self._prepare_download(
             product,
@@ -375,8 +404,8 @@ class UsgsApi(Api):
 
         # Check downloaded file format
         if (
-            kwargs["outputs_extension"] == ".tar.gz" and tarfile.is_tarfile(fs_path)
-        ) or (kwargs["outputs_extension"] == ".zip" and zipfile.is_zipfile(fs_path)):
+            kwargs["output_extension"] == ".tar.gz" and tarfile.is_tarfile(fs_path)
+        ) or (kwargs["output_extension"] == ".zip" and zipfile.is_zipfile(fs_path)):
             product_path = self._finalize(
                 fs_path,
                 progress_callback=progress_callback,
@@ -388,7 +417,7 @@ class UsgsApi(Api):
             logger.info(
                 "Downloaded product detected as a tar File, but was was expected to be a zip file"
             )
-            new_fs_path = fs_path[: fs_path.index(outputs_extension)] + ".tar.gz"
+            new_fs_path = fs_path[: fs_path.index(output_extension)] + ".tar.gz"
             shutil.move(fs_path, new_fs_path)
             product.location = path_to_uri(new_fs_path)
             return new_fs_path
@@ -396,7 +425,7 @@ class UsgsApi(Api):
             logger.info(
                 "Downloaded product detected as a zip File, but was was expected to be a tar file"
             )
-            new_fs_path = fs_path[: fs_path.index(outputs_extension)] + ".zip"
+            new_fs_path = fs_path[: fs_path.index(output_extension)] + ".zip"
             shutil.move(fs_path, new_fs_path)
             product.location = path_to_uri(new_fs_path)
             return new_fs_path
@@ -404,7 +433,7 @@ class UsgsApi(Api):
             logger.warning(
                 "Downloaded product is not a tar or a zip File. Please check its file type before using it"
             )
-            new_fs_path = fs_path[: fs_path.index(outputs_extension)]
+            new_fs_path = fs_path[: fs_path.index(output_extension)]
             shutil.move(fs_path, new_fs_path)
             product.location = path_to_uri(new_fs_path)
             return new_fs_path

eodag/plugins/authentication/aws_auth.py

@@ -35,6 +35,7 @@ class AwsAuth(Authentication):
     - auth anonymously using no-sign-request
     - auth using ``aws_profile``
     - auth using ``aws_access_key_id`` and ``aws_secret_access_key``
+      (optionally ``aws_session_token``)
     - auth using current environment (AWS environment variables and/or ``~/aws/*``),
       will be skipped if AWS credentials are filled in eodag conf
     """
@@ -45,13 +46,13 @@ class AwsAuth(Authentication):
         super(AwsAuth, self).__init__(provider, config)
         self.aws_access_key_id = None
         self.aws_secret_access_key = None
+        self.aws_session_token = None
         self.profile_name = None
 
     def authenticate(self) -> Dict[str, str]:
         """Authenticate
 
         :returns: dict containing AWS/boto3 non-empty credentials
-        :rtype: dict
         """
         credentials = getattr(self.config, "credentials", {}) or {}
         self.aws_access_key_id = credentials.get(
@@ -60,7 +61,15 @@ class AwsAuth(Authentication):
         self.aws_secret_access_key = credentials.get(
             "aws_secret_access_key", self.aws_secret_access_key
         )
+        self.aws_session_token = credentials.get(
+            "aws_session_token", self.aws_session_token
+        )
         self.profile_name = credentials.get("aws_profile", self.profile_name)
 
-        auth_keys = ["aws_access_key_id", "aws_secret_access_key", "profile_name"]
+        auth_keys = [
+            "aws_access_key_id",
+            "aws_secret_access_key",
+            "aws_session_token",
+            "profile_name",
+        ]
         return {k: getattr(self, k) for k in auth_keys if getattr(self, k)}

eodag/plugins/authentication/openid_connect.py

@@ -482,7 +482,7 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
         if not match:
             return value
         value_from_xpath = form_element.xpath(
-            self.CONFIG_XPATH_REGEX.match(value).groupdict("xpath_value")["xpath_value"]
+            match.groupdict("xpath_value")["xpath_value"]
         )
         if len(value_from_xpath) == 1:
             return value_from_xpath[0]
@@ -512,10 +512,11 @@ class CodeAuthorizedAuth(AuthBase):
     def __call__(self, request: PreparedRequest) -> PreparedRequest:
         """Perform the actual authentication"""
         if self.where == "qs":
-            parts = urlparse(request.url)
+            parts = urlparse(str(request.url))
             query_dict = parse_qs(parts.query)
-            query_dict.update({self.key: self.token})
-            url_without_args = parts._replace(query=None).geturl()
+            if self.key is not None:
+                query_dict.update({self.key: [self.token]})
+            url_without_args = parts._replace(query="").geturl()
 
             request.prepare_url(url_without_args, query_dict)
 

eodag/plugins/authentication/token.py

@@ -197,7 +197,8 @@ class RequestsTokenAuth(AuthBase):
         if self.where == "qs":
             parts = urlparse(str(request.url))
             qs = parse_qs(parts.query)
-            qs[self.qs_key] = self.token  # type: ignore
+            if self.qs_key is not None:
+                qs[self.qs_key] = [self.token]
             request.url = urlunparse(
                 (
                     parts.scheme,

eodag/plugins/crunch/base.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
+from eodag.config import PluginConfig
 from eodag.plugins.base import PluginTopic
 
 if TYPE_CHECKING:
@@ -29,7 +30,8 @@ class Crunch(PluginTopic):
     """Base cruncher"""
 
     def __init__(self, config: Optional[Dict[str, Any]]) -> None:
-        self.config = config if config is not None else {}
+        self.config = PluginConfig()
+        self.config.__dict__ = config if config is not None else {}
 
     def proceed(
         self, products: List[EOProduct], **search_params: Any

eodag/plugins/crunch/filter_date.py

@@ -21,7 +21,7 @@ import datetime
 import logging
 import time
 from datetime import datetime as dt
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, List
 
 import dateutil.parser
 from dateutil import tz
@@ -41,12 +41,8 @@ class FilterDate(Crunch):
 
                    - `start`: (optional) start sensing time in iso format
                    - `end`: (optional) end sensing time in iso format
-
-    :type config: dict
     """
 
-    config: Dict[str, str]
-
     @staticmethod
     def sort_product_by_start_date(product: EOProduct) -> dt:
         """Get product start date"""
@@ -63,16 +59,14 @@ class FilterDate(Crunch):
         """Execute crunch: Filter products between start and end dates.
 
         :param products: A list of products resulting from a search
-        :type products: list(:class:`~eodag.api.product._product.EOProduct`)
         :returns: The filtered products
-        :rtype: list(:class:`~eodag.api.product._product.EOProduct`)
         """
         logger.debug("Start filtering by date")
         if not products:
             return []
 
         # filter start date
-        filter_start_str = self.config.get("start", None)
+        filter_start_str = self.config.__dict__.get("start", None)
         if filter_start_str:
             filter_start = dateutil.parser.parse(filter_start_str)
             if not filter_start.tzinfo:
@@ -81,7 +75,7 @@ class FilterDate(Crunch):
             filter_start = None
 
         # filter end date
-        filter_end_str = self.config.get("end", None)
+        filter_end_str = self.config.__dict__.get("end", None)
         if filter_end_str:
             filter_end = dateutil.parser.parse(filter_end_str)
             if not filter_end.tzinfo:

eodag/plugins/crunch/filter_latest_intersect.py

@@ -59,12 +59,9 @@ class FilterLatestIntersect(Crunch):
         Filter latest products (the ones with a the highest start date) that intersect search extent.
 
         :param products: A list of products resulting from a search
-        :type products: list(:class:`~eodag.api.product._product.EOProduct`)
         :param search_params: Search criteria that must contain `geometry` (dict)
                               or search `geom` (:class:`shapely.geometry.base.BaseGeometry`) argument will be used
-        :type search_params: dict
         :returns: The filtered products
-        :rtype: list(:class:`~eodag.api.product._product.EOProduct`)
         """
         logger.debug("Start filtering for latest products")
         if not products:

eodag/plugins/crunch/filter_latest_tpl_name.py

@@ -26,6 +26,7 @@ from eodag.utils.exceptions import ValidationError
 
 if TYPE_CHECKING:
     from eodag.api.product import EOProduct
+
 logger = logging.getLogger("eodag.crunch.latest_tpl_name")
 
 
@@ -37,8 +38,6 @@ class FilterLatestByName(Crunch):
     :param config: Crunch configuration, must contain :
 
                    - `name_pattern` : product name pattern
-
-    :type config: dict
     """
 
     NAME_PATTERN_CONSTRAINT = re.compile(r"\(\?P<tileid>\\d\{6\}\)")
@@ -60,9 +59,7 @@ class FilterLatestByName(Crunch):
         """Execute crunch: Filter Search results to get only the latest product, based on the name of the product
 
         :param products: A list of products resulting from a search
-        :type products: list(:class:`~eodag.api.product._product.EOProduct`)
         :returns: The filtered products
-        :rtype: list(:class:`~eodag.api.product._product.EOProduct`)
         """
         logger.debug("Starting products filtering")
         processed: List[str] = []

eodag/plugins/crunch/filter_overlap.py

@@ -48,7 +48,6 @@ class FilterOverlap(Crunch):
                    - `within` : True if product geometry is within the search area
 
                    These configuration parameters are mutually exclusive.
-    :type config: dict
     """
 
     def proceed(
@@ -57,11 +56,8 @@ class FilterOverlap(Crunch):
         """Execute crunch: Filter products, retaining only those that are overlapping with the search_extent
 
         :param products: A list of products resulting from a search
-        :type products: list(:class:`~eodag.api.product._product.EOProduct`)
         :param search_params: Search criteria that must contain `geometry`
-        :type search_params: dict
         :returns: The filtered products
-        :rtype: list(:class:`~eodag.api.product._product.EOProduct`)
         """
         logger.debug("Start filtering for overlapping products")
         filtered: List[EOProduct] = []
@@ -73,10 +69,10 @@ class FilterOverlap(Crunch):
                 "geometry not found in cruncher arguments, filtering disabled."
             )
             return products
-        minimum_overlap = float(self.config.get("minimum_overlap", "0"))
-        contains = self.config.get("contains", False)
-        intersects = self.config.get("intersects", False)
-        within = self.config.get("within", False)
+        minimum_overlap = float(self.config.__dict__.get("minimum_overlap", "0"))
+        contains = self.config.__dict__.get("contains", False)
+        intersects = self.config.__dict__.get("intersects", False)
+        within = self.config.__dict__.get("within", False)
 
         if contains and (within or intersects) or (within and intersects):
             logger.warning(