eodag 3.0.0b2__py3-none-any.whl → 3.0.1__py3-none-any.whl

eodag/plugins/authentication/token.py

@@ -28,7 +28,13 @@ from requests.auth import AuthBase
 from urllib3 import Retry
 
 from eodag.plugins.authentication.base import Authentication
-from eodag.utils import HTTP_REQ_TIMEOUT, USER_AGENT
+from eodag.utils import (
+    HTTP_REQ_TIMEOUT,
+    REQ_RETRY_BACKOFF_FACTOR,
+    REQ_RETRY_STATUS_FORCELIST,
+    REQ_RETRY_TOTAL,
+    USER_AGENT,
+)
 from eodag.utils.exceptions import AuthenticationError, MisconfiguredError, TimeOutError
 
 if TYPE_CHECKING:
@@ -41,7 +47,36 @@ logger = logging.getLogger("eodag.authentication.token")
 
 
 class TokenAuth(Authentication):
-    """TokenAuth authentication plugin"""
+    """TokenAuth authentication plugin - fetches a token which is added to search/download requests
+
+    :param provider: provider name
+    :param config: Authentication plugin configuration:
+
+        * :attr:`~eodag.config.PluginConfig.type` (``str``) (**mandatory**): TokenAuth
+        * :attr:`~eodag.config.PluginConfig.auth_uri` (``str``) (**mandatory**): url used to fetch
+          the access token with user/password
+        * :attr:`~eodag.config.PluginConfig.refresh_uri` (``str``) : url used to fetch the
+          access token with a refresh token
+        * :attr:`~eodag.config.PluginConfig.token_type` (``str``): type of the token (``json``
+          or ``text``); default: ``text``
+        * :attr:`~eodag.config.PluginConfig.token_key` (``str``): (mandatory if token_type=json)
+          key to get the access token in the response to the token request
+        * :attr:`~eodag.config.PluginConfig.refresh_token_key` (``str``): key to get the refresh
+          token in the response to the token request
+        * :attr:`~eodag.config.PluginConfig.ssl_verify` (``bool``): if the ssl certificates
+          should be verified in the requests; default: ``True``
+        * :attr:`~eodag.config.PluginConfig.auth_error_code` (``int``): which error code is
+          returned in case of an authentication error
+        * :attr:`~eodag.config.PluginConfig.req_data` (``Dict[str, Any]``): if the credentials
+          should be sent as data in the post request, the json structure can be given in this parameter
+        * :attr:`~eodag.config.PluginConfig.retry_total` (``int``): :class:`urllib3.util.Retry` ``total`` parameter,
+          total number of retries to allow; default: ``3``
+        * :attr:`~eodag.config.PluginConfig.retry_backoff_factor` (``int``): :class:`urllib3.util.Retry`
+          ``backoff_factor`` parameter, backoff factor to apply between attempts after the second try; default: ``2``
+        * :attr:`~eodag.config.PluginConfig.retry_status_forcelist` (``List[int]``): :class:`urllib3.util.Retry`
+          ``status_forcelist`` parameter, list of integer HTTP status codes that we should force a retry on; default:
+          ``[401, 429, 500, 502, 503, 504]``
+    """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
         super(TokenAuth, self).__init__(provider, config)
@@ -89,14 +124,15 @@ class TokenAuth(Authentication):
                 and e.response.status_code in auth_errors
             ):
                 raise AuthenticationError(
-                    f"HTTP Error {e.response.status_code} returned, {response_text}\n"
-                    f"Please check your credentials for {self.provider}"
-                )
+                    f"Please check your credentials for {self.provider}.",
+                    f"HTTP Error {e.response.status_code} returned.",
+                    response_text,
+                ) from e
             # other error
             else:
                 raise AuthenticationError(
-                    f"Could no get authentication token: {str(e)}, {response_text}"
-                )
+                    "Could no get authentication token", str(e), response_text
+                ) from e
         else:
             if getattr(self.config, "token_type", "text") == "json":
                 token = response.json()[self.config.token_key]
@@ -116,16 +152,25 @@ class TokenAuth(Authentication):
         self,
         session: requests.Session,
     ) -> requests.Response:
+        retry_total = getattr(self.config, "retry_total", REQ_RETRY_TOTAL)
+        retry_backoff_factor = getattr(
+            self.config, "retry_backoff_factor", REQ_RETRY_BACKOFF_FACTOR
+        )
+        retry_status_forcelist = getattr(
+            self.config, "retry_status_forcelist", REQ_RETRY_STATUS_FORCELIST
+        )
+
         retries = Retry(
-            total=3,
-            backoff_factor=2,
-            status_forcelist=[401, 429, 500, 502, 503, 504],
+            total=retry_total,
+            backoff_factor=retry_backoff_factor,
+            status_forcelist=retry_status_forcelist,
         )
 
         # append headers to req if some are specified in config
         req_kwargs: Dict[str, Any] = {
             "headers": dict(self.config.headers, **USER_AGENT)
         }
