eodag 3.0.0b2__py3-none-any.whl → 3.0.1__py3-none-any.whl

eodag/utils/__init__.py

@@ -55,6 +55,7 @@ from typing import (
     Any,
     Callable,
     Dict,
+    Iterable,
     Iterator,
     List,
     Mapping,
@@ -78,11 +79,6 @@ from urllib.parse import (  # noqa; noqa
 )
 from urllib.request import url2pathname
 
-if sys.version_info >= (3, 9):
-    from typing import Annotated, get_args, get_origin  # noqa
-else:
-    from typing_extensions import Annotated, get_args, get_origin  # type: ignore # noqa
-
 if sys.version_info >= (3, 12):
     from typing import Unpack  # type: ignore # noqa
 else:
@@ -98,7 +94,7 @@ from dateutil.tz import UTC
 from jsonpath_ng import jsonpath
 from jsonpath_ng.ext import parse
 from jsonpath_ng.jsonpath import Child, Fields, Index, Root, Slice
-from requests import HTTPError
+from requests import HTTPError, Response
 from shapely.geometry import Polygon, shape
 from shapely.geometry.base import GEOMETRY_TYPES, BaseGeometry
 from tqdm.auto import tqdm
@@ -109,7 +105,7 @@ from eodag.utils.exceptions import MisconfiguredError
 if TYPE_CHECKING:
     from jsonpath_ng import JSONPath
 
-    from eodag.api.product import EOProduct
+    from eodag.api.product._product import EOProduct
 
 
 logger = py_logging.getLogger("eodag.utils")
@@ -124,6 +120,10 @@ USER_AGENT = {"User-Agent": f"eodag/{eodag_version}"}
 HTTP_REQ_TIMEOUT = 5  # in seconds
 DEFAULT_STREAM_REQUESTS_TIMEOUT = 60  # in seconds
 
+REQ_RETRY_TOTAL = 3
+REQ_RETRY_BACKOFF_FACTOR = 2
+REQ_RETRY_STATUS_FORCELIST = [401, 429, 500, 502, 503, 504]
+
 # default wait times in minutes
 DEFAULT_DOWNLOAD_WAIT = 2  # in minutes
 DEFAULT_DOWNLOAD_TIMEOUT = 20  # in minutes
@@ -236,9 +236,10 @@ class FloatRange(click.types.FloatParamType):
 def slugify(value: Any, allow_unicode: bool = False) -> str:
     """Copied from Django Source code, only modifying last line (no need for safe
     strings).
+
     source: https://github.com/django/django/blob/master/django/utils/text.py
 
-    Convert to ASCII if 'allow_unicode' is False. Convert spaces to hyphens.
+    Convert to ASCII if ``allow_unicode`` is ``False``. Convert spaces to hyphens.
     Remove characters that aren't alphanumerics, underscores, or hyphens.
     Convert to lowercase. Also strip leading and trailing whitespace.
     """
@@ -297,7 +298,7 @@ def strip_accents(s: str) -> str:
 
 def uri_to_path(uri: str) -> str:
     """
-    Convert a file URI (e.g. 'file:///tmp') to a local path (e.g. '/tmp')
+    Convert a file URI (e.g. ``file:///tmp``) to a local path (e.g. ``/tmp``)
     """
     if not uri.startswith("file"):
         raise ValueError("A file URI must be provided (e.g. 'file:///tmp'")
@@ -321,9 +322,7 @@ def mutate_dict_in_place(func: Callable[[Any], Any], mapping: Dict[Any, Any]) ->
     mapping.
 
     :param func: A function to apply to each value of mapping which is not a dict object
-    :type func: func
     :param mapping: A Python dict object
-    :type mapping: dict
     :returns: None
     """
     for key, value in mapping.items():
@@ -334,10 +333,10 @@ def mutate_dict_in_place(func: Callable[[Any], Any], mapping: Dict[Any, Any]) ->
 
 
 def merge_mappings(mapping1: Dict[Any, Any], mapping2: Dict[Any, Any]) -> None:
-    """Merge two mappings with string keys, values from `mapping2` overriding values
-    from `mapping1`.
+    """Merge two mappings with string keys, values from ``mapping2`` overriding values
+    from ``mapping1``.
 
-    Do its best to detect the key in `mapping1` to override. For example::
+    Do its best to detect the key in ``mapping1`` to override. For example:
 
     >>> mapping2 = {"keya": "new"}
     >>> mapping1 = {"keyA": "obsolete"}
@@ -345,14 +344,11 @@ def merge_mappings(mapping1: Dict[Any, Any], mapping2: Dict[Any, Any]) -> None:
     >>> mapping1
     {'keyA': 'new'}
 
-    If mapping2 has a key that cannot be detected in mapping1, this new key is added
-    to mapping1 as is.
+    If ``mapping2`` has a key that cannot be detected in ``mapping1``, this new key is
+    added to ``mapping1`` as is.
 
     :param mapping1: The mapping containing values to be overridden
-    :type mapping1: dict
-    :param mapping2: The mapping containing values that will override the
-                     first mapping
-    :type mapping2: dict
+    :param mapping2: The mapping containing values that will override the first mapping
     """
     # A mapping between mapping1 keys as lowercase strings and original mapping1 keys
     m1_keys_lowercase = {key.lower(): key for key in mapping1}
@@ -419,9 +415,7 @@ def get_timestamp(date_time: str) -> float:
     If the datetime has no offset, it is assumed to be an UTC datetime.
 
     :param date_time: The datetime string to return as timestamp
-    :type date_time: str
-    :returns: The timestamp corresponding to the date_time string in seconds
-    :rtype: float
+    :returns: The timestamp corresponding to the ``date_time`` string in seconds
     """
     dt = isoparse(date_time)
     if not dt.tzinfo:
@@ -430,7 +424,7 @@ def get_timestamp(date_time: str) -> float:
 
 
 def datetime_range(start: dt, end: dt) -> Iterator[dt]:
-    """Generator function for all dates in-between start and end date."""
+    """Generator function for all dates in-between ``start`` and ``end`` date."""
     delta = end - start
     for nday in range(delta.days + 1):
         yield start + datetime.timedelta(days=nday)
@@ -443,7 +437,6 @@ class DownloadedCallback:
         """Callback
 
         :param product: The downloaded EO product
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         """
         logger.debug("Download finished for the product %s", product)
 
@@ -451,15 +444,15 @@ class DownloadedCallback:
 class ProgressCallback(tqdm):
     """A callable used to render progress to users for long running processes.
 
-    It inherits from `tqdm.auto.tqdm`, and accepts the same arguments on
-    instantiation: `iterable`, `desc`, `total`, `leave`, `file`, `ncols`,
-    `mininterval`, `maxinterval`, `miniters`, `ascii`, `disable`, `unit`,
-    `unit_scale`, `dynamic_ncols`, `smoothing`, `bar_format`, `initial`,
-    `position`, `postfix`, `unit_divisor`.
+    It inherits from :class:`tqdm.auto.tqdm`, and accepts the same arguments on
+    instantiation: ``iterable``, ``desc``, ``total``, ``leave``, ``file``, ``ncols``,
+    ``mininterval``, ``maxinterval``, ``miniters``, ``ascii``, ``disable``, ``unit``,
+    ``unit_scale``, ``dynamic_ncols``, ``smoothing``, ``bar_format``, ``initial``,
+    ``position``, ``postfix``, ``unit_divisor``.
 
-    It can be globally disabled using `eodag.utils.logging.setup_logging(0)` or
-    `eodag.utils.logging.setup_logging(level, no_progress_bar=True)`, and
-    individually disabled using `disable=True`.
+    It can be globally disabled using ``eodag.utils.logging.setup_logging(0)`` or
+    ``eodag.utils.logging.setup_logging(level, no_progress_bar=True)``, and
+    individually disabled using ``disable=True``.
     """
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
@@ -483,9 +476,7 @@ class ProgressCallback(tqdm):
         """Update the progress bar.
 
         :param increment: Amount of data already processed
-        :type increment: int
         :param total: (optional) Maximum amount of data to be processed
-        :type total: int
         """
         if total is not None and total != self.total:
             self.reset(total=total)
@@ -496,8 +487,8 @@ class ProgressCallback(tqdm):
         """Returns another progress callback using the same initial
         keyword-arguments.
 
-        Optional `args` and `kwargs` parameters will be used to create a
-        new `~eodag.utils.ProgressCallback` instance, overriding initial
+        Optional ``args`` and ``kwargs`` parameters will be used to create a
+        new :class:`~eodag.utils.ProgressCallback` instance, overriding initial
         `kwargs`.
         """
 
@@ -519,7 +510,7 @@ def get_progress_callback() -> tqdm:
 
 
 def repeatfunc(func: Callable[..., Any], n: int, *args: Any) -> starmap:
-    """Call `func` `n` times with `args`"""
+    """Call ``func`` ``n`` times with ``args``"""
     return starmap(func, repeat(args, n))
 
 
@@ -534,14 +525,12 @@ def makedirs(dirpath: str) -> None:
 
 
 def rename_subfolder(dirpath: str, name: str) -> None:
-    """Rename first subfolder found in dirpath with given name,
-    raise RuntimeError if no subfolder can be found
+    """Rename first subfolder found in ``dirpath`` with given ``name``,
+    raise :class:`RuntimeError` if no subfolder can be found
 
     :param dirpath: path to the directory containing the subfolder
-    :type dirpath: str
     :param name: new name of the subfolder
-    :type name: str
-    :raises: RuntimeError
+    :raises: :class:`RuntimeError`
 
     Example:
 
@@ -555,16 +544,20 @@ def rename_subfolder(dirpath: str, name: str) -> None:
     ...     rename_subfolder(tmpdir, "otherfolder")
     ...     assert not os.path.isdir(somefolder) and os.path.isdir(otherfolder)
 
-    Before:
+    Before::
+
         $ tree <tmp-folder>
         <tmp-folder>
         └── somefolder
             └── somefile
-    After:
+
+    After::
+
         $ tree <tmp-folder>
         <tmp-folder>
         └── otherfolder
             └── somefile
+
     """
     try:
         subdir, *_ = (p for p in glob(os.path.join(dirpath, "*")) if os.path.isdir(p))
@@ -580,7 +573,7 @@ def rename_subfolder(dirpath: str, name: str) -> None:
 def format_dict_items(
     config_dict: Dict[str, Any], **format_variables: Any
 ) -> Dict[Any, Any]:
-    r"""Recursive apply string.format(\**format_variables) to dict elements
+    r"""Recursively apply :meth:`str.format` to ``**format_variables`` on ``config_dict`` values
 
     >>> format_dict_items(
     ...     {"foo": {"bar": "{a}"}, "baz": ["{b}?", "{b}!"]},
@@ -588,12 +581,9 @@ def format_dict_items(
     ... ) == {"foo": {"bar": "qux"}, "baz": ["quux?", "quux!"]}
     True
 
-    :param config_dict: Dictionnary having values that need to be parsed
-    :type config_dict: dict
+    :param config_dict: Dictionary having values that need to be parsed
     :param format_variables: Variables used as args for parsing
-    :type format_variables: dict
     :returns: Updated dict
-    :rtype: dict
     """
     return dict_items_recursive_apply(config_dict, format_string, **format_variables)
 
@@ -601,7 +591,7 @@ def format_dict_items(
 def jsonpath_parse_dict_items(
     jsonpath_dict: Dict[str, Any], values_dict: Dict[str, Any]
 ) -> Dict[Any, Any]:
-    """Recursive parse jsonpath elements in dict
+    """Recursively parse :class:`jsonpath_ng.JSONPath` elements in dict
 
     >>> import jsonpath_ng.ext as jsonpath
     >>> jsonpath_parse_dict_items(
@@ -610,12 +600,9 @@ def jsonpath_parse_dict_items(
     ... ) == {'foo': {'bar': 'baz'}, 'qux': ['quux', 'quux']}
     True
 
-    :param jsonpath_dict: Dictionnary having values that need to be parsed
-    :type jsonpath_dict: dict
+    :param jsonpath_dict: Dictionary having :class:`jsonpath_ng.JSONPath` values that need to be parsed
     :param values_dict: Values dict used as args for parsing
-    :type values_dict: dict
     :returns: Updated dict
-    :rtype: dict
     """
     return dict_items_recursive_apply(jsonpath_dict, parse_jsonpath, **values_dict)
 
@@ -627,7 +614,7 @@ def update_nested_dict(
     allow_empty_values: bool = False,
     allow_extend_duplicates: bool = True,
 ) -> Dict[Any, Any]:
-    """Update recursively old_dict items with new_dict ones
+    """Update recursively ``old_dict`` items with ``new_dict`` ones
 
     >>> update_nested_dict(
     ...     {"a": {"a.a": 1, "a.b": 2}, "b": 3},
@@ -661,15 +648,10 @@ def update_nested_dict(
     True
 
     :param old_dict: Dict to be updated
-    :type old_dict: dict
     :param new_dict: Incomming dict
-    :type new_dict: dict
     :param extend_list_values: (optional) Extend old_dict value if both old/new values are lists
-    :type extend_list_values: bool
     :param allow_empty_values: (optional) Allow update with empty values
-    :type allow_empty_values: bool
     :returns: Updated dict
-    :rtype: dict
     """
     for k, v in new_dict.items():
         if k in old_dict.keys():
@@ -734,13 +716,9 @@ def items_recursive_apply(
     'foo'
 
     :param input_obj: Input object (dict or list)
-    :type input_obj: Union[dict,list]
     :param apply_method: Method to be applied to dict elements
-    :type apply_method: :func:`apply_method`
     :param apply_method_parameters: Optional parameters passed to the method
-    :type apply_method_parameters: dict
     :returns: Updated object
-    :rtype: Union[dict, list]
     """
     if isinstance(input_obj, dict):
         return dict_items_recursive_apply(
@@ -768,14 +746,10 @@ def dict_items_recursive_apply(
     ... ) == {'foo': {'bar': 'BAZ!'}, 'qux': ['A!', 'B!']}
     True
 
-    :param config_dict: Input nested dictionnary
-    :type config_dict: dict
+    :param config_dict: Input nested dictionary
     :param apply_method: Method to be applied to dict elements
-    :type apply_method: :func:`apply_method`
     :param apply_method_parameters: Optional parameters passed to the method
-    :type apply_method_parameters: dict
     :returns: Updated dict
-    :rtype: dict
     """
     result_dict: Dict[Any, Any] = deepcopy(config_dict)
     for dict_k, dict_v in result_dict.items():
@@ -809,13 +783,9 @@ def list_items_recursive_apply(
     [{'foo': {'bar': 'BAZ!'}}, 'QUX!']
 
     :param config_list: Input list containing nested lists/dicts
-    :type config_list: list
     :param apply_method: Method to be applied to list elements
-    :type apply_method: :func:`apply_method`
     :param apply_method_parameters: Optional parameters passed to the method
-    :type apply_method_parameters: dict
     :returns: Updated list
-    :rtype: list
     """
     result_list = deepcopy(config_list)
     for list_idx, list_v in enumerate(result_list):
@@ -850,9 +820,7 @@ def items_recursive_sort(
     'foo'
 
     :param input_obj: Input object (dict or list)
-    :type input_obj: Union[dict,list]
     :returns: Updated object
-    :rtype: Union[dict, list]
     """
     if isinstance(input_obj, dict):
         return dict_items_recursive_sort(input_obj)
@@ -871,10 +839,8 @@ def dict_items_recursive_sort(config_dict: Dict[Any, Any]) -> Dict[Any, Any]:
     ... ) == {"a": ["b", {0: 1, 1: 2, 2: 0}], "b": {"a": 0, "b": "c"}}
     True
 
-    :param config_dict: Input nested dictionnary
-    :type config_dict: dict
+    :param config_dict: Input nested dictionary
     :returns: Updated dict
-    :rtype: dict
     """
     result_dict: Dict[Any, Any] = deepcopy(config_dict)
     for dict_k, dict_v in result_dict.items():
@@ -895,9 +861,7 @@ def list_items_recursive_sort(config_list: List[Any]) -> List[Any]:
     ['b', {0: 1, 1: 2, 2: 0}]
 
     :param config_list: Input list containing nested lists/dicts
-    :type config_list: list
     :returns: Updated list
-    :rtype: list
     """
     result_list: List[Any] = deepcopy(config_list)
     for list_idx, list_v in enumerate(result_list):
@@ -912,7 +876,7 @@ def list_items_recursive_sort(config_list: List[Any]) -> List[Any]:
 
 
 def string_to_jsonpath(*args: Any, force: bool = False) -> Union[str, JSONPath]:
-    """Get jsonpath for "$.foo.bar" like string
+    """Get :class:`jsonpath_ng.JSONPath` for ``$.foo.bar`` like string
 
     >>> string_to_jsonpath(None, "$.foo.bar")
     Child(Child(Root(), Fields('foo')), Fields('bar'))
@@ -926,11 +890,8 @@ def string_to_jsonpath(*args: Any, force: bool = False) -> Union[str, JSONPath]:
     Fields('foo')
 
     :param args: Last arg as input string value, to be converted
-    :type args: str
-    :param force: force conversion even if input string is not detected as a jsonpath
-    :type force: bool
+    :param force: force conversion even if input string is not detected as a :class:`jsonpath_ng.JSONPath`
     :returns: Parsed value
-    :rtype: str or Child or Root
     """
     path_str: str = args[-1]
     if JSONPATH_MATCH.match(str(path_str)) or force:
@@ -992,17 +953,14 @@ def string_to_jsonpath(*args: Any, force: bool = False) -> Union[str, JSONPath]:
 
 
 def format_string(key: str, str_to_format: Any, **format_variables: Any) -> Any:
-    """Format "{foo}" like string
+    """Format ``"{foo}"``-like string
 
     >>> format_string(None, "foo {bar}, {baz} ?", **{"bar": "qux", "baz": "quux"})
     'foo qux, quux ?'
 
     :param key: Input item key
-    :type key: str
     :param str_to_format: Input item value, to be parsed
-    :type str_to_format: str
     :returns: Parsed value
-    :rtype: str
     """
     if not isinstance(str_to_format, str):
         return str_to_format
@@ -1033,20 +991,16 @@ def format_string(key: str, str_to_format: Any, **format_variables: Any) -> Any:
 def parse_jsonpath(
     key: str, jsonpath_obj: Union[str, jsonpath.Child], **values_dict: Dict[str, Any]
 ) -> Optional[str]:
-    """Parse jsonpah in jsonpath_obj using values_dict
+    """Parse jsonpah in ``jsonpath_obj`` using ``values_dict``
 
     >>> import jsonpath_ng.ext as jsonpath
     >>> parse_jsonpath(None, parse("$.foo.bar"), **{"foo": {"bar": "baz"}})
     'baz'
 
     :param key: Input item key
-    :type key: str
     :param jsonpath_obj: Input item value, to be parsed
-    :type jsonpath_obj: str or jsonpath.Child
     :param values_dict: Values used as args for parsing
-    :type values_dict: dict
     :returns: Parsed value
-    :rtype: str
     """
     if isinstance(jsonpath_obj, jsonpath.Child):
         match = jsonpath_obj.find(values_dict)
@@ -1062,9 +1016,7 @@ def nested_pairs2dict(pairs: Union[List[Any], Any]) -> Union[Any, Dict[Any, Any]
     {'foo': {'bar': 'baz'}}
 
     :param pairs: Pairs of key / value
-    :type pairs: list or Any
     :returns: Created dict
-    :rtype: dict or Any
     """
     d = {}
     try:
@@ -1081,14 +1033,11 @@ def nested_pairs2dict(pairs: Union[List[Any], Any]) -> Union[Any, Dict[Any, Any]
 def get_geometry_from_various(
     locations_config: List[Dict[str, Any]] = [], **query_args: Any
 ) -> BaseGeometry:
-    """Creates a shapely geometry using given query kwargs arguments
+    """Creates a ``shapely.geometry`` using given query kwargs arguments
 
     :param locations_config: (optional) EODAG locations configuration
-    :type locations_config: list
-    :param query_args: Query kwargs arguments from core.search() method
-    :type query_args: dict
+    :param query_args: Query kwargs arguments from :meth:`~eodag.api.core.EODataAccessGateway.search`
     :returns: shapely Geometry found
-    :rtype: :class:`shapely.geometry.BaseGeometry`
     :raises: :class:`ValueError`
     """
     geom = None
@@ -1150,11 +1099,11 @@ def get_geometry_from_various(
     for arg in query_locations.keys():
         if arg in locations_dict.keys():
             found = False
-            pattern = query_locations[arg]
+            pattern = rf"{query_locations[arg]}"
             attr = locations_dict[arg]["attr"]
             with shapefile.Reader(locations_dict[arg]["path"]) as shp:
                 for shaperec in shp.shapeRecords():
-                    if re.search(pattern, shaperec.record[attr]):
+                    if re.search(pattern, str(shaperec.record[attr])):
                         found = True
                         new_geom = shape(shaperec.shape)
                         # get geoms union
@@ -1183,7 +1132,7 @@ class MockResponse:
     def raise_for_status(self) -> None:
         """raises an exception when the status is not ok"""
         if self.status_code != 200:
-            raise HTTPError()
+            raise HTTPError(response=Response())
 
 
 def md5sum(file_path: str) -> str:
@@ -1194,9 +1143,7 @@ def md5sum(file_path: str) -> str:
     'd41d8cd98f00b204e9800998ecf8427e'
 
     :param file_path: input file path
-    :type file_path: str
     :returns: MD5 checksum
-    :rtype: str
     """
     hash_md5 = hashlib.md5()
     with open(file_path, "rb") as f:
@@ -1212,16 +1159,14 @@ def obj_md5sum(data: Any) -> str:
     '37a6259cc0c1dae299a7866489dff0bd'
 
     :param data: JSON serializable input object
-    :type data: Any
     :returns: MD5 checksum
-    :rtype: str
     """
     return hashlib.md5(orjson.dumps(data, option=orjson.OPT_SORT_KEYS)).hexdigest()
 
 
 @functools.lru_cache()
 def cached_parse(str_to_parse: str) -> JSONPath:
-    """Cached jsonpath_ng.ext.parse
+    """Cached :func:`jsonpath_ng.ext.parse`
 
     >>> cached_parse.cache_clear()
     >>> cached_parse("$.foo")
@@ -1237,10 +1182,8 @@ def cached_parse(str_to_parse: str) -> JSONPath:
     >>> cached_parse.cache_info()
     CacheInfo(hits=1, misses=2, maxsize=128, currsize=2)
 
-    :param str_to_parse: string to parse as jsonpath
-    :type str_to_parse: str
-    :returns: parsed jsonpath
-    :rtype: :class:`jsonpath_ng.JSONPath`
+    :param str_to_parse: string to parse as :class:`jsonpath_ng.JSONPath`
+    :returns: parsed :class:`jsonpath_ng.JSONPath`
     """
     return parse(str_to_parse)
 
@@ -1254,12 +1197,10 @@ def _mutable_cached_yaml_load(config_path: str) -> Any:
 
 
 def cached_yaml_load(config_path: str) -> Dict[str, Any]:
-    """Cached yaml.load
+    """Cached :func:`yaml.load`
 
     :param config_path: path to the yaml configuration file
-    :type config_path: str
     :returns: loaded yaml configuration
-    :rtype: dict
     """
     return copy_deepcopy(_mutable_cached_yaml_load(config_path))
 
@@ -1271,14 +1212,12 @@ def _mutable_cached_yaml_load_all(config_path: str) -> List[Any]:
 
 
 def cached_yaml_load_all(config_path: str) -> List[Any]:
-    """Cached yaml.load_all
+    """Cached :func:`yaml.load_all`
 
     Load all configurations stored in the configuration file as separated yaml documents
 
     :param config_path: path to the yaml configuration file
-    :type config_path: str
     :returns: list of configurations
-    :rtype: list
     """
     return copy_deepcopy(_mutable_cached_yaml_load_all(config_path))
 
@@ -1289,11 +1228,8 @@ def get_bucket_name_and_prefix(
     """Extract bucket name and prefix from URL
 
     :param url: (optional) URL to use as product.location
-    :type url: str
     :param bucket_path_level: (optional) bucket location index in path.split('/')
-    :type bucket_path_level: int
     :returns: bucket_name and prefix as str
-    :rtype: tuple
     """
     bucket, prefix = None, None
 
@@ -1322,9 +1258,7 @@ def flatten_top_directories(
     """Flatten directory structure, removing common empty sub-directories
 
     :param nested_dir_root: Absolute path of the directory structure to flatten
-    :type nested_dir_root: str
     :param common_subdirs_path: (optional) Absolute path of the desired subdirectory to remove
-    :type common_subdirs_path: str
     """
     if not common_subdirs_path:
         subpaths_list = [p for p in Path(nested_dir_root).glob("**/*") if p.is_file()]
@@ -1343,12 +1277,11 @@ def flatten_top_directories(
 
 def deepcopy(sth: Any) -> Any:
     """Customized and faster deepcopy inspired by https://stackoverflow.com/a/45858907
-    `_copy_list` and `_copy_dict` available for the moment
+
+    ``_copy_list`` and ``_copy_dict`` dispatchers available for the moment
 
     :param sth: Object to copy
-    :type sth: Any
     :returns: Copied object
-    :rtype: Any
     """
     _dispatcher: Dict[Type[Any], Callable[..., Any]] = {}
 
@@ -1391,9 +1324,7 @@ def parse_header(header: str) -> Message:
     'example.txt'
 
     :param header: header to parse
-    :type header: str
     :returns: parsed header
-    :rtype: :class:`~email.message.Message`
     """
     m = Message()
     m["content-type"] = header
@@ -1412,7 +1343,7 @@ def cast_scalar_value(value: Any, new_type: Any) -> Any:
 
     :param value: the scalar value to convert
     :param new_type: the wanted type
-    :returns: scalar value converted to new_type
+    :returns: scalar ``value`` converted to ``new_type``
     """
     if isinstance(value, str) and new_type is bool:
         # Bool is a type with special meaning in Python, thus the special
@@ -1435,7 +1366,7 @@ def cast_scalar_value(value: Any, new_type: Any) -> Any:
 class StreamResponse:
     """Represents a streaming response"""
 
-    content: Iterator[bytes]
+    content: Iterable[bytes]
     headers: Optional[Mapping[str, str]] = None
     media_type: Optional[str] = None
     status_code: Optional[int] = None
@@ -1458,11 +1389,10 @@ def guess_extension(type: str) -> Optional[str]:
 
 def get_ssl_context(ssl_verify: bool) -> ssl.SSLContext:
     """
-    Returns an SSL context based on ssl_verify argument.
-    :param ssl_verify: ssl_verify parameter
-    :type ssl_verify: bool
+    Returns an SSL context based on ``ssl_verify`` argument.
+
+    :param ssl_verify: :attr:`~eodag.config.PluginConfig.ssl_verify` parameter
     :returns: An SSL context object.
-    :rtype: ssl.SSLContext
     """
     ctx = ssl.create_default_context()
     if not ssl_verify:
@@ -1472,3 +1402,34 @@ def get_ssl_context(ssl_verify: bool) -> ssl.SSLContext:
         ctx.check_hostname = True
         ctx.verify_mode = ssl.CERT_REQUIRED
     return ctx
+
+
+def sort_dict(input_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Recursively sorts a dict by keys.
+
+    :param input_dict: input dict
+    :returns: sorted dict
+
+    >>> sort_dict({"b": {"c": 1, "a": 2, "b": 3}, "a": 4})
+    {'a': 4, 'b': {'a': 2, 'b': 3, 'c': 1}}
+    """
+    return {
+        k: sort_dict(v) if isinstance(v, dict) else v
+        for k, v in sorted(input_dict.items())
+    }
+
+
+def dict_md5sum(input_dict: Dict[str, Any]) -> str:
+    """
+    Hash nested dictionary
+
+    :param input_dict: input dict
+    :returns: hash
+
+    >>> hd = dict_md5sum({"b": {"c": 1, "a": 2, "b": 3}, "a": 4})
+    >>> hd
+    'a195bcef1bb3b419e9e74b7cc5db8098'
+    >>> assert(dict_md5sum({"a": 4, "b": {"b": 3, "c": 1, "a": 2}}) == hd)
+    """
+    return obj_md5sum(sort_dict(input_dict))