eodag 3.1.0b1__py3-none-any.whl → 3.2.0__py3-none-any.whl

eodag/api/product/metadata_mapping.py

@@ -23,19 +23,7 @@ import logging
 import re
 from datetime import datetime, timedelta
 from string import Formatter
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AnyStr,
-    Callable,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Tuple,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, AnyStr, Callable, Iterator, Optional, Union, cast
 
 import geojson
 import orjson
@@ -61,6 +49,7 @@ from eodag.utils import (
     get_timestamp,
     items_recursive_apply,
     nested_pairs2dict,
+    sanitize,
     string_to_jsonpath,
     update_nested_dict,
 )
@@ -88,8 +77,8 @@ DEFAULT_GEOMETRY = "POLYGON((180 -90, 180 90, -180 90, -180 -90, 180 -90))"
 
 
 def get_metadata_path(
-    map_value: Union[str, List[str]],
-) -> Tuple[Union[List[str], None], str]:
+    map_value: Union[str, list[str]],
+) -> tuple[Union[list[str], None], str]:
     """Return the jsonpath or xpath to the value of a EO product metadata in a provider
     search result.
 
@@ -137,12 +126,12 @@ def get_metadata_path(
     return None, path
 
 
-def get_metadata_path_value(map_value: Union[str, List[str]]) -> str:
+def get_metadata_path_value(map_value: Union[str, list[str]]) -> str:
     """Get raw metadata path without converter"""
     return map_value[1] if isinstance(map_value, list) else map_value
 
 
-def get_search_param(map_value: List[str]) -> str:
+def get_search_param(map_value: list[str]) -> str:
     """See :func:`~eodag.api.product.metadata_mapping.get_metadata_path`
 
     :param map_value: The value originating from the definition of `metadata_mapping`
@@ -188,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
@@ -335,7 +325,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return wkt_value
 
         @staticmethod
-        def convert_to_bounds_lists(input_geom: BaseGeometry) -> List[List[float]]:
+        def convert_to_bounds_lists(input_geom: BaseGeometry) -> list[list[float]]:
             if isinstance(input_geom, MultiPolygon):
                 geoms = [geom for geom in input_geom.geoms]
                 # sort with larger one at first (stac-browser only plots first one)
@@ -345,7 +335,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 return [list(input_geom.bounds[0:4])]
 
         @staticmethod
-        def convert_to_bounds(input_geom_unformatted: Any) -> List[float]:
+        def convert_to_bounds(input_geom_unformatted: Any) -> list[float]:
             input_geom = get_geometry_from_various(geometry=input_geom_unformatted)
             if isinstance(input_geom, MultiPolygon):
                 geoms = [geom for geom in input_geom.geoms]
@@ -356,16 +346,16 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 max_lon = -180
                 max_lat = -90
                 for geom in geoms:
-                    min_lon = min(min_lon, geom.bound[0])
-                    min_lat = min(min_lat, geom.bound[1])
-                    max_lon = max(max_lon, geom.bound[2])
-                    max_lat = max(max_lat, geom.bound[3])
+                    min_lon = min(min_lon, geom.bounds[0])
+                    min_lat = min(min_lat, geom.bounds[1])
+                    max_lon = max(max_lon, geom.bounds[2])
+                    max_lat = max(max_lat, geom.bounds[3])
                 return [min_lon, min_lat, max_lon, max_lat]
             else:
                 return list(input_geom.bounds[0:4])
 
         @staticmethod
-        def convert_to_nwse_bounds(input_geom: BaseGeometry) -> List[float]:
+        def convert_to_nwse_bounds(input_geom: BaseGeometry) -> list[float]:
             if isinstance(input_geom, str):
                 input_geom = shapely.wkt.loads(input_geom)
             return list(input_geom.bounds[-1:] + input_geom.bounds[:-1])
@@ -379,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]:
@@ -449,7 +439,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                         else:
                             yield e
 
