feat(providers): replace filter_by_name() by filter()

filter() takes a regex input and output a Provider iterator

Author: alambare

eodag/api/core.py

@@ -479,14 +479,14 @@ def list_product_types(
             self.fetch_product_types_list(provider=provider)
 
         product_types: list[dict[str, Any]] = []
-        providers = self.providers.filter_by_name(provider)
+        providers = list(self.providers.filter(f"^{provider}$" if provider else None))
 
         if provider and not providers:
             raise UnsupportedProvider(
                 f"The requested provider is not (yet) supported: {provider}"
             )
 
-        for p in providers.values():
+        for p in providers:
             for product_type_id in p.product_types:  # type: ignore
                 if product_type_id == GENERIC_PRODUCT_TYPE:
                     continue
@@ -515,13 +515,13 @@ def fetch_product_types_list(self, provider: Optional[str] = None) -> None:
         if strict_mode:
             return
 
-        providers_to_fetch = self.providers.filter_by_name(provider)
-
         # providers discovery confs that are fetchable
         providers_discovery_configs_fetchable: dict[str, DiscoverProductTypes] = {}
         # check if any provider has not already been fetched for product types
         already_fetched = True
-        for provider_to_fetch in providers_to_fetch.values():
+        for provider_to_fetch in self.providers.filter(
+            f"^{provider}$" if provider else None
+        ):
             if provider_to_fetch.fetchable and provider_to_fetch.search_config:
                 providers_discovery_configs_fetchable[
                     provider_to_fetch.name
@@ -639,7 +639,9 @@ def discover_product_types(
         :returns: external product types configuration
         """
 
-        providers_to_discover = self.providers.filter_by_name(provider)
+        providers_to_discover = list(
+            self.providers.filter(f"^{provider}$" if provider else None)
+        )
 
         if provider and not providers_to_discover:
             raise UnsupportedProvider(
@@ -649,7 +651,7 @@ def discover_product_types(
         ext_product_types_conf: dict[str, Any] = {}
 
         kwargs: dict[str, Any] = {}
-        for p in providers_to_discover.values():
+        for p in providers_to_discover:
             if not p.search_config:
                 return None
 

eodag/api/provider.py

@@ -19,6 +19,7 @@
 
 import logging
 import os
+import re
 import tempfile
 import traceback
 from collections import UserDict
@@ -426,7 +427,7 @@ def sync_product_types(
         Synchronize product types for a provider based on strict or permissive mode.
 
         In strict mode, removes product types not in product_types_config.
-        In permissive mode, adds empty product type configs for missing types.
+        In permissive mode, adds empty product type to config for missing types.
 
         :param product_types_config: The configuration of product_types.
         :param strict_mode: If True, remove unknown product types; if False, add empty configs for them.
@@ -636,19 +637,21 @@ def get_products(self, provider: str | Provider) -> Optional[dict[str, Any]]:
         provider_obj = self.data.get(name)
         return provider_obj.product_types if provider_obj else None
 
-    def filter_by_name(self, name: Optional[str] = None) -> ProvidersDict:
+    def filter(self, pattern: Optional[str] = None) -> Iterator[Provider]:
         """
-        Return a ProvidersDict filtered by provider name or group.
+        Yield providers whose name or group matches the regex pattern.
 
-        :param name: The name or group to filter by.
-        :return: The filtered ProvidersDict.
+        :param pattern: Regex pattern to filter provider name or group.
+        :return: Iterator of matching Provider objects.
         """
-        if not name:
-            return self
+        if not pattern:
+            yield from self.data.values()
+            return
 
-        return ProvidersDict(
-            {n: p for n, p in self.data.items() if name in [p.name, p.group]}
-        )
+        regex = re.compile(pattern)
+        for p in self.data.values():
+            if regex.search(p.name) or (p.group and regex.search(p.group)):
+                yield p
 
     def delete_product_type(self, provider: str, product_type: str) -> None:
         """