eodag 3.6.0__py3-none-any.whl → 3.8.0__py3-none-any.whl

eodag/rest/core.py

@@ -23,6 +23,7 @@ import os
 import re
 from typing import TYPE_CHECKING, cast
 from unittest.mock import Mock
+from urllib.parse import urlencode
 
 import dateutil
 from cachetools.func import lru_cache
@@ -67,8 +68,6 @@ from eodag.utils import (
     deepcopy,
     dict_items_recursive_apply,
     format_dict_items,
-    obj_md5sum,
-    urlencode,
 )
 from eodag.utils.exceptions import (
     MisconfiguredError,
@@ -123,7 +122,7 @@ def format_product_types(product_types: list[dict[str, Any]]) -> str:
     """
     result: list[str] = []
     for pt in product_types:
-        result.append(f'* *__{pt["ID"]}__*: {pt["abstract"]}')
+        result.append(f"* *__{pt['ID']}__*: {pt['abstract']}")
     return "\n".join(sorted(result))
 
 
@@ -266,11 +265,7 @@ def download_stac_item(
             _order_and_update(product, auth, kwargs)
 
         download_stream = product.downloader._stream_download_dict(
-            product,
-            auth=auth,
-            asset=asset,
-            wait=-1,
-            timeout=-1,
+            product, auth=auth, asset=asset, wait=-1, timeout=-1
         )
     except NotImplementedError:
         logger.warning(
@@ -686,7 +681,7 @@ def crunch_products(
     cruncher = crunchers.get(cruncher_name)
     if not cruncher:
         raise ValidationError(
-            f'Unknown crunch name. Use one of: {", ".join(crunchers.keys())}'
+            f"Unknown crunch name. Use one of: {', '.join(crunchers.keys())}"
         )
 
     cruncher_config: dict[str, Any] = {}
@@ -696,7 +691,7 @@ def crunch_products(
             raise ValidationError(
                 (
                     f"cruncher {cruncher} require additional parameters:"
-                    f' {", ".join(cruncher.config_params)}'
+                    f" {', '.join(cruncher.config_params)}"
                 )
             )
         cruncher_config[config_param] = config_param_value
@@ -756,12 +751,6 @@ def eodag_api_init() -> None:
             clean = {k: v for k, v in update_fields.items() if v}
             p_f.update(clean)
 
-    eodag_api.product_types_config_md5 = obj_md5sum(
-        eodag_api.product_types_config.source
-    )
-
-    eodag_api.build_index()
-
     # pre-build search plugins
     for provider in eodag_api.available_providers():
         next(eodag_api._plugins_manager.get_search_plugins(provider=provider))

eodag/rest/stac.py

@@ -790,10 +790,6 @@ class StacCollection(StacCommon):
                 f"Product type keywords: {str(product_type_collection['keywords'])}",
             )
 
-        # merge providers
-        if "providers" in ext_stac_collection:
-            ext_stac_collection["providers"] += product_type_collection["providers"]
-
         product_type_collection.update(ext_stac_collection)
 
         # parse f-strings

eodag/utils/__init__.py

@@ -36,6 +36,7 @@ import re
 import shutil
 import ssl
 import string
+import struct
 import sys
 import types
 import unicodedata
@@ -61,18 +62,7 @@ from typing import (
     Union,
     cast,
 )
-
-# All modules using these should import them from utils package
-from urllib.parse import (  # noqa; noqa
-    parse_qs,
-    parse_qsl,
-    quote,
-    unquote,
-    urlencode,
-    urljoin,
-    urlparse,
-    urlsplit,
-)
+from urllib.parse import urlparse, urlsplit
 from urllib.request import url2pathname
 
 if sys.version_info >= (3, 12):
@@ -80,7 +70,6 @@ if sys.version_info >= (3, 12):
 else:
     from typing_extensions import Unpack  # noqa
 
-
 import click
 import orjson
 import shapefile
@@ -224,14 +213,13 @@ class FloatRange(click.types.FloatParamType):
         ):
             if self.min is None:
                 self.fail(
-                    "%s is bigger than the maximum valid value " "%s." % (rv, self.max),
+                    "%s is bigger than the maximum valid value %s." % (rv, self.max),
                     param,
                     ctx,
                 )
             elif self.max is None:
                 self.fail(
-                    "%s is smaller than the minimum valid value "
-                    "%s." % (rv, self.min),
+                    "%s is smaller than the minimum valid value %s." % (rv, self.min),
                     param,
                     ctx,
                 )
@@ -387,27 +375,29 @@ def merge_mappings(mapping1: dict[Any, Any], mapping2: dict[Any, Any]) -> None:
             # `m1_keys_lowercase.get(key, key)`
             current_value = mapping1.get(m1_keys_lowercase.get(key, key))
             if current_value is not None:
-                current_value_type = type(current_value)
-                new_value_type = type(value)
                 try:
                     # If current or new value is a list (search queryable parameter), simply replace current with new
                     if (
-                        new_value_type == list
-                        and current_value_type != list
-                        or new_value_type != list
-                        and current_value_type == list
+                        isinstance(value, list)
+                        and not isinstance(current_value, list)
+                        or not isinstance(value, list)
+                        and isinstance(current_value, list)
                     ):
                         mapping1[m1_keys_lowercase.get(key, key)] = value
                     else:
                         mapping1[m1_keys_lowercase.get(key, key)] = cast_scalar_value(
-                            value, current_value_type
+                            value, type(current_value)
                         )
                 except (TypeError, ValueError):
                     # Ignore any override value that does not have the same type
                     # as the default value
                     logger.debug(
-                        f"Ignored '{key}' setting override from '{current_value}' to '{value}', "
-                        f"(could not cast {new_value_type} to {current_value_type})"
+                        "Ignored '%s' setting override from '%s' to '%s', (could not cast %s to %s)",
+                        key,
+                        current_value,
+                        value,
+                        type(value),
+                        type(current_value),
                     )
                     pass
             else:
@@ -1451,8 +1441,7 @@ def cast_scalar_value(value: Any, new_type: Any) -> Any:
         # case
         if value.capitalize() not in ("True", "False"):
             raise ValueError(
-                "Only true or false strings (case insensitive) are "
-                "allowed for booleans"
+                "Only true or false strings (case insensitive) are allowed for booleans"
             )
         # Get the real Python value of the boolean. e.g: value='tRuE'
         # => eval(value.capitalize())=True.
@@ -1505,6 +1494,7 @@ def guess_extension(type: str) -> Optional[str]:
     return mimetypes.guess_extension(type, strict=False)
 
 
+@functools.lru_cache(maxsize=2)
 def get_ssl_context(ssl_verify: bool) -> ssl.SSLContext:
     """
     Returns an SSL context based on ``ssl_verify`` argument.
@@ -1572,3 +1562,27 @@ def remove_str_array_quotes(input_str: str) -> str:
             continue
         output_str += input_str[i]
     return output_str
+
+
+def parse_le_uint32(data: bytes) -> int:
+    """
+    Parse little-endian unsigned 4-byte integer.
+
+    >>> parse_le_uint32(b'\\x01\\x00\\x00\\x00')
+    1
+    >>> parse_le_uint32(b'\\xff\\xff\\xff\\xff')
+    4294967295
+    """
+    return struct.unpack("<I", data)[0]
+
+
+def parse_le_uint16(data: bytes) -> int:
+    """
+    Parse little-endian unsigned 2-byte integer.
+
+    >>> parse_le_uint16(b'\\x01\\x00')
+    1
+    >>> parse_le_uint16(b'\\xff\\xff')
+    65535
+    """
+    return struct.unpack("<H", data)[0]

eodag/utils/exceptions.py

@@ -79,6 +79,10 @@ class STACOpenerError(EodagError):
     """An error indicating that a STAC file could not be opened"""
 
 
+class InvalidDataError(EodagError):
+    """Raised when data is invalid, malformed, or corrupt and cannot be processed as expected."""
+
+
 class RequestError(EodagError):
     """An error indicating that a request has failed. Usually eodag functions
     and methods should catch and skip this"""

eodag/utils/free_text_search.py

@@ -0,0 +1,229 @@
+# -*- coding: utf-8 -*-
+# Copyright 2025, CS GROUP - France, https://www.csgroup.eu/
+#
+# This file is part of EODAG project
+#     https://www.github.com/CS-SI/EODAG
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import re
+from typing import Callable
+
+from eodag.utils.exceptions import ValidationError
+
+
+def _tokenize(expr: str) -> list[str]:
+    """
+    Tokenizes a search expression into words, logical operators, and quoted phrases.
+
+    Handles:
+    - Logical operators: AND, OR, NOT
+    - Quoted phrases: "exact phrase"
+    - Wildcards: * and ? inside words
+    - Parentheses: (, )
+
+    :param expr: The search string (e.g., '("foo" OR bar) AND baz')
+    :return: A list of tokens (e.g., ['(', '"foo"', 'OR', 'BAR', ')', 'AND', 'BAZ'])
+
+    >>> _tokenize('("foo* bar?" OR baz) AND qux')
+    ['(', '"foo* bar?"', 'OR', 'BAZ', ')', 'AND', 'QUX']
+    """
+    # Match quoted phrases or unquoted tokens (including * and ?), or parentheses
+    pattern = r'"[^"]*"|AND|OR|NOT|\(|\)|[^\s()"]+'
+    raw_tokens = re.findall(pattern, expr)
+
+    tokens = []
+    for token in raw_tokens:
+        if token.startswith('"') and token.endswith('"'):
+            tokens.append(token)
+        elif token.upper() in {"AND", "OR", "NOT"}:
+            tokens.append(token.upper())
+        else:
+            tokens.append(token.upper())
+    return tokens
+
+
+def _to_postfix(tokens: list[str]) -> list[str]:
+    """
+    Converts infix tokens to postfix (Reverse Polish Notation) using the Shunting Yard algorithm.
+
+    :param tokens: List of tokens in infix order.
+    :return: List of tokens in postfix order.
+
+    :raises ValidationError: If parentheses are unbalanced.
+
+    >>> _to_postfix(['FOO', 'AND', '(', 'BAR', 'OR', 'BAZ', ')'])
+    ['FOO', 'BAR', 'BAZ', 'OR', 'AND']
+
+    >>> _to_postfix(['(', 'FOO', 'AND', 'BAR'])
+    Traceback (most recent call last):
+        ...
+    eodag.utils.exceptions.ValidationError: Mismatched parentheses in expression
+    """
+    precedence = {"NOT": 3, "AND": 2, "OR": 1}
+    output: list[str] = []
+    stack: list[str] = []
+
+    for token in tokens:
+        if token in precedence:
+            while (
+                stack
+                and stack[-1] != "("
+                and precedence.get(stack[-1], 0) >= precedence[token]
+            ):
+                output.append(stack.pop())
+            stack.append(token)
+        elif token == "(":
+            stack.append(token)
+        elif token == ")":
+            while stack and stack[-1] != "(":
+                output.append(stack.pop())
+            if not stack:
+                raise ValidationError("Mismatched parentheses in expression")
+            # Remove '('
+            stack.pop()
+        else:
+            output.append(token)
+
+    while stack:
+        if stack[-1] == "(":
+            raise ValidationError("Mismatched parentheses in expression")
+        output.append(stack.pop())
+
+    return output
+
+
+def _make_evaluator(postfix_expr: list[str]) -> Callable[[dict[str, str]], bool]:
+    """
+    Returns a function that evaluates a postfix expression on a dictionary of string fields.
+
+    Quoted phrases are matched exactly (case-insensitive).
+    Unquoted tokens are matched as case-insensitive full words (unless they contain wildcards).
+
+    :param postfix_expr: List of tokens in postfix order.
+    :return: A function that returns True if the dict matches.
+
+    >>> evaluator = _make_evaluator(['FOO', 'BAR', 'OR'])
+    >>> evaluator({'title': 'some foo text'})
+    True
+    >>> evaluator({'title': 'some bar text'})
+    True
+    >>> evaluator({'title': 'nothing'})
+    False
+    >>> evaluator2 = _make_evaluator(['"foo text"', 'NOT'])
+    >>> evaluator2({'title': 'some foo text'})
+    False
+    >>> evaluator2({'title': 'some bar'})
+    True
+    """
+
+    def evaluate(entry: dict[str, str]) -> bool:
+        stack: list[bool] = []
+        text = " ".join(str(v) for v in entry.values()).lower()
+
+        for token in postfix_expr:
+            if token == "AND":
+                b, a = stack.pop(), stack.pop()
+                stack.append(a and b)
+            elif token == "OR":
+                b, a = stack.pop(), stack.pop()
+                stack.append(a or b)
+            elif token == "NOT":
+                a = stack.pop()
+                stack.append(not a)
+            else:
+                if token.startswith('"') and token.endswith('"'):
+                    phrase = token[1:-1].lower()
+                    stack.append(phrase in text)
+                else:
+                    # Wildcard tokens → regex with .* and .
+                    if "*" in token or "?" in token:
+                        wildcard_pattern = (
+                            re.escape(token.lower())
+                            .replace(r"\*", ".*")
+                            .replace(r"\?", ".")
+                        )
+                        regex = re.compile(wildcard_pattern, flags=re.IGNORECASE)
+                    else:
+                        # Plain token → must match as a whole word
+                        regex = re.compile(
+                            rf"\b{re.escape(token.lower())}\b", flags=re.IGNORECASE
+                        )
+
+                    stack.append(bool(regex.search(text)))
+
+        return stack[0]
+
+    return evaluate
+
+
+def compile_free_text_query(query: str) -> Callable[[dict[str, str]], bool]:
+    """
+    Compiles a free-text logical search query into a dictionary evaluator function.
+
+    The evaluator checks whether the concatenated string values of a dictionary
+    (case-insensitive) satisfy the given logical expression.
+
+    Processing steps:
+        1. Tokenize the query into words, quoted phrases, wildcards, and operators.
+        2. Convert infix tokens into postfix notation using the Shunting Yard algorithm.
+        3. Build an evaluator function that applies the expression to dictionary fields.
+
+    Supported features:
+        - Logical operators: ``AND``, ``OR``, ``NOT``
+        - Grouping with parentheses: ``(``, ``)``
+        - Exact phrases in quotes: ``"foo bar"`` (case-insensitive substring match)
+        - Wildcards inside tokens:
+            - ``*`` → matches zero or more characters
+            - ``?`` → matches exactly one character
+        - Plain tokens without wildcards → matched as whole words (word boundary aware)
+        - Case-insensitive matching across all tokens and phrases
+
+    :param query: A logical search expression
+                  (e.g., ``'("foo bar" OR baz*) AND NOT qux'``).
+    :return: A function that takes a ``dict[str, str]`` and returns ``True`` if it matches.
+
+    :Example:
+
+    >>> evaluator = compile_free_text_query('("FooAndBar" OR BAR) AND "FOOBAR collection"')
+    >>> evaluator({
+    ...     "title": "titleFOOBAR - Lorem FOOBAR collection",
+    ...     "abstract": "abstract FOOBAR - This is FOOBAR. FooAndBar"
+    ... })
+    True
+    >>> evaluator({
+    ...     "title": "collection FOOBAR",
+    ...     "abstract": "abstract FOOBAR - This is FOOBAR. FooAndBar"
+    ... })
+    False
+    >>> evaluator({
+    ...     "title": "titleFOOBAR - Lorem FOOBAR ",
+    ...     "abstract": "abstract FOOBAR - This is FOOBAR."
+    ... })
+    False
+    >>> evaluator({"title": "Only Bar here"})
+    False
+
+    Wildcard example:
+
+    >>> evaluator = compile_free_text_query('foo*')
+    >>> evaluator({"title": "this is foobar"})
+    True
+    >>> evaluator({"title": "something with fooo"})
+    True
+    >>> evaluator({"title": "bar only"})
+    False
+    """
+
+    tokens = _tokenize(query)
+    postfix = _to_postfix(tokens)
+    return _make_evaluator(postfix)