-                polygons_list: List[Polygon] = []
+                polygons_list: list[Polygon] = []
                 for elem in flatten_elements(georss[0]):
                     coords_list = elem.text.split()
                     polygon_args = [
@@ -474,7 +464,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         @staticmethod
         def convert_to_longitude_latitude(
             input_geom_unformatted: Any,
-        ) -> Dict[str, float]:
+        ) -> dict[str, float]:
             bounds = MetadataFormatter.convert_to_bounds(input_geom_unformatted)
             lon = (bounds[0] + bounds[2]) / 2
             lat = (bounds[1] + bounds[3]) / 2
@@ -508,14 +498,21 @@ 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(
-            input_obj: Union[Dict[Any, Any], List[Any]], args: str
-        ) -> Union[Dict[Any, Any], List[Any]]:
+            input_obj: Union[dict[Any, Any], list[Any]], args: str
+        ) -> Union[dict[Any, Any], list[Any]]:
             old, new = ast.literal_eval(args)
             return items_recursive_apply(
                 input_obj,
@@ -525,8 +522,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
         @staticmethod
         def convert_dict_update(
-            input_dict: Dict[Any, Any], args: str
-        ) -> Dict[Any, Any]:
+            input_dict: dict[Any, Any], args: str
+        ) -> dict[Any, Any]:
             """Converts"""
             new_items_list = ast.literal_eval(args)
 
@@ -536,8 +533,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
         @staticmethod
         def convert_dict_filter(
-            input_dict: Dict[Any, Any], jsonpath_filter_str: str
-        ) -> Dict[Any, Any]:
+            input_dict: dict[Any, Any], jsonpath_filter_str: str
+        ) -> dict[Any, Any]:
             """Fitlers dict items using jsonpath"""
 
             jsonpath_filter = string_to_jsonpath(jsonpath_filter_str, force=True)
@@ -616,8 +613,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 return NOT_AVAILABLE
 
         @staticmethod
