def __update_data_from_catalog_config(self, catalog_config):
"""Updates configuration and data using given input catalog config
:param catalog_config: catalog config, from yml stac_config[catalogs]
:type catalog_config: dict
"""
model = catalog_config["model"]
self.catalog_config = update_nested_dict(self.catalog_config,
catalog_config)
# parse f-strings
# defaultdict usage will return "" for missing keys in format_args
format_args = copy.deepcopy(self.stac_config)
format_args["catalog"] = defaultdict(
str, dict(model, **{
"root": self.root,
"url": self.url
}))
parsed_model = format_dict_items(self.catalog_config["model"],
**format_args)
self.update_data(parsed_model)
return True
def get_queryables(self, search_params):
"""Retrieve the metadata mappings that are query-able"""
logger.debug("Retrieving queryable metadata from metadata_mapping")
queryables = {}
for eodag_search_key, user_input in search_params.items():
if user_input is not None:
md_mapping = self.config.metadata_mapping.get(
eodag_search_key, (None, NOT_MAPPED))
_, md_value = md_mapping
# query param from defined metadata_mapping
if md_mapping is not None and isinstance(md_mapping, list):
search_param = get_search_param(md_mapping)
if search_param is not None:
queryables[eodag_search_key] = search_param
# query param from metadata auto discovery
elif md_value == NOT_MAPPED and getattr(
self.config, "discover_metadata", {}).get(
"auto_discovery", False):
pattern = re.compile(
self.config.discover_metadata.get(
"metadata_pattern", ""))
search_param_cfg = self.config.discover_metadata.get(
"search_param", "")
if pattern.match(eodag_search_key) and isinstance(
search_param_cfg, str):
search_param = search_param_cfg.format(
metadata=eodag_search_key)
queryables[eodag_search_key] = search_param
elif pattern.match(eodag_search_key) and isinstance(
search_param_cfg, dict):
search_param_cfg_parsed = dict_items_recursive_apply(
search_param_cfg,
lambda k, v: v.format(metadata=eodag_search_key),
)
for k, v in search_param_cfg_parsed.items():
if getattr(self.config, k, None):
update_nested_dict(getattr(self.config, k),
v,
extend_list_values=True)
else:
logger.warning(
"Could not use discover_metadata[search_param]: no entry for %s in plugin config",
k,
)
return queryables
def build_query_string(self, *args, **kwargs):
"""Build The query string using the search parameters"""
logger.debug("Building the query string that will be used for search")
if "raise_errors" in kwargs.keys():
del kwargs["raise_errors"]
# . not allowed in eodag_search_key, replaced with %2E
kwargs = {k.replace(".", "%2E"): v for k, v in kwargs.items()}
queryables = self.get_queryables(kwargs)
query_params = {}
# Get all the search parameters that are recognised as queryables by the
# provider (they appear in the queryables dictionary)
for eodag_search_key, provider_search_key in queryables.items():
user_input = kwargs[eodag_search_key]
if self.COMPLEX_QS_REGEX.match(provider_search_key):
parts = provider_search_key.split("=")
if len(parts) == 1:
formatted_query_param = format_metadata(
provider_search_key, *args, **kwargs
)
if "{{" in provider_search_key:
# json query string (for POST request)
update_nested_dict(
query_params, json.loads(formatted_query_param)
)
else:
query_params[eodag_search_key] = formatted_query_param
else:
provider_search_key, provider_value = parts
query_params.setdefault(provider_search_key, []).append(
format_metadata(provider_value, *args, **kwargs)
)
else:
query_params[provider_search_key] = user_input
# Now get all the literal search params (i.e params to be passed "as is"
# in the search request)
# ignore additional_params if it isn't a dictionary
literal_search_params = getattr(self.config, "literal_search_params", {})
if not isinstance(literal_search_params, dict):
literal_search_params = {}
# Now add formatted free text search parameters (this is for cases where a
# complex query through a free text search parameter is available for the
# provider and needed for the consumer)
literal_search_params.update(self.format_free_text_search(**kwargs))
for provider_search_key, provider_value in literal_search_params.items():
if isinstance(provider_value, list):
query_params.setdefault(provider_search_key, []).extend(provider_value)
else:
query_params.setdefault(provider_search_key, []).append(provider_value)
# Build the final query string, in one go without quoting it
# (some providers do not operate well with urlencoded and quoted query strings)
return (
query_params,
urlencode(
query_params, doseq=True, quote_via=lambda x, *_args, **_kwargs: x
),
)