eodag 3.1.0b2__py3-none-any.whl → 3.2.1__py3-none-any.whl

eodag/api/core.py

@@ -23,13 +23,13 @@ import os
 import re
 import shutil
 import tempfile
+from importlib.metadata import version
+from importlib.resources import files as res_files
 from operator import itemgetter
 from typing import TYPE_CHECKING, Any, Iterator, Optional, Union
 
 import geojson
-import pkg_resources
 import yaml.parser
-from pkg_resources import resource_filename
 from whoosh import analysis, fields
 from whoosh.fields import Schema
 from whoosh.index import exists_in, open_dir
@@ -119,8 +119,8 @@ class EODataAccessGateway:
         user_conf_file_path: Optional[str] = None,
         locations_conf_path: Optional[str] = None,
     ) -> None:
-        product_types_config_path = resource_filename(
-            "eodag", os.path.join("resources/", "product_types.yml")
+        product_types_config_path = os.getenv("EODAG_PRODUCT_TYPES_CFG_FILE") or str(
+            res_files("eodag") / "resources" / "product_types.yml"
         )
         self.product_types_config = SimpleYamlProxyConfig(product_types_config_path)
         self.product_types_config_md5 = obj_md5sum(self.product_types_config.source)
@@ -161,8 +161,8 @@ class EODataAccessGateway:
                 user_conf_file_path = standard_configuration_path
                 if not os.path.isfile(standard_configuration_path):
                     shutil.copy(
-                        resource_filename(
-                            "eodag", os.path.join("resources", "user_conf_template.yml")
+                        str(
+                            res_files("eodag") / "resources" / "user_conf_template.yml"
                         ),
                         standard_configuration_path,
                     )
@@ -203,9 +203,8 @@ class EODataAccessGateway:
                 locations_conf_path = os.path.join(self.conf_dir, "locations.yml")
                 if not os.path.isfile(locations_conf_path):
                     # copy locations conf file and replace path example
-                    locations_conf_template = resource_filename(
-                        "eodag",
-                        os.path.join("resources", "locations_conf_template.yml"),
+                    locations_conf_template = str(
+                        res_files("eodag") / "resources" / "locations_conf_template.yml"
                     )
                     with (
                         open(locations_conf_template) as infile,
@@ -222,14 +221,14 @@ class EODataAccessGateway:
                             outfile.write(line)
                     # copy sample shapefile dir
                     shutil.copytree(
-                        resource_filename("eodag", os.path.join("resources", "shp")),
+                        str(res_files("eodag") / "resources" / "shp"),
                         os.path.join(self.conf_dir, "shp"),
                     )
         self.set_locations_conf(locations_conf_path)
 
     def get_version(self) -> str:
         """Get eodag package version"""
-        return pkg_resources.get_distribution("eodag").version
+        return version("eodag")
 
     def build_index(self) -> None:
         """Build a `Whoosh <https://whoosh.readthedocs.io/en/latest/index.html>`_

eodag/api/product/_assets.py

@@ -31,12 +31,27 @@ if TYPE_CHECKING:
 
 
 class AssetsDict(UserDict):
-    """A UserDict object listing assets contained in a
-    :class:`~eodag.api.product._product.EOProduct` resulting from a search.
+    """A UserDict object which values are :class:`~eodag.api.product._assets.Asset`
+    contained in a :class:`~eodag.api.product._product.EOProduct` resulting from a
+    search.
 
     :param product: Product resulting from a search
     :param args: (optional) Arguments used to init the dictionary
     :param kwargs: (optional) Additional named-arguments used to init the dictionary
+
+    Example
+    -------
+
+    >>> from eodag.api.product import EOProduct
+    >>> product = EOProduct(
+    ...     provider="foo",
+    ...     properties={"id": "bar", "geometry": "POINT (0 0)"}
+    ... )
+    >>> type(product.assets)
+    <class 'eodag.api.product._assets.AssetsDict'>
+    >>> product.assets.update({"foo": {"href": "http://somewhere/something"}})
+    >>> product.assets
+    {'foo': {'href': 'http://somewhere/something'}}
     """
 
     product: EOProduct
@@ -56,22 +71,29 @@ class AssetsDict(UserDict):
         """
         return {k: v.as_dict() for k, v in self.data.items()}
 
-    def get_values(self, asset_filter: str = "") -> list[Asset]:
+    def get_values(self, asset_filter: str = "", regex=True) -> list[Asset]:
         """
         retrieves the assets matching the given filter
 
         :param asset_filter: regex filter with which the assets should be matched
+        :param regex: Uses regex to match the asset key or simply compare strings
         :return: list of assets
         """
         if asset_filter:
-            filter_regex = re.compile(asset_filter)
-            assets_keys = list(self.keys())
-            assets_keys = list(filter(filter_regex.fullmatch, assets_keys))
+            if regex:
+                filter_regex = re.compile(asset_filter)
+                assets_keys = list(self.keys())
+                assets_keys = list(filter(filter_regex.fullmatch, assets_keys))
+            else:
+                assets_keys = [a for a in self.keys() if a == asset_filter]
             filtered_assets = {}
             if len(assets_keys) > 0:
                 filtered_assets = {a_key: self.get(a_key) for a_key in assets_keys}
             assets_values = [a for a in filtered_assets.values() if a and "href" in a]
-            if not assets_values:
+            if not assets_values and regex:
+                # retry without regex
+                return self.get_values(asset_filter, regex=False)
+            elif not assets_values:
                 raise NotAvailableError(
                     rf"No asset key matching re.fullmatch(r'{asset_filter}') was found in {self.product}"
                 )
@@ -119,13 +141,27 @@ class AssetsDict(UserDict):
 
 
 class Asset(UserDict):
-    """A UserDict object containg one of the assets of a
-    :class:`~eodag.api.product._product.EOProduct` resulting from a search.
+    """A UserDict object containg one of the
+    :attr:`~eodag.api.product._product.EOProduct.assets` resulting from a search.
 
     :param product: Product resulting from a search
     :param key: asset key
     :param args: (optional) Arguments used to init the dictionary
     :param kwargs: (optional) Additional named-arguments used to init the dictionary
+
+    Example
+    -------
+
+    >>> from eodag.api.product import EOProduct
+    >>> product = EOProduct(
+    ...     provider="foo",
+    ...     properties={"id": "bar", "geometry": "POINT (0 0)"}
+    ... )
+    >>> product.assets.update({"foo": {"href": "http://somewhere/something"}})
+    >>> type(product.assets["foo"])
+    <class 'eodag.api.product._assets.Asset'>
+    >>> product.assets["foo"]
+    {'href': 'http://somewhere/something'}
     """
 
     product: EOProduct

eodag/api/product/_product.py

@@ -89,20 +89,6 @@ class EOProduct:
 
     :param provider: The provider from which the product originates
     :param properties: The metadata of the product
-    :ivar product_type: The product type
-    :vartype product_type: str
-    :ivar location: The path to the product, either remote or local if downloaded
-    :vartype location: str
-    :ivar remote_location: The remote path to the product
-    :vartype remote_location: str
-    :ivar search_kwargs: The search kwargs used by eodag to search for the product
-    :vartype search_kwargs: Any
-    :ivar geometry: The geometry of the product
-    :vartype geometry: :class:`shapely.geometry.base.BaseGeometry`
-    :ivar search_intersection: The intersection between the product's geometry
-                               and the search area.
-    :vartype search_intersection: :class:`shapely.geometry.base.BaseGeometry` or None
-
 
     .. note::
         The geojson spec `enforces <https://github.com/geojson/draft-geojson/pull/6>`_
@@ -112,18 +98,28 @@ class EOProduct:
         mentioned CRS.
     """
 
+    #: The provider from which the product originates
     provider: str
+    #: The metadata of the product
     properties: dict[str, Any]
+    #: The product type
     product_type: Optional[str]
-    location: str
-    filename: str
-    remote_location: str
-    search_kwargs: Any
+    #: The geometry of the product
     geometry: BaseGeometry
+    #: The intersection between the product's geometry and the search area.
     search_intersection: Optional[BaseGeometry]
+    #: The path to the product, either remote or local if downloaded
+    location: str
+    #: The remote path to the product
+    remote_location: str
+    #: Assets of the product
     assets: AssetsDict
     #: Driver enables additional methods to be called on the EOProduct
     driver: DatasetDriver
+    #: Product data filename, stored during download
+    filename: str
+    #: Product search keyword arguments, stored during search
+    search_kwargs: Any
 
     def __init__(
         self, provider: str, properties: dict[str, Any], **kwargs: Any

eodag/api/product/metadata_mapping.py

@@ -49,6 +49,7 @@ from eodag.utils import (
     get_timestamp,
     items_recursive_apply,
     nested_pairs2dict,
+    sanitize,
     string_to_jsonpath,
     update_nested_dict,
 )
@@ -176,6 +177,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         - ``split_corine_id``: get the product type by splitting the product id
         - ``to_datetime_dict``: convert a datetime string to a dictionary where values are either a string or a list
         - ``get_ecmwf_time``: get the time of a datetime string in the ECMWF format
+        - ``sanitize``: sanitize string
 
     :param search_param: The string to be formatted
     :param args: (optional) Additional arguments to use in the formatting process
@@ -367,8 +369,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             )
 
         @staticmethod
-        def convert_to_geojson(string: str) -> str:
-            return geojson.dumps(string)
+        def convert_to_geojson(value: Any) -> str:
+            return geojson.dumps(value)
 
         @staticmethod
         def convert_from_ewkt(ewkt_string: str) -> Union[BaseGeometry, str]:
@@ -496,9 +498,16 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return NOT_AVAILABLE
 
         @staticmethod
-        def convert_replace_str(string: str, args: str) -> str:
+        def convert_replace_str(value: Any, args: str) -> str:
+            if isinstance(value, dict):
+                value = MetadataFormatter.convert_to_geojson(value)
+            elif not isinstance(value, str):
+                raise TypeError(
+                    f"convert_replace_str expects a string or a dict (apply to_geojson). Got {type(value)}"
+                )
+
             old, new = ast.literal_eval(args)
-            return re.sub(old, new, string)
+            return re.sub(old, new, value)
 
         @staticmethod
         def convert_recursive_sub_str(
@@ -816,6 +825,11 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 + ":00"
             ]
 
+        @staticmethod
+        def convert_sanitize(text: str) -> str:
+            """Sanitize string"""
+            return sanitize(text)
+
         @staticmethod
         def convert_get_dates_from_string(text: str, split_param="-"):
             reg = "[0-9]{8}" + split_param + "[0-9]{8}"
@@ -1487,7 +1501,11 @@ def get_queryable_from_provider(
         ind = mapping_values.index(provider_queryable)
         return Queryables.get_queryable_from_alias(list(metadata_mapping.keys())[ind])
     for param, param_conf in metadata_mapping.items():
-        if isinstance(param_conf, list) and re.search(pattern, param_conf[0]):
+        if (
+            isinstance(param_conf, list)
+            and param_conf[0]
+            and re.search(pattern, param_conf[0])
+        ):
             return Queryables.get_queryable_from_alias(param)
     return None
 

eodag/config.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import logging
 import os
 import tempfile
+from importlib.resources import files as res_files
 from inspect import isclass
 from typing import (
     Annotated,
@@ -41,7 +42,6 @@ import yaml.constructor
 import yaml.parser
 from annotated_types import Gt
 from jsonpath_ng import JSONPath
-from pkg_resources import resource_filename
 
 from eodag.api.product.metadata_mapping import mtd_cfg_as_conversion_and_querypath
 from eodag.utils import (
@@ -443,6 +443,9 @@ class PluginConfig(yaml.YAMLObject):
     literal_search_params: dict[str, str]
     #: :class:`~eodag.plugins.search.qssearch.QueryStringSearch` Characters that should not be quoted in the url params
     dont_quote: list[str]
+    #: :class:`~eodag.plugins.search.qssearch.QueryStringSearch` Guess assets keys using their ``href``.
+    #: Use their original key if ``False``
+    asset_key_from_href: bool
     #: :class:`~eodag.plugins.search.qssearch.ODataV4Search` Dict describing free text search request build
     free_text_search_operations: dict[str, Any]
     #: :class:`~eodag.plugins.search.qssearch.ODataV4Search` Set to ``True`` if the metadata is not given in the search
@@ -671,9 +674,9 @@ def load_default_config() -> dict[str, ProviderConfig]:
 
     :returns: The default provider's configuration
     """
-    eodag_providers_cfg_file = os.getenv(
-        "EODAG_PROVIDERS_CFG_FILE"
-    ) or resource_filename("eodag", "resources/providers.yml")
+    eodag_providers_cfg_file = os.getenv("EODAG_PROVIDERS_CFG_FILE") or str(
+        res_files("eodag") / "resources" / "providers.yml"
+    )
     return load_config(eodag_providers_cfg_file)
 
 
@@ -779,6 +782,7 @@ def provider_config_init(
             and provider_config.search.type
             in [
                 "StacSearch",
+                "StacListAssets",
                 "StaticStacSearch",
             ]
         ):
@@ -987,9 +991,7 @@ def load_stac_config() -> dict[str, Any]:
 
     :returns: The stac configuration
     """
-    return load_yml_config(
-        resource_filename("eodag", os.path.join("resources/", "stac.yml"))
-    )
+    return load_yml_config(str(res_files("eodag") / "resources" / "stac.yml"))
 
 
 def load_stac_api_config() -> dict[str, Any]:
@@ -997,9 +999,7 @@ def load_stac_api_config() -> dict[str, Any]:
 
     :returns: The stac API configuration
     """
-    return load_yml_config(
-        resource_filename("eodag", os.path.join("resources/", "stac_api.yml"))
-    )
+    return load_yml_config(str(res_files("eodag") / "resources" / "stac_api.yml"))
 
 
 def load_stac_provider_config() -> dict[str, Any]:
@@ -1008,7 +1008,7 @@ def load_stac_provider_config() -> dict[str, Any]:
     :returns: The stac provider configuration
     """
     return SimpleYamlProxyConfig(
-        resource_filename("eodag", os.path.join("resources/", "stac_provider.yml"))
+        str(res_files("eodag") / "resources" / "stac_provider.yml")
     ).source
 
 

eodag/plugins/apis/ecmwf.py

@@ -30,11 +30,7 @@ from pydantic.fields import FieldInfo
 from eodag.plugins.apis.base import Api
 from eodag.plugins.search import PreparedSearch
 from eodag.plugins.search.base import Search
-from eodag.plugins.search.build_search_result import (
-    ECMWF_KEYWORDS,
-    ECMWFSearch,
-    keywords_to_mdt,
-)
+from eodag.plugins.search.build_search_result import ECMWFSearch, ecmwf_mtd
 from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
     DEFAULT_DOWNLOAD_WAIT,
@@ -94,7 +90,7 @@ class EcmwfApi(Api, ECMWFSearch):
     def __init__(self, provider: str, config: PluginConfig) -> None:
         # init self.config.metadata_mapping using Search Base plugin
         config.metadata_mapping = {
-            **keywords_to_mdt(ECMWF_KEYWORDS, "ecmwf"),
+            **ecmwf_mtd(),
             **config.metadata_mapping,
         }
         Search.__init__(self, provider, config)

eodag/plugins/apis/usgs.py

@@ -128,7 +128,7 @@ class UsgsApi(Api):
                 api.logout()
                 continue
             except USGSError as e:
-                if i == 0:
+                if i == 0 and os.path.isfile(api.TMPFILE):
                     # `.usgs` API file key might be obsolete
                     # Remove it and try again
                     os.remove(api.TMPFILE)

eodag/plugins/authentication/openid_connect.py

@@ -379,6 +379,12 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
 
         login_document = etree.HTML(authorization_response.text)
         login_forms = login_document.xpath(self.config.login_form_xpath)
+
+        if not login_forms:
+            # we assume user is already logged in
+            # no form found because we got redirected to the redirect_uri
+            return authorization_response
+
         login_form = login_forms[0]
 
         # Get the form data to pass to the login form from config or from the login form

eodag/plugins/download/aws.py

@@ -60,6 +60,7 @@ from eodag.utils.exceptions import (
     NotAvailableError,
     TimeOutError,
 )
+from eodag.utils.s3 import open_s3_zipped_object
 
 if TYPE_CHECKING:
     from boto3.resources.collection import ResourceCollection
@@ -195,6 +196,7 @@ AWS_AUTH_ERROR_MESSAGES = [
     "AccessDenied",
     "InvalidAccessKeyId",
     "SignatureDoesNotMatch",
+    "InvalidRequest",
 ]
 
 
@@ -232,6 +234,7 @@ class AwsDownload(Download):
         super(AwsDownload, self).__init__(provider, config)
         self.requester_pays = getattr(self.config, "requester_pays", False)
         self.s3_session: Optional[boto3.session.Session] = None
+        self.s3_resource: Optional[boto3.resources.base.ServiceResource] = None
 
     def download(
         self,
@@ -289,10 +292,10 @@ class AwsDownload(Download):
         asset_filter = kwargs.get("asset", None)
         if asset_filter:
             build_safe = False
+            ignore_assets = False
         else:
             build_safe = product_conf.get("build_safe", False)
-
-        ignore_assets = getattr(self.config, "ignore_assets", False)
+            ignore_assets = getattr(self.config, "ignore_assets", False)
 
         # product conf overrides provider conf for "flatten_top_dirs"
         flatten_top_dirs = product_conf.get(
@@ -325,19 +328,32 @@ class AwsDownload(Download):
             bucket_names_and_prefixes, auth
         )
 
+        # files in zip
+        updated_bucket_names_and_prefixes = self._download_file_in_zip(
+            product, bucket_names_and_prefixes, product_local_path, progress_callback
+        )
+        # prevent nothing-to-download errors if download was performed in zip
+        raise_error = (
+            False
+            if len(updated_bucket_names_and_prefixes) != len(bucket_names_and_prefixes)
+            else True
+        )
+
         # downloadable files
         unique_product_chunks = self._get_unique_products(
-            bucket_names_and_prefixes,
+            updated_bucket_names_and_prefixes,
             authenticated_objects,
             asset_filter,
             ignore_assets,
             product,
+            raise_error=raise_error,
         )
 
         total_size = sum([p.size for p in unique_product_chunks]) or None
 
         # download
-        progress_callback.reset(total=total_size)
+        if len(unique_product_chunks) > 0:
+            progress_callback.reset(total=total_size)
         try:
             for product_chunk in unique_product_chunks:
                 try:
@@ -389,6 +405,52 @@ class AwsDownload(Download):
 
         return product_local_path
 
+    def _download_file_in_zip(
+        self, product, bucket_names_and_prefixes, product_local_path, progress_callback
+    ):
+        """
+        Download file in zip from a prefix like `foo/bar.zip!file.txt`
+        """
+        if self.s3_resource is None:
+            logger.debug("Cannot check files in s3 zip without s3 resource")
+            return bucket_names_and_prefixes
+
+        s3_client = self.s3_resource.meta.client
+
+        downloaded = []
+        for i, pack in enumerate(bucket_names_and_prefixes):
+            bucket_name, prefix = pack
+            if ".zip!" in prefix:
+                splitted_path = prefix.split(".zip!")
+                zip_prefix = f"{splitted_path[0]}.zip"
+                rel_path = splitted_path[-1]
+                dest_file = os.path.join(product_local_path, rel_path)
+                dest_abs_path_dir = os.path.dirname(dest_file)
+                if not os.path.isdir(dest_abs_path_dir):
+                    os.makedirs(dest_abs_path_dir)
+
+                with open_s3_zipped_object(
+                    bucket_name, zip_prefix, s3_client, partial=False
+                ) as zip_file:
+                    # file size
+                    file_info = zip_file.getinfo(rel_path)
+                    progress_callback.reset(total=file_info.file_size)
+                    with zip_file.open(rel_path) as extracted, open(
+                        dest_file, "wb"
+                    ) as output_file:
+                        # Read in 1MB chunks
+                        for zchunk in iter(lambda: extracted.read(1024 * 1024), b""):
+                            output_file.write(zchunk)
+                            progress_callback(len(zchunk))
+
+                downloaded.append(i)
+
+        return [
+            pack
+            for i, pack in enumerate(bucket_names_and_prefixes)
+            if i not in downloaded
+        ]
+
     def _download_preparation(
         self,
         product: EOProduct,
@@ -396,10 +458,12 @@ class AwsDownload(Download):
         **kwargs: Unpack[DownloadConf],
     ) -> tuple[Optional[str], Optional[str]]:
         """
-        preparation for the download:
+        Preparation for the download:
+
         - check if file was already downloaded
         - get file path
         - create directories
+
         :param product: product to be downloaded
         :param progress_callback: progress callback to be used
         :param kwargs: additional arguments
@@ -423,7 +487,8 @@ class AwsDownload(Download):
 
     def _configure_safe_build(self, build_safe: bool, product: EOProduct):
         """
-        updates the product properties with fetch metadata if safe build is enabled
+        Updates the product properties with fetch metadata if safe build is enabled
+
         :param build_safe: if safe build is enabled
         :param product: product to be updated
         """
@@ -513,10 +578,11 @@ class AwsDownload(Download):
         auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
     ) -> tuple[dict[str, Any], ResourceCollection]:
         """
-        authenticates with s3 and retrieves the available objects
-        raises an error when authentication is not possible
+        Authenticates with s3 and retrieves the available objects
+
         :param bucket_names_and_prefixes: list of bucket names and corresponding path prefixes
         :param auth: authentication information
+        :raises AuthenticationError: authentication is not possible
         :return: authenticated objects per bucket, list of available objects
         """
         if not isinstance(auth, (dict, type(None))):
@@ -583,14 +649,17 @@ class AwsDownload(Download):
         asset_filter: Optional[str],
         ignore_assets: bool,
         product: EOProduct,
+        raise_error: bool = True,
     ) -> set[Any]:
         """
-        retrieve unique product chunks based on authenticated objects and asset filters
+        Retrieve unique product chunks based on authenticated objects and asset filters
+
         :param bucket_names_and_prefixes: list of bucket names and corresponding path prefixes
         :param authenticated_objects: available objects per bucket
         :param asset_filter: text for which assets should be filtered
         :param ignore_assets: if product instead of individual assets should be used
         :param product: product that shall be downloaded
+        :param raise_error: raise error if there is nothing to download
         :return: set of product chunks that can be downloaded
         """
         product_chunks: list[Any] = []
@@ -612,12 +681,12 @@ class AwsDownload(Download):
                     unique_product_chunks,
                 )
             )
