Easier and more self documenting patterns for loading/saving Persistent

[python_utils.git] / dict_utils.py

diff --git a/dict_utils.py b/dict_utils.py
index 6f0f572e988cd5fdfea2e52c1fe1da8e50a80188..573e683c1d84d2f0f11d18e61fa9f950f585e1c4 100644 (file)
--- a/dict_utils.py
+++ b/dict_utils.py
@@ -42,7 +42,6 @@ def shard(d: Dict[Any, Any], size: int) -> Iterator[Dict[Any, Any]]:
     """
     Shards a dict into N subdicts which, together, contain all keys/values
     from the original unsharded dict.
-
     """
     items = d.items()
     for x in range(0, len(d), size):
@@ -50,24 +49,35 @@ def shard(d: Dict[Any, Any], size: int) -> Iterator[Dict[Any, Any]]:
 
 
 def coalesce_by_creating_list(_, new_value, old_value):
+    """Helper for use with :meth:`coalesce` that creates a list on
+    collision."""
     from list_utils import flatten
 
     return flatten([new_value, old_value])
 
 
 def coalesce_by_creating_set(key, new_value, old_value):
+    """Helper for use with :meth:`coalesce` that creates a set on
+    collision."""
     return set(coalesce_by_creating_list(key, new_value, old_value))
 
 
 def coalesce_last_write_wins(_, new_value, discarded_old_value):
+    """Helper for use with :meth:`coalsce` that klobbers the old
+    with the new one on collision."""
     return new_value
 
 
 def coalesce_first_write_wins(_, discarded_new_value, old_value):
+    """Helper for use with :meth:`coalsce` that preserves the old
+    value and discards the new one on collision."""
     return old_value
 
 
 def raise_on_duplicated_keys(key, new_value, old_value):
+    """Helper for use with :meth:`coalesce` that raises an exception
+    when a collision is detected.
+    """
     raise Exception(f'Key {key} is duplicated in more than one input dict.')
 
 
@@ -79,10 +89,13 @@ def coalesce(
     """Merge N dicts into one dict containing the union of all keys /
     values in the input dicts.  When keys collide, apply the
     aggregation_function which, by default, creates a list of values.
-    See also several other alternative functions for coalescing values
-    (coalesce_by_creating_set, coalesce_first_write_wins,
-    coalesce_last_write_wins, raise_on_duplicated_keys) or provide a
-    custom helper function.
+    See also several other alternative functions for coalescing values:
+
+        * :meth:`coalesce_by_creating_set`
+        * :meth:`coalesce_first_write_wins`
+        * :meth:`coalesce_last_write_wins`
+        * :meth:`raise_on_duplicated_keys`
+        * or provive your own collision resolution code.
 
     >>> a = {'a': 1, 'b': 2}
     >>> b = {'b': 1, 'c': 2, 'd': 3}
@@ -111,7 +124,7 @@ def coalesce(
 
 
 def item_with_max_value(d: Dict[Any, Any]) -> Tuple[Any, Any]:
-    """Returns the key and value with the max value in a dict.
+    """Returns the key and value of the item with the max value in a dict.
 
     >>> d = {'a': 1, 'b': 2, 'c': 3}
     >>> item_with_max_value(d)
@@ -126,7 +139,7 @@ def item_with_max_value(d: Dict[Any, Any]) -> Tuple[Any, Any]:
 
 
 def item_with_min_value(d: Dict[Any, Any]) -> Tuple[Any, Any]:
-    """Returns the key and value with the min value in a dict.
+    """Returns the key and value of the item with the min value in a dict.
 
     >>> d = {'a': 1, 'b': 2, 'c': 3}
     >>> item_with_min_value(d)