+        ssl_verify = getattr(self.config, "ssl_verify", True)
 
         if self.refresh_token:
             logger.debug("fetching access token with refresh token")
@@ -135,6 +180,7 @@ class TokenAuth(Authentication):
                     self.config.refresh_uri,
                     data={"refresh_token": self.refresh_token},
                     timeout=HTTP_REQ_TIMEOUT,
+                    verify=ssl_verify,
                     **req_kwargs,
                 )
                 response.raise_for_status()
@@ -170,6 +216,7 @@ class TokenAuth(Authentication):
             method=method,
             url=self.config.auth_uri,
             timeout=HTTP_REQ_TIMEOUT,
+            verify=ssl_verify,
             **req_kwargs,
         )
 
@@ -197,7 +244,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/authentication/token_exchange.py

@@ -38,25 +38,23 @@ class OIDCTokenExchangeAuth(Authentication):
     """Token exchange implementation using
         :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth` token as subject.
 
-    The configuration keys of this plugin are as follows (they have no defaults)::
+    :param provider: provider name
+    :param config: Authentication plugin configuration:
+
+        * :attr:`~eodag.config.PluginConfig.subject` (``Dict[str, Any]``) (**mandatory**):
+          The full :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth` plugin
+          configuration used to retrieve subject token
+        * :attr:`~eodag.config.PluginConfig.subject_issuer` (``str``) (**mandatory**): Identifies
+          the issuer of the subject_token
+        * :attr:`~eodag.config.PluginConfig.token_uri` (``str``) (**mandatory**): The url to
+          query to get the authorized token
+        * :attr:`~eodag.config.PluginConfig.client_id` (``str``) (**mandatory**): The OIDC
+          provider's client ID of the eodag provider
+        * :attr:`~eodag.config.PluginConfig.audience` (``str``) (**mandatory**): This parameter
+          specifies the target client you want the new token minted for.
+        * :attr:`~eodag.config.PluginConfig.token_key` (``str``) (**mandatory**): The key
+          pointing to the token in the json response to the POST request to the token server
 
-        # (mandatory) The full OIDCAuthorizationCodeFlowAuth plugin configuration used to retrieve subject token
-        subject:
-
-        # (mandatory) Identifies the issuer of the subject_token
-        subject_issuer:
-
-        # (mandatory) The url to query to get the authorized token
-        token_uri:
-
-        # (mandatory) The OIDC provider's client ID of the eodag provider
-        client_id:
-
-        # (mandatory) This parameter specifies the target client you want the new token minted for.
-        audience:
-
-        # (mandatory) The key pointing to the token in the json response to the POST request to the token server
-        token_key:
     """
 
     GRANT_TYPE = "urn:ietf:params:oauth:grant-type:token-exchange"
@@ -71,7 +69,7 @@ class OIDCTokenExchangeAuth(Authentication):
     ]
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
-        super(OIDCTokenExchangeAuth, self).__init__(provider, config)
+        super().__init__(provider, config)
         for required_key in self.REQUIRED_KEYS:
             if getattr(self.config, required_key, None) is None:
                 raise MisconfiguredError(
@@ -100,12 +98,14 @@ class OIDCTokenExchangeAuth(Authentication):
             "audience": self.config.audience,
         }
         logger.debug("Getting target auth token")
+        ssl_verify = getattr(self.config, "ssl_verify", True)
         try:
             auth_response = self.subject.session.post(
                 self.config.token_uri,
                 data=auth_data,
                 headers=USER_AGENT,
                 timeout=HTTP_REQ_TIMEOUT,
+                verify=ssl_verify,
             )
             auth_response.raise_for_status()
         except requests.exceptions.Timeout as exc:

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:
@@ -26,10 +27,14 @@ if TYPE_CHECKING:
 
 
 class Crunch(PluginTopic):
-    """Base cruncher"""
+    """Base cruncher
+
+    :param config: Crunch configuration
+    """
 
     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
@@ -37,16 +37,15 @@ logger = logging.getLogger("eodag.crunch.date")
 class FilterDate(Crunch):
     """FilterDate cruncher: filter products by date
 
-    :param config: Crunch configuration, may contain :
+    Allows to filter out products that are older than a start date (optional) or more recent than an end date
+    (optional).
 
-                   - `start`: (optional) start sensing time in iso format
-                   - `end`: (optional) end sensing time in iso format
+    :param config: Crunch configuration, may contain :
 
-    :type config: dict
+        * ``start`` (``str``): start sensing time in iso format
+        * ``end`` (``str``): end sensing time in iso format
     """
 
