eodag 3.10.0__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

eodag/config.py

@@ -64,8 +64,8 @@ from eodag.utils.exceptions import ValidationError
 
 logger = logging.getLogger("eodag.config")
 
-EXT_PRODUCT_TYPES_CONF_URI = (
-    "https://cs-si.github.io/eodag/eodag/resources/ext_product_types.json"
+EXT_COLLECTIONS_CONF_URI = (
+    "https://cs-si.github.io/eodag/eodag/resources/ext_collections.json"
 )
 AUTH_TOPIC_KEYS = ("auth", "search_auth", "download_auth")
 PLUGINS_TOPICS_KEYS = ("api", "search", "download") + AUTH_TOPIC_KEYS
@@ -114,7 +114,7 @@ class ProviderConfig(yaml.YAMLObject):
                      Lower value means lower priority. (Default: 0)
     :param api: (optional) The configuration of a plugin of type Api
     :param search: (optional) The configuration of a plugin of type Search
-    :param products: (optional) The products types supported by the provider
+    :param products: (optional) The collections supported by the provider
     :param download: (optional) The configuration of a plugin of type Download
     :param auth: (optional) The configuration of a plugin of type Authentication
     :param search_auth: (optional) The configuration of a plugin of type Authentication for search
@@ -135,7 +135,7 @@ class ProviderConfig(yaml.YAMLObject):
     auth: PluginConfig
     search_auth: PluginConfig
     download_auth: PluginConfig
-    product_types_fetched: bool  # set in core.update_product_types_list
+    collections_fetched: bool  # set in core.update_collections_list
 
     yaml_loader = yaml.Loader
     yaml_dumper = yaml.SafeDumper
@@ -274,17 +274,19 @@ class PluginConfig(yaml.YAMLObject):
         metadata_path: str
         #: list search parameters to send as is to the provider
         search_param_unparsed: list[str]
+        #: Use as STAC extension prefix if it does not have one already
+        metadata_prefix: str
         #: Whether an error must be raised when using a search parameter which is not queryable or not
         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
@@ -294,32 +296,32 @@ class PluginConfig(yaml.YAMLObject):
         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[JSONPath, str]
-        #: 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
@@ -431,8 +433,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
@@ -449,14 +451,14 @@ class PluginConfig(yaml.YAMLObject):
     sort: PluginConfig.Sort
     #: :class:`~eodag.plugins.search.base.Search` Configuration for the metadata auto-discovery
     discover_metadata: PluginConfig.DiscoverMetadata
-    #: :class:`~eodag.plugins.search.base.Search` Configuration for the product types auto-discovery
-    discover_product_types: PluginConfig.DiscoverProductTypes
+    #: :class:`~eodag.plugins.search.base.Search` Configuration for the collections auto-discovery
+    discover_collections: PluginConfig.DiscoverCollections
     #: :class:`~eodag.plugins.search.base.Search` Configuration for the queryables auto-discovery
     discover_queryables: PluginConfig.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]]
@@ -476,26 +478,19 @@ class PluginConfig(yaml.YAMLObject):
     per_product_metadata_query: bool
     #: :class:`~eodag.plugins.search.qssearch.ODataV4Search` Dict used to simplify further metadata extraction
     metadata_pre_mapping: PluginConfig.MetadataPreMapping
-    #: :class:`~eodag.plugins.search.data_request_search.DataRequestSearch` URL to which the data request shall be sent
-    data_request_url: str
-    #: :class:`~eodag.plugins.search.data_request_search.DataRequestSearch` URL to fetch the status of the data request
-    status_url: str
-    #: :class:`~eodag.plugins.search.data_request_search.DataRequestSearch`
-    #: URL to fetch the search result when the data request is done
-    result_url: str
-    #: :class:`~eodag.plugins.search.data_request_search.DataRequestSearch`
-    #: if date parameters are mandatory in the request
-    dates_required: bool
     #: :class:`~eodag.plugins.search.csw.CSWSearch` Search definition dictionary
     search_definition: dict[str, Any]
     #: :class:`~eodag.plugins.search.qssearch.PostJsonSearch` Whether to merge responses or not (`aws_eos` specific)
     merge_responses: bool
     #: :class:`~eodag.plugins.search.qssearch.PostJsonSearch` Collections names (`aws_eos` specific)