-            if not unique_product_chunks:
+            if not unique_product_chunks and raise_error:
                 raise NotAvailableError(
                     rf"No file basename matching re.fullmatch(r'{asset_filter}') was found in {product.remote_location}"
                 )
 
-        if not unique_product_chunks:
+        if not unique_product_chunks and raise_error:
             raise NoMatchingProductType("No product found to download.")
 
         return unique_product_chunks
@@ -701,6 +770,13 @@ class AwsDownload(Download):
             bucket_names_and_prefixes, auth
         )
 
+        # stream not implemented for prefixes like `foo/bar.zip!file.txt`
+        for _, prefix in bucket_names_and_prefixes:
+            if prefix and ".zip!" in prefix:
+                raise NotImplementedError(
+                    "Download streaming is not implemented for files in zip on S3"
+                )
+
         # downloadable files
         unique_product_chunks = self._get_unique_products(
             bucket_names_and_prefixes,
@@ -935,6 +1011,7 @@ class AwsDownload(Download):
                 objects = s3_resource.Bucket(bucket_name).objects
             list(objects.filter(Prefix=prefix).limit(1))
             self.s3_session = s3_session
+            self.s3_resource = s3_resource
             return objects
         else:
             return None
@@ -965,6 +1042,7 @@ class AwsDownload(Download):
                 objects = s3_resource.Bucket(bucket_name).objects
             list(objects.filter(Prefix=prefix).limit(1))
             self.s3_session = s3_session
+            self.s3_resource = s3_resource
             return objects
         else:
             return None
@@ -986,6 +1064,7 @@ class AwsDownload(Download):
             objects = s3_resource.Bucket(bucket_name).objects
         list(objects.filter(Prefix=prefix).limit(1))
         self.s3_session = s3_session
+        self.s3_resource = s3_resource
         return objects
 
     def get_product_bucket_name_and_prefix(

eodag/plugins/search/base.py

@@ -150,7 +150,7 @@ class Search(PluginTopic):
         )
 
     def get_product_type_def_params(
-        self, product_type: str, **kwargs: Any
+        self, product_type: str, format_variables: Optional[dict[str, Any]] = None
     ) -> dict[str, Any]:
         """Get the provider product type definition parameters and specific settings
 
@@ -171,7 +171,8 @@ class Search(PluginTopic):
             return {
                 k: v
                 for k, v in format_dict_items(
-                    self.config.products[GENERIC_PRODUCT_TYPE], **kwargs
+                    self.config.products[GENERIC_PRODUCT_TYPE],
+                    **(format_variables or {}),
                 ).items()
                 if v
             }