-        def convert_split_id_into_s1_params(product_id: str) -> Dict[str, str]:
-            parts: List[str] = re.split(r"_(?!_)", product_id)
+        def convert_split_id_into_s1_params(product_id: str) -> dict[str, str]:
+            parts: list[str] = re.split(r"_(?!_)", product_id)
             if len(parts) < 9:
                 logger.error(
                     "id %s does not match expected Sentinel-1 id format", product_id
@@ -651,8 +648,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return params
 
         @staticmethod
-        def convert_split_id_into_s3_params(product_id: str) -> Dict[str, str]:
-            parts: List[str] = re.split(r"_(?!_)", product_id)
+        def convert_split_id_into_s3_params(product_id: str) -> dict[str, str]:
+            parts: list[str] = re.split(r"_(?!_)", product_id)
             params = {"productType": product_id[4:15]}
             dates = re.findall("[0-9]{8}T[0-9]{6}", product_id)
             start_date = datetime.strptime(dates[0], "%Y%m%dT%H%M%S") - timedelta(
@@ -668,8 +665,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return params
 
         @staticmethod
-        def convert_split_id_into_s5p_params(product_id: str) -> Dict[str, str]:
-            parts: List[str] = re.split(r"_(?!_)", product_id)
+        def convert_split_id_into_s5p_params(product_id: str) -> dict[str, str]:
+            parts: list[str] = re.split(r"_(?!_)", product_id)
             params = {
                 "productType": product_id[9:19],
                 "processingMode": parts[1],
@@ -686,7 +683,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return params
 
         @staticmethod
-        def convert_split_cop_dem_id(product_id: str) -> List[int]:
+        def convert_split_cop_dem_id(product_id: str) -> list[int]:
             parts = product_id.split("_")
             lattitude = parts[3]
             longitude = parts[5]
@@ -725,7 +722,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         @staticmethod
         def convert_to_datetime_dict(
             date: str, format: str
-        ) -> Dict[str, Union[List[str], str]]:
+        ) -> dict[str, Union[list[str], str]]:
             """Convert a date (str) to a dictionary where values are in the format given in argument
 
             date == "2021-04-21T18:27:19.123Z" and format == "list" => {
@@ -777,7 +774,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         @staticmethod
         def convert_interval_to_datetime_dict(
             date: str, separator: str = "/"
-        ) -> Dict[str, List[str]]:
+        ) -> dict[str, list[str]]:
             """Convert a date interval ('/' separated str) to a dictionary where values are lists
 
             date == "2021-04-21/2021-04-22" => {
@@ -817,7 +814,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             }
 
         @staticmethod
-        def convert_get_ecmwf_time(date: str) -> List[str]:
+        def convert_get_ecmwf_time(date: str) -> list[str]:
             """Get the time of a date (str) in the ECMWF format (["HH:00"])
 
             "2021-04-21T18:27:19.123Z" => ["18:00"]
@@ -828,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}"
@@ -861,8 +863,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
         @staticmethod
         def convert_assets_list_to_dict(
-            assets_list: List[Dict[str, str]], asset_name_key: str = "title"
-        ) -> Dict[str, Dict[str, str]]:
+            assets_list: list[dict[str, str]], asset_name_key: str = "title"
+        ) -> dict[str, dict[str, str]]:
             """Convert a list of assets to a dictionary where keys represent
             name of assets and are found among values of asset dictionaries.
 
@@ -889,8 +891,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 "asset3": {"href": "qux", "title": "qux-title", "name": "asset3"},
             }
             """
-            asset_names: List[str] = []
-            assets_dict: Dict[str, Dict[str, str]] = {}
+            asset_names: list[str] = []
+            assets_dict: dict[str, dict[str, str]] = {}
 
             for asset in assets_list:
                 asset_name = asset[asset_name_key]
@@ -899,7 +901,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
             # we only keep the equivalent of the path basename in the case where the
             # asset name has a path pattern and this basename is only found once
-            immutable_asset_indexes: List[int] = []
+            immutable_asset_indexes: list[int] = []
             for i, asset_name in enumerate(asset_names):
                 if i in immutable_asset_indexes:
                     continue
@@ -925,10 +927,10 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
 
 def properties_from_json(
-    json: Dict[str, Any],
-    mapping: Dict[str, Any],
-    discovery_config: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
+    json: dict[str, Any],
+    mapping: dict[str, Any],
+    discovery_config: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
     """Extract properties from a provider json result.
 
     :param json: The representation of a provider result as a json object
@@ -941,7 +943,7 @@ def properties_from_json(
                              `discovery_path` (String representation of jsonpath)
     :returns: The metadata of the :class:`~eodag.api.product._product.EOProduct`
     """
-    properties: Dict[str, Any] = {}
+    properties: dict[str, Any] = {}
     templates = {}
     used_jsonpaths = []
     for metadata, value in mapping.items():
@@ -1085,8 +1087,8 @@ def properties_from_xml(
     xml_as_text: AnyStr,
     mapping: Any,
     empty_ns_prefix: str = "ns",
-    discovery_config: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
+    discovery_config: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
     """Extract properties from a provider xml result.
 
     :param xml_as_text: The representation of a provider result as xml
@@ -1104,7 +1106,7 @@ def properties_from_xml(
                              `discovery_path` (String representation of xpath)
     :returns: the metadata of the :class:`~eodag.api.product._product.EOProduct`
     """
-    properties: Dict[str, Any] = {}
+    properties: dict[str, Any] = {}
     templates = {}
     used_xpaths = []
     root = etree.XML(xml_as_text)
@@ -1232,10 +1234,10 @@ def properties_from_xml(
 
 
 def mtd_cfg_as_conversion_and_querypath(
-    src_dict: Dict[str, Any],
-    dest_dict: Dict[str, Any] = {},
+    src_dict: dict[str, Any],
+    dest_dict: dict[str, Any] = {},
     result_type: str = "json",
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Metadata configuration dictionary to querypath with conversion dictionary
     Transform every src_dict value from jsonpath_str to tuple `(conversion, jsonpath_object)`
     or from xpath_str to tuple `(conversion, xpath_str)`
@@ -1283,8 +1285,8 @@ def mtd_cfg_as_conversion_and_querypath(
 
 
 def format_query_params(
-    product_type: str, config: PluginConfig, query_dict: Dict[str, Any]
-) -> Dict[str, Any]:
+    product_type: str, config: PluginConfig, query_dict: dict[str, Any]
+) -> dict[str, Any]:
     """format the search parameters to query parameters"""
     if "raise_errors" in query_dict.keys():
         del query_dict["raise_errors"]
@@ -1296,7 +1298,7 @@ def format_query_params(
         **config.products.get(product_type, {}).get("metadata_mapping", {}),
     )
 
-    query_params: Dict[str, Any] = {}
+    query_params: dict[str, Any] = {}
     # Get all the search parameters that are recognised as queryables by the
     # provider (they appear in the queryables dictionary)
     queryables = _get_queryables(query_dict, config, product_type_metadata_mapping)
@@ -1326,8 +1328,8 @@ def format_query_params(
                     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, product_type, **query_dict)
+                query_params[provider_search_key] = format_metadata(
+                    provider_value, product_type, **query_dict
                 )
         else:
             query_params[provider_search_key] = user_input
@@ -1386,10 +1388,10 @@ def _resolve_hashes(formatted_query_param: str) -> str:
 
 
 def _format_free_text_search(
-    config: PluginConfig, metadata_mapping: Dict[str, Any], **kwargs: Any
-) -> Dict[str, Any]:
+    config: PluginConfig, metadata_mapping: dict[str, Any], **kwargs: Any
+) -> dict[str, Any]:
     """Build the free text search parameter using the search parameters"""
-    query_params: Dict[str, Any] = {}
+    query_params: dict[str, Any] = {}
     if not getattr(config, "free_text_search_operations", None):
         return query_params
     for param, operations_config in config.free_text_search_operations.items():
@@ -1428,13 +1430,13 @@ def _format_free_text_search(
 
 
 def _get_queryables(
-    search_params: Dict[str, Any],
+    search_params: dict[str, Any],
     config: PluginConfig,
-    metadata_mapping: Dict[str, Any],
-) -> Dict[str, Any]:
+    metadata_mapping: dict[str, Any],
+) -> dict[str, Any]:
     """Retrieve the metadata mappings that are query-able"""
     logger.debug("Retrieving queryable metadata from metadata_mapping")
-    queryables: Dict[str, Any] = {}
+    queryables: dict[str, Any] = {}
     for eodag_search_key, user_input in search_params.items():
         if user_input is not None:
             md_mapping = metadata_mapping.get(eodag_search_key, (None, NOT_MAPPED))
@@ -1481,7 +1483,7 @@ def _get_queryables(
 
 
 def get_queryable_from_provider(
-    provider_queryable: str, metadata_mapping: Dict[str, Union[str, List[str]]]
+    provider_queryable: str, metadata_mapping: dict[str, Union[str, list[str]]]
 ) -> Optional[str]:
     """Get EODAG configured queryable parameter from provider queryable parameter
 
@@ -1499,13 +1501,17 @@ 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
 
 
 def get_provider_queryable_path(
-    queryable: str, metadata_mapping: Dict[str, Union[str, List[str]]]
+    queryable: str, metadata_mapping: dict[str, Union[str, list[str]]]
 ) -> Optional[str]:
     """Get EODAG configured queryable path from its parameter
 
@@ -1522,8 +1528,8 @@ def get_provider_queryable_path(
 
 def get_provider_queryable_key(
     eodag_key: str,
-    provider_queryables: Dict[str, Any],
-    metadata_mapping: Dict[str, Union[List[Any], str]],
+    provider_queryables: dict[str, Any],
+    metadata_mapping: dict[str, Union[list[Any], str]],
 ) -> str:
     """Finds the provider queryable corresponding to the given eodag key based on the metadata mapping
 

eodag/api/search_result.py

@@ -18,17 +18,7 @@
 from __future__ import annotations
 
 from collections import UserList
-from typing import (
-    TYPE_CHECKING,
-    Annotated,
-    Any,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Tuple,
-    Union,
-)
+from typing import TYPE_CHECKING, Annotated, Any, Iterable, Optional, Union
 
 from shapely.geometry import GeometryCollection, shape
 from typing_extensions import Doc
@@ -56,17 +46,17 @@ class SearchResult(UserList):
     :ivar number_matched: Estimated total number of matching results
     """
 
-    data: List[EOProduct]
+    data: list[EOProduct]
 
     errors: Annotated[
-        List[Tuple[str, Exception]], Doc("Tuple of provider name, exception")
+        list[tuple[str, Exception]], Doc("Tuple of provider name, exception")
     ]
 
     def __init__(
         self,
-        products: List[EOProduct],
+        products: list[EOProduct],
         number_matched: Optional[int] = None,
-        errors: List[Tuple[str, Exception]] = [],
+        errors: list[tuple[str, Exception]] = [],
     ) -> None:
         super().__init__(products)
         self.number_matched = number_matched
@@ -92,7 +82,7 @@ class SearchResult(UserList):
         return self.crunch(FilterDate(dict(start=start, end=end)))
 
     def filter_latest_intersect(
-        self, geometry: Union[Dict[str, Any], BaseGeometry, Any]
+        self, geometry: Union[dict[str, Any], BaseGeometry, Any]
     ) -> SearchResult:
         """
         Apply :class:`~eodag.plugins.crunch.filter_latest_intersect.FilterLatestIntersect` crunch,
@@ -148,7 +138,7 @@ class SearchResult(UserList):
         return self.filter_property(storageStatus="ONLINE")
 
     @staticmethod
-    def from_geojson(feature_collection: Dict[str, Any]) -> SearchResult:
+    def from_geojson(feature_collection: dict[str, Any]) -> SearchResult:
         """Builds an :class:`~eodag.api.search_result.SearchResult` object from its representation as geojson
 
         :param feature_collection: A collection representing a search result.
@@ -161,7 +151,7 @@ class SearchResult(UserList):
             ]
         )
 
-    def as_geojson_object(self) -> Dict[str, Any]:
+    def as_geojson_object(self) -> dict[str, Any]:
         """GeoJSON representation of SearchResult"""
         return {
             "type": "FeatureCollection",
@@ -182,7 +172,7 @@ class SearchResult(UserList):
         return self.as_shapely_geometry_object().wkt
 
     @property
-    def __geo_interface__(self) -> Dict[str, Any]:
+    def __geo_interface__(self) -> dict[str, Any]:
         """Implements the geo-interface protocol.
 
         See https://gist.github.com/sgillies/2217756
@@ -230,9 +220,9 @@ class RawSearchResult(UserList):
     :param results: A list of raw/unparsed search results
     """
 
-    data: List[Any]
-    query_params: Dict[str, Any]
-    product_type_def_params: Dict[str, Any]
+    data: list[Any]
+    query_params: dict[str, Any]
+    product_type_def_params: dict[str, Any]
 
-    def __init__(self, results: List[Any]) -> None:
+    def __init__(self, results: list[Any]) -> None:
         super(RawSearchResult, self).__init__(results)

eodag/cli.py

@@ -48,7 +48,7 @@ import shutil
 import sys
 import textwrap
 from importlib.metadata import metadata
-from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Set
+from typing import TYPE_CHECKING, Any, Mapping
 
 import click
 
@@ -104,7 +104,7 @@ class MutuallyExclusiveOption(click.Option):
         super(MutuallyExclusiveOption, self).__init__(*args, **kwargs)
 
     def handle_parse_result(
-        self, ctx: Context, opts: Mapping[str, Any], args: List[str]
+        self, ctx: Context, opts: Mapping[str, Any], args: list[str]
     ):
         """Raise error or use parent handle_parse_result()"""
         if self.mutually_exclusive.intersection(opts) and self.name in opts:
@@ -359,9 +359,9 @@ def search_crunch(ctx: Context, **kwargs: Any) -> None:
     count = kwargs.pop("count")
 
     # Process inputs for crunch
-    cruncher_names: Set[Any] = set(kwargs.pop("cruncher") or [])
+    cruncher_names: set[Any] = set(kwargs.pop("cruncher") or [])
     cruncher_args = kwargs.pop("cruncher_args")
-    cruncher_args_dict: Dict[str, Dict[str, Any]] = {}
+    cruncher_args_dict: dict[str, dict[str, Any]] = {}
     if cruncher_args:
         for cruncher, argname, argval in cruncher_args:
             cruncher_args_dict.setdefault(cruncher, {}).setdefault(argname, argval)