-    collection: list[str]
+    _collection: list[str]
     #: :class:`~eodag.plugins.search.static_stac_search.StaticStacSearch`
     #: Maximum number of connections for concurrent HTTP requests
     max_connections: int
     #: :class:`~eodag.plugins.search.build_search_result.ECMWFSearch`
+    #: if date parameters are mandatory in the request
+    dates_required: bool
+    #: :class:`~eodag.plugins.search.build_search_result.ECMWFSearch`
     #: Whether end date should be excluded from search request or not
     end_date_excluded: bool
     #: :class:`~eodag.plugins.search.build_search_result.ECMWFSearch`
@@ -521,9 +516,10 @@ class PluginConfig(yaml.YAMLObject):
     flatten_top_dirs: bool
     #: :class:`~eodag.plugins.download.base.Download` Level in extracted path tree where to find data
     archive_depth: int
-    #: :class:`~eodag.plugins.download.base.Download` Whether ignore assets and download using ``downloadLink`` or not
+    #: :class:`~eodag.plugins.download.base.Download` Whether ignore assets and download using ``eodag:download_link``
+    #: 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
@@ -542,7 +538,7 @@ class PluginConfig(yaml.YAMLObject):
     no_auth_download: bool
     #: :class:`~eodag.plugins.download.http.HTTPDownload` Parameters to be added to the query params of the request
     dl_url_params: dict[str, str]
-    #: :class:`~eodag.plugins.download.s3rest.S3RestDownload`
+    #: :class:`~eodag.plugins.download.aws.AwsDownload`
     #: At which level of the path part of the url the bucket can be found
     bucket_path_level: int
     #: :class:`~eodag.plugins.download.aws.AwsDownload` S3 endpoint
@@ -1069,15 +1065,15 @@ def load_stac_provider_config() -> dict[str, Any]:
     ).source
 
 
