fix: changes due to rebase

renaming and fixing some configuration, code and tests

Author: anesson-cs

eodag/api/core.py

@@ -34,13 +34,13 @@
 import geojson
 import yaml
 
-from eodag.api.collection import Collection, CollectionsDict
+from eodag.api.collection import Collection, CollectionsDict, CollectionsList
 from eodag.api.product.metadata_mapping import mtd_cfg_as_conversion_and_querypath
 from eodag.api.provider import Provider, ProvidersDict
 from eodag.api.search_result import SearchResult
 from eodag.config import (
     PLUGINS_TOPICS_KEYS,
-    DiscoverProductTypes,
+    DiscoverCollections,
     PluginConfig,
     SimpleYamlProxyConfig,
     credentials_in_auth,
@@ -171,7 +171,7 @@ def __init__(
         strict_mode = is_env_var_true("EODAG_STRICT_COLLECTIONS")
 
         for provider in self.providers.values():
-            provider.sync_product_types(self, strict_mode)
+            provider.sync_collections(self, strict_mode)
 
         # re-build _plugins_manager using up-to-date providers_config
         self._plugins_manager.rebuild(self.providers)
@@ -504,7 +504,7 @@ def list_collections(
             )
 
         for p in providers_iter:
-            for collection_id in p.product_types:  # type: ignore
+            for collection_id in p.collections:  # type: ignore
                 if collection_id == GENERIC_COLLECTION:
                     continue
 
@@ -531,7 +531,7 @@ def fetch_collections_list(self, provider: Optional[str] = None) -> None:
             return
 
         # providers discovery confs that are fetchable
-        providers_discovery_configs_fetchable: dict[str, DiscoverProductTypes] = {}
+        providers_discovery_configs_fetchable: dict[str, DiscoverCollections] = {}
         # check if any provider has not already been fetched for collections
         already_fetched = True
         for provider_to_fetch in self.providers.filter_by_name_or_group(provider):
@@ -585,7 +585,7 @@ def fetch_collections_list(self, provider: Optional[str] = None) -> None:
                     default_discovery_conf["results_entry"], str
                 ):
                     default_discovery_conf_parsed = cast(
-                        DiscoverProductTypes,
+                        DiscoverCollections,
                         dict(
                             default_discovery_conf,
                             **{
@@ -689,7 +689,7 @@ def discover_collections(
                         kwargs["auth"] = auth
                     else:
                         logger.debug(
-                            f"Could not authenticate on {p} for product types discovery"
+                            f"Could not authenticate on {p} for collections discovery"
                         )
                         ext_collections_conf[p.name] = None
                         continue
@@ -716,7 +716,7 @@ def update_collections_list(
                         continue
 
                     provider_products_config = (
-                        self.providers[provider].product_types or {}
+                        self.providers[provider].collections or {}
                     )
                 except UnsupportedProvider:
                     logger.debug(
@@ -795,7 +795,8 @@ def update_collections_list(
                     )
                     if bad_formatted_col_count > 0:
                         logger.debug(
-                            f"bad formatted attributes skipped for {bad_formatted_col_count} collection(s) on {provider}"
+                            "bad formatted attributes skipped for "
+                            f"{bad_formatted_col_count} collection(s) on {provider}"
                         )
 
             elif provider not in self.providers:
@@ -824,7 +825,7 @@ def available_providers(
         candidates = []
 
         for key, provider in self.providers.items():
-            if collection and collection not in provider.product_types:
+            if collection and collection not in provider.collections:
                 continue
 
             group = getattr(provider.config, "group", None)

eodag/api/provider.py

@@ -51,17 +51,18 @@
     update_nested_dict,
 )
 from eodag.utils.exceptions import (
-    UnsupportedProductType,
+    UnsupportedCollection,
     UnsupportedProvider,
     ValidationError,
 )
 from eodag.utils.free_text_search import compile_free_text_query
 from eodag.utils.repr import html_table
 
 if TYPE_CHECKING:
-    from eodag.api.core import EODataAccessGateway
     from typing_extensions import Self
 
+    from eodag.api.core import EODataAccessGateway
+
 logger = logging.getLogger("eodag.provider")
 
 AUTH_TOPIC_KEYS = ("auth", "search_auth", "download_auth")
@@ -259,7 +260,7 @@ class Provider:
     >>> provider = Provider(config)
     >>> provider.name
     'example_provider'
-    >>> 'S2_MSI_L1C' in provider.product_types
+    >>> 'S2_MSI_L1C' in provider.collections
     True
     >>> provider.priority  # Default priority
     0
@@ -329,7 +330,7 @@ def _repr_html_(self, show_name: bool = True) -> str:
             {html_table(summaries)}
             <br />
             <br />
-            {html_table(list(self.product_types.keys()))}
+            {html_table(list(self.collections.keys()))}
         </div>
         """
 
@@ -354,8 +355,8 @@ def name(self) -> str:
         return self._name
 
     @property
-    def product_types(self) -> dict[str, Any]:
-        """Return the product types dictionary for this provider."""
+    def collections(self) -> dict[str, Any]:
+        """Return the collections dictionary for this provider."""
         return getattr(self.config, "products", {})
 
     @property
@@ -375,20 +376,20 @@ def search_config(self) -> Optional[PluginConfig]:
 
     @property
     def fetchable(self) -> bool:
-        """Return True if the provider can fetch product types."""
+        """Return True if the provider can fetch collections."""
         return bool(
-            getattr(self.search_config, "discover_product_types", {}).get("fetch_url")
+            getattr(self.search_config, "discover_collections", {}).get("fetch_url")
         )
 
     @property
     def unparsable_properties(self) -> set[str]:
-        """Return set of unparsable properties for generic product types, if any."""
+        """Return set of unparsable properties for generic collections, if any."""
         if not self.fetchable or self.search_config is None:
             return set()
 
         props = getattr(
-            getattr(self.search_config, "discover_product_types", None),
-            "generic_product_type_unparsable_properties",
+            getattr(self.search_config, "discover_collections", None),
+            "generic_collection_unparsable_properties",
             {},
         )
         return set(props.keys()) if isinstance(props, dict) else set()
@@ -434,37 +435,37 @@ def _copy_matching_credentials(
                             self.config, key
                         ).credentials = conf_with_creds.credentials
 
-    def delete_product_type(self, name: str) -> None:
-        """Remove a product type from this provider.
+    def delete_collection(self, name: str) -> None:
+        """Remove a collection from this provider.
 
-        :param name: The product type name.
+        :param name: The collection name.
 
-        :raises UnsupportedProductType: If the product type is not found.
+        :raises UnsupportedCollection: If the collection is not found.
         """
         try:
-            del self.product_types[name]
+            del self.collections[name]
         except KeyError:
-            msg = f"Product type '{name}' not found in provider '{self.name}'."
-            raise UnsupportedProductType(msg)
+            msg = f"Collection '{name}' not found in provider '{self.name}'."
+            raise UnsupportedCollection(msg)
 
-    def sync_product_types(
+    def sync_collections(
         self,
         dag: EODataAccessGateway,
         strict_mode: bool,
     ) -> None:
         """
-        Synchronize product types for a provider based on strict or permissive mode.
+        Synchronize collections for a provider based on strict or permissive mode.
 
         In strict mode, removes collections not in "dag.collections_config".
         In permissive mode, adds empty collection to config for missing types.
 
         :param dag: The gateway instance to use to list existing collections and to create new collection instances.
-        :param strict_mode: If True, remove unknown product types; if False, add empty configs for them.
+        :param strict_mode: If True, remove unknown collections; if False, add empty configs for them.
         """
         products_to_remove: list[str] = []
         products_to_add: list[str] = []
 
-        for product_id in self.product_types:
+        for product_id in self.collections:
             if product_id == GENERIC_COLLECTION:
                 continue
 
@@ -476,26 +477,24 @@ def sync_product_types(
                 empty_product = Collection(
                     dag=dag, id=product_id, title=product_id, description=NOT_AVAILABLE
                 )
-                dag.collections_config[
-                    product_id
-                ] = empty_product  # will update available_product_types
+                dag.collections_config[product_id] = empty_product
                 products_to_add.append(product_id)
 
         if products_to_add:
             logger.debug(
-                "Product types permissive mode, %s added (provider %s)",
+                "Collections permissive mode, %s added (provider %s)",
                 ", ".join(products_to_add),
                 self,
             )
 
         if products_to_remove:
             logger.debug(
-                "Product types strict mode, ignoring %s (provider %s)",
+                "Collections strict mode, ignoring %s (provider %s)",
                 ", ".join(products_to_remove),
                 self,
             )
             for id in products_to_remove:
-                self.delete_product_type(id)
+                self.delete_collection(id)
 
     def _mm_already_built(self) -> bool:
         """Check if metadata mapping is already built (converted to querypaths/conversion)."""
@@ -759,20 +758,20 @@ def filter_by_name_or_group(
             ):
                 yield provider
 
-    def delete_product_type(self, provider: str, product_type: str) -> None:
+    def delete_collection(self, provider: str, collection: str) -> None:
         """
-        Delete a product type from a provider.
+        Delete a collection from a provider.
 
         :param provider: The provider's name.
-        :param product_ID: The product type to delete.
+        :param product_ID: The collection to delete.
         :raises UnsupportedProvider: If the provider or product is not found.
         """
         if provider_obj := self.get(provider):
-            if product_type in provider_obj.product_types:
-                provider_obj.delete_product_type(product_type)
+            if collection in provider_obj.collections:
+                provider_obj.delete_collection(collection)
             else:
-                msg = f"Product type '{product_type}' not found for provider '{provider}'."
-                raise UnsupportedProductType(msg)
+                msg = f"Collection '{collection}' not found for provider '{provider}'."
+                raise UnsupportedCollection(msg)
         else:
             msg = f"Provider '{provider}' not found."
             raise UnsupportedProvider(msg)

eodag/config.py

@@ -151,14 +151,14 @@ class DiscoverMetadata(TypedDict):
     raise_mtd_discovery_error: bool
 
 
-class DiscoverProductTypes(TypedDict, total=False):
-    """Configuration for product types discovery"""
+class DiscoverCollections(TypedDict, total=False):
+    """Configuration for collections discovery"""
 
-    #: URL from which the product types can be fetched
+    #: URL from which the collections can be fetched
     fetch_url: Optional[str]
-    #: HTTP method used to fetch product types
+    #: HTTP method used to fetch collections
     fetch_method: str
-    #: Request body to fetch product types using POST method
+    #: Request body to fetch collections using POST method
     fetch_body: dict[str, Any]
     #: Maximum number of connections for concurrent HTTP requests
     max_connections: int
@@ -168,33 +168,33 @@ class DiscoverProductTypes(TypedDict, total=False):
     start_page: int
     #: Type of the provider result
     result_type: str
-    #: JsonPath to the list of product types
+    #: JsonPath to the list of collections
     results_entry: Union[str, JSONPath]
-    #: Mapping for the product type id
-    generic_product_type_id: str
-    #: Mapping for product type metadata (e.g. ``abstract``, ``licence``) which can be parsed from the provider
+    #: Mapping for the collection id
+    generic_collection_id: str
+    #: Mapping for collection metadata (e.g. ``abstract``, ``licence``) which can be parsed from the provider
     #: result
-    generic_product_type_parsable_metadata: dict[str, str]
-    #: Mapping for product type properties which can be parsed from the result and are not product type metadata
-    generic_product_type_parsable_properties: dict[str, str]
-    #: Mapping for product type properties which cannot be parsed from the result and are not product type metadata
-    generic_product_type_unparsable_properties: dict[str, str]
+    generic_collection_parsable_metadata: dict[str, str]
+    #: Mapping for collection properties which can be parsed from the result and are not collection metadata
+    generic_collection_parsable_properties: dict[str, str]
+    #: Mapping for collection properties which cannot be parsed from the result and are not collection metadata
+    generic_collection_unparsable_properties: dict[str, str]
     #: URL to fetch data for a single collection
     single_collection_fetch_url: str
     #: Query string to be added to the fetch_url to filter for a collection
     single_collection_fetch_qs: str
-    #: Mapping for product type metadata returned by the endpoint given in single_collection_fetch_url. If ``ID``
-    #: is redefined in this mapping, it will replace ``generic_product_type_id`` value
-    single_product_type_parsable_metadata: dict[str, str]
+    #: Mapping for collection metadata returned by the endpoint given in single_collection_fetch_url. If ``ID``
+    #: is redefined in this mapping, it will replace ``generic_collection_id`` value
+    single_collection_parsable_metadata: dict[str, str]
 
 
 class DiscoverQueryables(TypedDict, total=False):
     """Configuration for queryables discovery"""
 
-    #: URL to fetch the queryables valid for all product types
+    #: URL to fetch the queryables valid for all collections
     fetch_url: Optional[str]
-    #: URL to fetch the queryables for a specific product type
-    product_type_fetch_url: Optional[str]
+    #: URL to fetch the queryables for a specific collection
+    collection_fetch_url: Optional[str]
     #: Type of the result
     result_type: str
     #: JsonPath to retrieve the queryables from the provider result
@@ -320,8 +320,8 @@ class PluginConfig(yaml.YAMLObject):
     # search & api -----------------------------------------------------------------------------------------------------
     # copied from ProviderConfig in PluginManager.get_search_plugins()
     priority: int
-    # per product type metadata-mapping, set in core._prepare_search
-    product_type_config: dict[str, Any]
+    # per collection metadata-mapping, set in core._prepare_search
+    collection_config: dict[str, Any]
 
     #: :class:`~eodag.plugins.search.base.Search` Plugin API endpoint
     api_endpoint: str
@@ -338,14 +338,14 @@ class PluginConfig(yaml.YAMLObject):
     sort: Sort
     #: :class:`~eodag.plugins.search.base.Search` Configuration for the metadata auto-discovery
     discover_metadata: DiscoverMetadata
-    #: :class:`~eodag.plugins.search.base.Search` Configuration for the product types auto-discovery
-    discover_product_types: DiscoverProductTypes
+    #: :class:`~eodag.plugins.search.base.Search` Configuration for the collections auto-discovery
+    discover_collections: DiscoverCollections
     #: :class:`~eodag.plugins.search.base.Search` Configuration for the queryables auto-discovery
     discover_queryables: DiscoverQueryables
     #: :class:`~eodag.plugins.search.base.Search` The mapping between eodag metadata and the plugin specific metadata
     metadata_mapping: dict[str, Union[str, list[str]]]
     #: :class:`~eodag.plugins.search.base.Search` :attr:`~eodag.config.PluginConfig.metadata_mapping` got from the given
-    #: product type
+    #: collection
     metadata_mapping_from_product: str
     #: :class:`~eodag.plugins.search.base.Search` A mapping for the metadata of individual assets
     assets_mapping: dict[str, dict[str, Any]]
@@ -412,7 +412,7 @@ class PluginConfig(yaml.YAMLObject):
     archive_depth: int
     #: :class:`~eodag.plugins.download.base.Download` Whether ignore assets and download using ``downloadLink`` or not
     ignore_assets: bool
-    #: :class:`~eodag.plugins.download.base.Download` Product type specific configuration
+    #: :class:`~eodag.plugins.download.base.Download` Collection specific configuration
     products: dict[str, dict[str, Any]]
     #: :class:`~eodag.plugins.download.http.HTTPDownload` Whether the product has to be ordered to download it or not
     order_enabled: bool

eodag/plugins/manager.py

@@ -132,15 +132,15 @@ def build_collection_to_provider_config_map(self) -> None:
         """Build mapping conf between collections and providers"""
         self.collection_to_provider_config_map = {}
         for provider in list(self.providers.values()):
-            if not provider.product_types:
+            if not provider.collections:
                 logger.info(
                     "%s: provider has no product configured and will be skipped",
                     provider,
                 )
                 del self.providers[provider.name]
                 continue
 
-            for collection in provider.product_types:
+            for collection in provider.collections:
                 collection_providers = (
                     self.collection_to_provider_config_map.setdefault(  # noqa
                         collection, []