Addressing reviews

Author: ewirbel

source/isaaclab/isaaclab/sim/simulation_context.py

@@ -30,6 +30,7 @@
 from pxr import Gf, PhysxSchema, Sdf, Usd, UsdPhysics, UsdUtils
 
 import isaaclab.sim as sim_utils
+from isaaclab.utils.dict import to_flat_dict
 from isaaclab.utils.logger import configure_logging
 from isaaclab.utils.version import get_isaac_sim_version
 
@@ -41,33 +42,6 @@
 logger = logging.getLogger(__name__)
 
 
-def to_flat_dict(input_dict: dict[str, Any], delimiter: str = ".") -> dict[str, Any]:
-    """A simple method to transform a nested dict with key strings into a flat dict
-    where keys are separated with a given delimiter. For example, if the input dictionary
-    is {"foo": "bar", "spam": {"egg": "ham"}}, and the delimiter is ".", then the output
-    would be {"foo": "bar", "spam.egg": "ham"}
-
-    Args:
-        input_dict (dict[str, Any]): Input dictionary with string keys, potentially nested.
-        delimiter (str, optional): Delimiter for concatenating keys. Defaults to ".".
-
-    Returns:
-        dict[str, Any]: Output flattened dictionary with nested keys.
-    """
-    out_dict = {}
-    for key, value in input_dict.items():
-        # If we have a dict inside the current value, we need to flatten it.
-        if isinstance(value, dict):
-            inner_flattened_dict = to_flat_dict(value, delimiter)
-            # Recursively combine parent key with inner flattened directory.
-            for inner_key, inner_value in inner_flattened_dict.items():
-                out_dict[f"{key}{delimiter}{inner_key}"] = inner_value
-        # If we are already flat, keep as is.
-        else:
-            out_dict[key] = value
-    return out_dict
-
-
 class SimulationContext(_SimulationContext):
     """A class to control simulation-related events such as physics stepping and rendering.
 

source/isaaclab/isaaclab/utils/dict.py

@@ -342,3 +342,30 @@ def print_dict(val, nesting: int = -4, start: bool = True):
             print(callable_to_string(val))
         else:
             print(val)
+
+
+def to_flat_dict(input_dict: dict[str, Any], delimiter: str = ".") -> dict[str, Any]:
+    """A simple method to transform a nested dict with key strings into a flat dict
+    where keys are separated with a given delimiter. For example, if the input dictionary
+    is {"foo": "bar", "spam": {"egg": "ham"}}, and the delimiter is ".", then the output
+    would be {"foo": "bar", "spam.egg": "ham"}
+
+    Args:
+        input_dict (dict[str, Any]): Input dictionary with string keys, potentially nested.
+        delimiter (str, optional): Delimiter for concatenating keys. Defaults to ".".
+
+    Returns:
+        dict[str, Any]: Output flattened dictionary with nested keys.
+    """
+    out_dict = {}
+    for key, value in input_dict.items():
+        # If we have a dict inside the current value, we need to flatten it.
+        if isinstance(value, dict):
+            inner_flattened_dict = to_flat_dict(value, delimiter)
+            # Recursively combine parent key with inner flattened directory.
+            for inner_key, inner_value in inner_flattened_dict.items():
+                out_dict[f"{key}{delimiter}{inner_key}"] = inner_value
+        # If we are already flat, keep as is.
+        else:
+            out_dict[key] = value
+    return out_dict

source/isaaclab/test/utils/test_dict.py

@@ -97,3 +97,25 @@ def test_dict_to_md5():
     for _ in range(200):
         md5_hash_2 = dict_utils.dict_to_md5_hash(test_dict)
         assert md5_hash_1 == md5_hash_2
+
+
+def test_to_flat_dict():
+    """Test dictionary flattening."""
+
+    # create a complex nested dictionary
+    test_dict = {
+        "a": 1,
+        "b": 2,
+        "c": {"d": 3, "e": 4, "f": {"g": 5, "h": 6}},
+        "i": random.random(),
+        "k": dict_utils.callable_to_string(dict_utils.class_to_dict),
+    }
+    flattened_dict = dict_utils.to_flat_dict(test_dict)
+
+    # Test that we match the nesting
+    expected_keys = ["a", "b", "c.d", "c.e", "c.f.g", "c.f.h"]
+    expected_values = [1, 2, 3, 4, 5, 6]
+    assert len(flattened_dict) == len(expected_keys)
+    for key, value in flattened_dict:
+        assert key in expected_keys
+        assert value in expected_values