-def get_ext_product_types_conf(
-    conf_uri: str = EXT_PRODUCT_TYPES_CONF_URI,
+def get_ext_collections_conf(
+    conf_uri: str = EXT_COLLECTIONS_CONF_URI,
 ) -> dict[str, Any]:
-    """Read external product types conf
+    """Read external collections conf
 
     :param conf_uri: URI to local or remote configuration file
-    :returns: The external product types configuration
+    :returns: The external collections configuration
     """
-    logger.info("Fetching external product types from %s", conf_uri)
+    logger.info("Fetching external collections from %s", conf_uri)
     if conf_uri.lower().startswith("http"):
         # read from remote
         try:
@@ -1089,7 +1085,7 @@ def get_ext_product_types_conf(
         except requests.RequestException as e:
             logger.debug(e)
             logger.warning(
-                "Could not read remote external product types conf from %s", conf_uri
+                "Could not read remote external collections conf from %s", conf_uri
             )
             return {}
     elif conf_uri.lower().startswith("file"):
@@ -1102,6 +1098,6 @@ def get_ext_product_types_conf(
     except (orjson.JSONDecodeError, FileNotFoundError) as e:
         logger.debug(e)
         logger.warning(
-            "Could not read local external product types conf from %s", conf_uri
+            "Could not read local external collections conf from %s", conf_uri
         )
         return {}

eodag/plugins/apis/base.py

@@ -45,8 +45,8 @@ class Api(Search, Download):
       (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 ``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()``)
+      is built on the MD5 hash of the product's ``collection`` and ``properties['id']``
+      attributes (``hashlib.md5((product.collection+"-"+product.properties['id']).encode("utf-8")).hexdigest()``)
       and whose content is the product's ``remote_location`` attribute itself.
     - not try to download a product whose ``location`` attribute already points to an
       existing file/directory

eodag/plugins/apis/ecmwf.py

@@ -35,6 +35,7 @@ from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
     DEFAULT_DOWNLOAD_WAIT,
     DEFAULT_MISSION_START_DATE,
+    get_collection_dates,
     get_geometry_from_various,
     path_to_uri,
     sanitize,
@@ -52,7 +53,6 @@ if TYPE_CHECKING:
     from eodag.api.product import EOProduct
     from eodag.api.search_result import SearchResult
     from eodag.config import PluginConfig
-    from eodag.types import S3SessionKwargs
     from eodag.types.download_args import DownloadConf
     from eodag.utils import DownloadedCallback, ProgressCallback, Unpack
 
@@ -114,25 +114,24 @@ class EcmwfApi(Api, ECMWFSearch):
     ) -> tuple[list[EOProduct], Optional[int]]:
         """Build ready-to-download SearchResult"""
 
-        # check productType, dates, geometry, use defaults if not specified
-        # productType
-        if not kwargs.get("productType"):
-            kwargs["productType"] = "%s_%s_%s" % (
+        # check collection, dates, geometry, use defaults if not specified
+        # collection
+        if not kwargs.get("collection"):
+            kwargs["collection"] = "%s_%s_%s" % (
                 kwargs.get("ecmwf:dataset", "mars"),
                 kwargs.get("ecmwf:type", ""),
                 kwargs.get("ecmwf:levtype", ""),
             )
+
+        col_start, col_end = get_collection_dates(
+            getattr(self.config, "collection_config", {})
+        )
         # start date
-        if "startTimeFromAscendingNode" not in kwargs:
-            kwargs["startTimeFromAscendingNode"] = (
-                getattr(self.config, "product_type_config", {}).get("missionStartDate")
-                or DEFAULT_MISSION_START_DATE
-            )
+        if "start_datetime" not in kwargs:
+            kwargs["start_datetime"] = col_start or DEFAULT_MISSION_START_DATE
         # end date
-        if "completionTimeFromAscendingNode" not in kwargs:
-            kwargs["completionTimeFromAscendingNode"] = getattr(
-                self.config, "product_type_config", {}
-            ).get("missionEndDate") or datetime.now(timezone.utc).isoformat(
+        if "end_datetime" not in kwargs:
+            kwargs["end_datetime"] = col_end or datetime.now(timezone.utc).isoformat(
                 timespec="seconds"
             )
 
@@ -173,7 +172,7 @@ class EcmwfApi(Api, ECMWFSearch):
     def download(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, S3SessionKwargs, S3ServiceResource]] = None,
+        auth: Optional[Union[AuthBase, S3ServiceResource]] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,
         timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
@@ -205,7 +204,7 @@ class EcmwfApi(Api, ECMWFSearch):
             os.makedirs(new_fs_path)
         fs_path = os.path.join(new_fs_path, os.path.basename(fs_path))
 
-        # get download request dict from product.location/downloadLink url query string
+        # get download request dict from product.location/eodag:download_link url query string
         # separate url & parameters
         download_request = geojson.loads(urlsplit(product.location).query)
 
@@ -245,7 +244,7 @@ class EcmwfApi(Api, ECMWFSearch):
             raise DownloadError(e)
 
         with open(record_filename, "w") as fh:
-            fh.write(product.properties["downloadLink"])
+            fh.write(product.properties["eodag:download_link"])
         logger.debug("Download recorded in %s", record_filename)
 
         # do not try to extract a directory
@@ -262,7 +261,7 @@ class EcmwfApi(Api, ECMWFSearch):
     def download_all(
         self,
         products: SearchResult,
-        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
+        auth: Optional[Union[AuthBase, S3ServiceResource]] = None,
         downloaded_callback: Optional[DownloadedCallback] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,
@@ -291,9 +290,9 @@ class EcmwfApi(Api, ECMWFSearch):
     ) -> Optional[dict[str, Annotated[Any, FieldInfo]]]:
         """Fetch queryables list from provider using metadata mapping
 
-        :param kwargs: additional filters for queryables (`productType` and other search
+        :param kwargs: additional filters for queryables (`collection` and other search
                        arguments)
         :returns: fetched queryable parameters dict
         """
-        product_type = kwargs.get("productType")
-        return self.queryables_from_metadata_mapping(product_type)
+        collection = kwargs.get("collection")
+        return self.queryables_from_metadata_mapping(collection)

eodag/plugins/apis/usgs.py

@@ -31,7 +31,6 @@ from usgs import USGSAuthExpiredError, USGSError, api
 
 from eodag.api.product import EOProduct
 from eodag.api.product.metadata_mapping import (
-    DEFAULT_METADATA_MAPPING,
     mtd_cfg_as_conversion_and_querypath,
     properties_from_json,
 )
@@ -42,7 +41,7 @@ from eodag.utils import (
     DEFAULT_DOWNLOAD_WAIT,
     DEFAULT_ITEMS_PER_PAGE,
     DEFAULT_PAGE,
-    GENERIC_PRODUCT_TYPE,
+    GENERIC_COLLECTION,
     USER_AGENT,
     ProgressCallback,
     format_dict_items,
@@ -50,7 +49,7 @@ from eodag.utils import (
 )
 from eodag.utils.exceptions import (
     AuthenticationError,
-    NoMatchingProductType,
+    NoMatchingCollection,
     NotAvailableError,
     RequestError,
     ValidationError,
@@ -62,7 +61,6 @@ if TYPE_CHECKING:
 
     from eodag.api.search_result import SearchResult
     from eodag.config import PluginConfig
-    from eodag.types import S3SessionKwargs
     from eodag.types.download_args import DownloadConf
     from eodag.utils import DownloadedCallback, Unpack
 
@@ -101,7 +99,7 @@ class UsgsApi(Api):
         # Same method as in base.py, Search.__init__()
         # Prepare the metadata mapping
         # Do a shallow copy, the structure is flat enough for this to be sufficient
-        metas: dict[str, Any] = DEFAULT_METADATA_MAPPING.copy()
+        metas: dict[str, Any] = {}
         # Update the defaults with the mapping value. This will add any new key
         # added by the provider mapping that is not in the default metadata.
         metas.update(self.config.metadata_mapping)
@@ -148,23 +146,25 @@ class UsgsApi(Api):
             if prep.items_per_page is not None
             else DEFAULT_ITEMS_PER_PAGE
         )
-        product_type = kwargs.get("productType")
-        if product_type is None:
-            raise NoMatchingProductType(
-                "Cannot search on USGS without productType specified"
+        collection = kwargs.get("collection")
+        if collection is None:
+            raise NoMatchingCollection(
+                "Cannot search on USGS without collection specified"
             )
         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
+        collection_def_params = self.config.products.get(  # type: ignore
+            collection,
+            self.config.products[GENERIC_COLLECTION],  # type: ignore
         )
-        usgs_dataset = format_dict_items(product_type_def_params, **kwargs)["dataset"]
-        start_date = kwargs.pop("startTimeFromAscendingNode", None)
-        end_date = kwargs.pop("completionTimeFromAscendingNode", None)
+        usgs_collection = format_dict_items(collection_def_params, **kwargs)[
+            "_collection"
+        ]
+        start_date = kwargs.pop("start_datetime", None)
+        end_date = kwargs.pop("end_datetime", None)
         geom = kwargs.pop("geometry", None)
         footprint: dict[str, str] = {}
         if hasattr(geom, "bounds"):
@@ -201,14 +201,16 @@ class UsgsApi(Api):
 
             # search by id
             if searched_id := kwargs.get("id"):
-                dataset_filters = api.dataset_filters(usgs_dataset)
+                dataset_filters = api.dataset_filters(usgs_collection)
                 # 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}"
+                            "Try using %s dataset filter to search by id on %s",
+                            dataset_filter["searchSql"],
+                            usgs_collection,
                         )
                         full_api_search_kwargs = {
                             "where": {
@@ -218,19 +220,19 @@ class UsgsApi(Api):
                             **api_search_kwargs,
                         }
                         logger.info(
-                            f"Sending search request for {usgs_dataset} with {full_api_search_kwargs}"
+                            f"Sending search request for {usgs_collection} with {full_api_search_kwargs}"
                         )
                         results = api.scene_search(
-                            usgs_dataset, **full_api_search_kwargs
+                            usgs_collection, **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}"
+                    f"Sending search request for {usgs_collection} with {api_search_kwargs}"
                 )
-                results = api.scene_search(usgs_dataset, **api_search_kwargs)
+                results = api.scene_search(usgs_collection, **api_search_kwargs)
 
             # update results with storage info from download_options()
             results_by_entity_id = {
@@ -240,7 +242,7 @@ class UsgsApi(Api):
                 f"Adapting {len(results_by_entity_id)} plugin results to eodag product representation"
             )
             download_options = api.download_options(
-                usgs_dataset, list(results_by_entity_id.keys())
+                usgs_collection, list(results_by_entity_id.keys())
             )
             if download_options.get("data") is not None:
                 for download_option in download_options["data"]:
@@ -262,7 +264,7 @@ class UsgsApi(Api):
             results["data"]["results"] = list(results_by_entity_id.values())
 
             for result in results["data"]["results"]:
-                result["productType"] = usgs_dataset
+                result["collection"] = usgs_collection
 
                 product_properties = properties_from_json(
                     result, self.config.metadata_mapping
@@ -270,7 +272,7 @@ class UsgsApi(Api):
 
                 final.append(
                     EOProduct(
-                        productType=product_type,
+                        collection=collection,
                         provider=self.provider,
                         properties=product_properties,
                         geometry=footprint,
@@ -278,7 +280,7 @@ class UsgsApi(Api):
                 )
         except USGSError as e:
             logger.warning(
-                f"Product type {usgs_dataset} may not exist on USGS EE catalog"
+                f"Collection {usgs_collection} may not exist on USGS EE catalog"
             )
             api.logout()
             raise RequestError.from_error(e) from e
@@ -297,7 +299,7 @@ class UsgsApi(Api):
     def download(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, S3SessionKwargs, S3ServiceResource]] = None,
+        auth: Optional[Union[AuthBase, S3ServiceResource]] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,
         timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
@@ -314,7 +316,7 @@ class UsgsApi(Api):
         output_extension = cast(
             str,
             self.config.products.get(  # type: ignore
-                product.product_type, self.config.products[GENERIC_PRODUCT_TYPE]  # type: ignore
+                product.collection, self.config.products[GENERIC_COLLECTION]  # type: ignore
             ).get("output_extension", ".tar.gz"),
         )
         kwargs["output_extension"] = kwargs.get("output_extension", output_extension)
@@ -335,11 +337,13 @@ class UsgsApi(Api):
             raise NotAvailableError(
                 f"No USGS products found for {product.properties['id']}"
             )
-
+        usgs_dataset = self.config.products.get(product.collection, {}).get(
+            "_collection", GENERIC_COLLECTION
+        )
         download_request_results = api.download_request(
-            product.properties["productType"],
-            product.properties["entityId"],
-            product.properties["productId"],
+            usgs_dataset,
+            product.properties["usgs:entityId"],
+            product.properties["usgs:productId"],
         )
 
         req_urls: list[str] = []
@@ -422,7 +426,7 @@ class UsgsApi(Api):
         download_request(product, fs_path, progress_callback, **kwargs)
 
         with open(record_filename, "w") as fh:
-            fh.write(product.properties["downloadLink"])
+            fh.write(product.properties["eodag:download_link"])
         logger.debug(f"Download recorded in {record_filename}")
 
         api.logout()
@@ -466,7 +470,7 @@ class UsgsApi(Api):
     def download_all(
         self,
         products: SearchResult,
-        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
+        auth: Optional[Union[AuthBase, S3ServiceResource]] = None,
         downloaded_callback: Optional[DownloadedCallback] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,

eodag/plugins/authentication/base.py

@@ -27,8 +27,6 @@ if TYPE_CHECKING:
     from mypy_boto3_s3 import S3ServiceResource
     from requests.auth import AuthBase
 
-    from eodag.types import S3SessionKwargs
-
 
 class Authentication(PluginTopic):
     """Plugins authentication Base plugin
@@ -42,7 +40,7 @@ class Authentication(PluginTopic):
           configuration that needs authentication and helps identifying it
     """
 
-    def authenticate(self) -> Union[AuthBase, S3SessionKwargs, S3ServiceResource]:
+    def authenticate(self) -> Union[AuthBase, S3ServiceResource]:
         """Authenticate"""
         raise NotImplementedError
 

eodag/plugins/crunch/filter_date.py

@@ -49,7 +49,7 @@ class FilterDate(Crunch):
     @staticmethod
     def sort_product_by_start_date(product: EOProduct) -> dt:
         """Get product start date"""
-        start_date = product.properties.get("startTimeFromAscendingNode")
+        start_date = product.properties.get("start_datetime")
         if not start_date:
             # Retrieve year, month, day, hour, minute, second of EPOCH start
             epoch = time.gmtime(0)[:-3]
@@ -93,7 +93,7 @@ class FilterDate(Crunch):
         for product in products:
 
             # product start date
-            product_start_str = product.properties.get("startTimeFromAscendingNode")
+            product_start_str = product.properties.get("start_datetime")
             if product_start_str:
                 product_start = dateutil.parser.parse(product_start_str)
                 if not product_start.tzinfo:
@@ -102,7 +102,7 @@ class FilterDate(Crunch):
                 product_start = None
 
             # product end date
-            product_end_str = product.properties.get("completionTimeFromAscendingNode")
+            product_end_str = product.properties.get("end_datetime")
             if product_end_str:
                 product_end = dateutil.parser.parse(product_end_str)
                 if not product_end.tzinfo:

eodag/plugins/crunch/filter_latest_intersect.py

@@ -46,7 +46,7 @@ class FilterLatestIntersect(Crunch):
     @staticmethod
     def sort_product_by_start_date(product: EOProduct) -> dt:
         """Get product start date"""
-        start_date = product.properties.get("startTimeFromAscendingNode")
+        start_date = product.properties.get("start_datetime")
         if not start_date:
             # Retrieve year, month, day, hour, minute, second of EPOCH start
             epoch = time.gmtime(0)[:-3]
@@ -67,7 +67,7 @@ class FilterLatestIntersect(Crunch):
         logger.debug("Start filtering for latest products")
         if not products:
             return []
-        # Warning: May crash if startTimeFromAscendingNode is not in the appropriate format
+        # Warning: May crash if start_datetime is not in the appropriate format
         products.sort(key=self.sort_product_by_start_date, reverse=True)
         filtered: list[EOProduct] = []
         add_to_filtered = filtered.append

eodag/plugins/crunch/filter_latest_tpl_name.py

@@ -75,7 +75,7 @@ class FilterLatestByName(Crunch):
                     logger.debug(
                         "Latest product found for tileid=%s: date=%s",
                         tileid,
-                        product.properties["startTimeFromAscendingNode"],
+                        product.properties["start_datetime"],
                     )
                     filtered.append(product)
                     processed.append(tileid)