Add extra saving functions

Author: seankmartin

skm_pyutils/config.py

@@ -4,7 +4,6 @@
 import os
 import sys
 from pprint import pprint
-
 import yaml
 
 
@@ -144,23 +143,26 @@ def normalise_path(pth):
         exec(contents, {}, metadata)
     except Exception as e:
         import traceback
+
         print("QUITTING: An error occurred reading {}".format(path))
         traceback.print_exc()
         exit(-1)
     metadata = {k.lower(): v for (k, v) in metadata.items()}
     return metadata
 
+
 def read_yaml(path):
-    with open(path, 'r') as stream:
-        parsed_yaml=yaml.safe_load(stream)
+    with open(path, "r") as stream:
+        parsed_yaml = yaml.safe_load(stream)
     return parsed_yaml
 
 
 def read_json(path):
-    with open(path, 'r') as stream:
+    with open(path, "r") as stream:
         parsed_json = json.load(stream)
     return parsed_json
 
+
 def split_dict(in_dict, index):
     """
     Grab the value at index from each list in the dictionary.
@@ -183,3 +185,58 @@ def split_dict(in_dict, index):
         if isinstance(value, list):
             new_dict[key] = value[index]
     return new_dict
+
+def convert_dict_to_string(in_dict, name):
+    """
+    Convert the underlying parameters dictionary to string.
+
+    Can be useful for printing or writing to a file.
+    Does not overwrite default __str__ as the output is quite verbose.
+
+    Parameters
+    ----------
+    in_dict : dict
+        Input dictionary
+
+    Returns
+    -------
+    str
+        The string representation of the dict.
+
+    """
+
+    def _val_to_str(val):
+        """
+        Convert a value to a string.
+
+        One caveat, if a string is passed, it returns
+        the original string wrapped in quotes.
+
+        Parameters
+        ----------
+        val : object
+            The value to convert
+
+        Returns
+        -------
+        str
+            The value as a string.
+
+        """
+        return f"'{val}'" if isinstance(val, str) else val
+
+    out_str = ""
+    out_str += name + " = {\n"
+    for k, v in in_dict.items():
+        out_str += f"\t{_val_to_str(str(k))}:"
+        if isinstance(v, dict):
+            out_str += "\n\t\t{\n"
+            for k2, v2 in v.items():
+                out_str += "\t\t {}: {},\n".format(
+                    _val_to_str(str(k2)), _val_to_str(v2)
+                )
+            out_str += "\t\t},\n"
+        else:
+            out_str += f" {_val_to_str(v)},\n"
+    out_str += "\t}"
+    return out_str

skm_pyutils/save.py

@@ -1,6 +1,7 @@
 """Utilities for saving structures to disk."""
 import csv
 import os
+from typing import Union
 
 import numpy as np
 
@@ -134,3 +135,82 @@ def save_dicts_to_csv(filename, in_dicts, do_sort=True):
 
     except Exception as e:
         log_exception(e, "When {} saving to csv".format(filename))
+
+
+def data_dict_from_attr_list(
+    input_item, attr_list: list, friendly_names: Union["list[str]", None] = None
+):
+    """
+    From a list of attributes, return a dictionary.
+
+    Each item in attr_list should be a tuple containing
+    attributes, keys, or None.
+    The elements of the tuple are then accessed iteratively, like
+    item.tuple_el1.tuple_el2...
+    If the element is an attribute, it is directly retrieved.
+    If the element is a key in a dictionary, that is retrieved.
+    If the element is None, it indicates a break.
+    (This last option can be used to get functions without calling them,
+    or to get a full dictionary instead of pulling out the key, value pairs.)
+
+    The output also depends on what is retrieved, if a dictionary or a function.
+    Functions are called with no arguments.
+    Dictionaries have key value pairs, that are stored in the output dictionary.
+    Both of these can be avoided by passing the last element of the tuple as None.
+
+    As an example:
+    item.results = {"addition": {"1 + 1": 2}}
+    item.data.running_speed = [0.5, 1.4, 1.5]
+    attr_list = [("results", "addition", None)]
+    this_fn(attr_list) = {"results_addition": {"1 + 1" = 2}}
+    attr_list = [("results", "addition"), ("data", "running_speed")]
+    this_fn(attr_list) = {"1 + 1": 2, "data_running_speed": [0.5, 1.4, 1.5]}
+
+    Parameters
+    ----------
+    input_item : Any
+        The item to get data attributes from.
+    attr_list : list
+        The list of attributes to retrieve.
+    friendly_names : list of str, optional
+        What to name each retrieved attribute, (default None).
+        Must be the same size as attr_list or None.
+
+    Returns
+    -------
+    dict
+        The retrieved attributes.
+
+    Raises
+    ------
+    ValueError
+        attr_list and friendly_names are not the same size.
+
+    """
+    if friendly_names is not None and len(friendly_names) != len(attr_list):
+        raise ValueError("friendly_names and attr_list must be the same length")
+
+    data_out = {}
+    for i, attr_tuple in enumerate(attr_list):
+        item = input_item
+        for a in attr_tuple:
+            if a is None:
+                break
+            item = (
+                getattr(item, a) if isinstance(a, str) and hasattr(item, a) else item[a]
+            )
+            if callable(item):
+                item = item()
+        if isinstance(item, dict):
+            for key, value in item.items():
+                data_out[key] = value
+        else:
+            non_none_attrs = [x for x in attr_tuple if x is not None]
+            if friendly_names is None:
+                key = "_".join(non_none_attrs)
+            else:
+                key = friendly_names[i]
+                if key is None:
+                    key = "_".join(non_none_attrs)
+            data_out[key] = item
+    return data_out