-    config: Dict[str, str]
-
     @staticmethod
     def sort_product_by_start_date(product: EOProduct) -> dt:
         """Get product start date"""
@@ -63,16 +62,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 +78,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

@@ -39,7 +39,8 @@ logger = logging.getLogger("eodag.crunch.latest_intersect")
 class FilterLatestIntersect(Crunch):
     """FilterLatestIntersect cruncher
 
-    Filter latest products (the ones with a the highest start date) that intersect search extent
+    Filter latest products (the ones with a the highest start date) that intersect search extent;
+    The configuration for this plugin is an empty dict
     """
 
     @staticmethod
@@ -53,18 +54,15 @@ class FilterLatestIntersect(Crunch):
         return dateutil.parser.parse(start_date)
 
     def proceed(
-        self, products: List[EOProduct], **search_params: Any
+        self, products: List[EOProduct], **search_params: Dict[str, Any]
     ) -> List[EOProduct]:
         """Execute 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
+        :param search_params: Search criteria that must contain ``geometry`` or ``geom`` parameters having value of
+                              type :class:`shapely.geometry.base.BaseGeometry` or ``Dict[str, Any]``
         :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")
 
 
@@ -36,9 +37,7 @@ class FilterLatestByName(Crunch):
 
     :param config: Crunch configuration, must contain :
 
-                   - `name_pattern` : product name pattern
-
-    :type config: dict
+        * ``name_pattern`` (``str``) (**mandatory**): product name pattern
     """
 
     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

@@ -40,15 +40,12 @@ class FilterOverlap(Crunch):
 
     Filter products, retaining only those that are overlapping with the search_extent
 
-    :param config: Crunch configuration, may contain :
+    :param config: Crunch configuration may contain the following parameters which are mutually exclusive:
 
-                   - `minimum_overlap` : minimal overlap percentage
-                   - `contains` : True if product geometry contains the search area
-                   - `intersects` : True if product geometry intersects the search area
-                   - `within` : True if product geometry is within the search area
-
-                   These configuration parameters are mutually exclusive.
-    :type config: dict
+        * ``minimum_overlap`` (``Union[float, str]``): minimal overlap percentage; default: ``"0"``
+        * ``contains`` (``bool``): ``True`` if product geometry contains the search area; default: ``False``
+        * ``intersects`` (``bool``): ``True`` if product geometry intersects the search area; default: ``False``
+        * ``within`` (``bool``): ``True`` if product geometry is within the search area; default: ``False``
     """
 
     def proceed(
@@ -57,11 +54,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 +67,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(

eodag/plugins/crunch/filter_property.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 
 import logging
 import operator
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, List
 
 from eodag.plugins.crunch.base import Crunch
 
@@ -34,27 +34,22 @@ class FilterProperty(Crunch):
 
     Filter products, retaining only those whose property match criteria
 
-    :param config: Crunch configuration, should contain :
+    :param config: Crunch configuration, must contain :
 
-                   - `property=value` : property key from product.properties, associated to its filter value
-                   - `operator` : (optional) Operator used for filtering (one of `lt,le,eq,ne,ge,gt`). Default is `eq`
-
-    :type config: dict
+        * ``<property>`` ``(Any)`` (**mandatory**): property key from ``product.properties``, associated to its filter
+          value
+        * ``operator`` (``str``): Operator used for filtering (one of ``lt,le,eq,ne,ge,gt``). Default is ``eq``
     """
 
-    config: Dict[str, Union[str, Optional[str]]]
-
     def proceed(
         self, products: List[EOProduct], **search_params: Any
     ) -> List[EOProduct]:
         """Execute crunch: Filter products, retaining only those that match property filtering
 
         :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`)
         """
-        operator_name = self.config.pop("operator", "eq") or "eq"
+        operator_name = self.config.__dict__.pop("operator", "eq") or "eq"
         try:
             operator_method = getattr(operator, operator_name)
         except AttributeError:
@@ -64,12 +59,12 @@ class FilterProperty(Crunch):
             )
             return products
 
-        if len(self.config.keys()) != 1:
+        if len(self.config.__dict__.keys()) != 1:
             logger.warning("One property is needed for filtering, filtering disabled.")
             return products
 
-        property_key = next(iter(self.config))
-        property_value = self.config.get(property_key, None)
+        property_key = next(iter(self.config.__dict__))
+        property_value = self.config.__dict__.get(property_key, None)
 
         logger.debug(
             "Start filtering for products matching operator.%s(product.properties['%s'], %s)",