cleanup and tests

Author: mafrahm

hbw/analysis/create_analysis.py

@@ -111,8 +111,7 @@ def analysis_factory(configs: od.UniqueObjectIndex):
                     )
                 else:
                     logger.warning(
-                        f"Campaign used for {config_name} has been changed since last initialization."
-                        "Difference: \n",
+                        f"Campaign used for {config_name} is being reinitialized: \n",
                     )
                     cpn_task.run()
 

hbw/scripts/test_config.py

@@ -9,7 +9,6 @@
 
 default_analysis = law.config.get_expanded("analysis", "default_analysis")
 default_config = law.config.get_expanded("analysis", "default_config")
-default_config = "c22uhhpost"
 analysis_inst = ana = AnalysisTask.get_analysis_inst(default_analysis)
 config_inst = cfg = ana.get_config(default_config)
 

hbw/tasks/campaigns.py

@@ -146,9 +146,9 @@ def run(self):
         output = self.output()
 
         # cross check if the dataset summary did change
-        backup_dataset_summary = self.target("backup_dataset_summary.yaml")
-        if backup_dataset_summary.exists():
-            backup_dataset_summary = backup_dataset_summary.load(formatter="yaml")
+        backup_target = self.target("backup_dataset_summary.yaml")
+        if backup_target.exists():
+            backup_dataset_summary = backup_target.load(formatter="yaml")
             if backup_dataset_summary != self.dataset_summary:
                 from hbw.util import gather_dict_diff
                 logger.warning(
@@ -157,15 +157,15 @@ def run(self):
                 )
                 if self.recreate_backup_summary:
                     logger.warning("Recreating backup dataset summary")
-                    backup_dataset_summary.dump(self.dataset_summary, formatter="yaml")
+                    backup_target.dump(self.dataset_summary, formatter="yaml")
                 else:
                     logger.warning(
                         "Run the following command to recreate the backup dataset summary:\n"
                         f"law run {self.task_family} --recreate_backup_summary --config {self.config} --remove-output 0,a,y",  # noqa
                     )
         else:
             logger.warning("No backup dataset summary found, creating one now")
-            backup_dataset_summary.dump(self.dataset_summary, formatter="yaml")
+            backup_target.dump(self.dataset_summary, formatter="yaml")
 
         output["dataset_summary"].dump(self.dataset_summary, formatter="yaml")
         output["campaign_summary"].dump(self.campaign_summary, formatter="yaml")

hbw/util.py

@@ -280,33 +280,33 @@ def filter_unchanged_keys(d1: dict, d2: dict):
     return filtered if filtered else None
 
 
-def dict_diff_filtered(dict1: dict, dict2: dict):
+def dict_diff_filtered(old_dict: dict, new_dict: dict):
     """Return the differences between two dictionaries with nested filtering of unchanged keys."""
     diff = {}
 
     # Check keys present in either dict
-    all_keys = set(dict1.keys()).union(set(dict2.keys()))
+    all_keys = set(old_dict.keys()).union(set(new_dict.keys()))
 
     for key in all_keys:
-        if key in dict1 and key in dict2:
-            if isinstance(dict1[key], dict) and isinstance(dict2[key], dict):
+        if key in old_dict and key in new_dict:
+            if isinstance(old_dict[key], dict) and isinstance(new_dict[key], dict):
                 # Recur for nested dictionaries and get filtered diff
-                nested_diff = filter_unchanged_keys(dict1[key], dict2[key])
+                nested_diff = filter_unchanged_keys(old_dict[key], new_dict[key])
                 if nested_diff:
                     diff[key] = nested_diff
-            elif dict1[key] != dict2[key]:
-                diff[key] = {"old": dict1[key], "new": dict2[key]}
-        elif key in dict1:
-            diff[key] = {"old": dict1[key], "new": None}
+            elif old_dict[key] != new_dict[key]:
+                diff[key] = {"old": old_dict[key], "new": new_dict[key]}
+        elif key in old_dict:
+            diff[key] = {"old": old_dict[key], "new": None}
         else:
-            diff[key] = {"old": None, "new": dict2[key]}
+            diff[key] = {"old": None, "new": new_dict[key]}
 
     return diff
 
 
-def gather_dict_diff(dict1: dict, dict2: dict) -> str:
+def gather_dict_diff(old_dict: dict, new_dict: dict) -> str:
     """Gather the differences between two dictionaries and return them as a formatted string."""
-    diff = filter_unchanged_keys(dict1, dict2)
+    diff = filter_unchanged_keys(old_dict, new_dict)
     lines = []
 
     if not diff:

tests/test_util.py

@@ -8,15 +8,129 @@
 
 from columnflow.util import maybe_import
 
-from hbw.util import build_param_product, round_sig, dict_diff, four_vec, call_once_on_config
+from hbw.util import build_param_product, round_sig, dict_diff, four_vec, call_once_on_config, gather_dict_diff
 
 import order as od
 
 np = maybe_import("numpy")
 ak = maybe_import("awkward")
 
 
-class HbwUtilTest(unittest.TestCase):
+class TestDictDiff(unittest.TestCase):
+    def test_no_difference(self):
+        dict1 = {"name": "Alice", "age": 25}
+        dict2 = {"name": "Alice", "age": 25}
+        result = gather_dict_diff(dict1, dict2)
+        self.assertEqual(result, "✅ No differences found.")
+
+    def test_simple_modification(self):
+        dict1 = {"name": "Alice", "age": 25}
+        dict2 = {"name": "Alice", "age": 26}
+        result = gather_dict_diff(dict1, dict2)
+        expected_output = (
+            "🔄 Modified: age:\n"
+            "    - Old: 25\n"
+            "    - New: 26"
+        )
+        self.assertEqual(result, expected_output)
+
+    def test_addition(self):
+        dict1 = {"name": "Alice"}
+        dict2 = {"name": "Alice", "hobby": "cycling"}
+        result = gather_dict_diff(dict1, dict2)
+        expected_output = "🔹 Added: hobby: cycling"
+        self.assertEqual(result, expected_output)
+
+    def test_removal(self):
+        dict1 = {"name": "Alice", "hobby": "cycling"}
+        dict2 = {"name": "Alice"}
+        result = gather_dict_diff(dict1, dict2)
+        expected_output = "🔻 Removed: hobby: cycling"
+        self.assertEqual(result, expected_output)
+
+    def test_nested_modification(self):
+        dict1 = {
+            "name": "Alice",
+            "skills": {
+                "python": "intermediate",
+                "sql": "beginner"
+            }
+        }
+        dict2 = {
+            "name": "Alice",
+            "skills": {
+                "python": "advanced",
+                "sql": "beginner"
+            }
+        }
+        result = gather_dict_diff(dict1, dict2)
+        expected_output = (
+            "🔄 Modified: skills:\n"
+            "    🔄 Modified: python:\n"
+            "        - Old: intermediate\n"
+            "        - New: advanced"
+        )
+        self.assertEqual(result, expected_output)
+
+    def test_nested_addition(self):
+        dict1 = {
+            "name": "Alice",
+            "skills": {
+                "python": "intermediate"
+            }
+        }
+        dict2 = {
+            "name": "Alice",
+            "skills": {
+                "python": "intermediate",
+                "docker": "beginner"
+            }
+        }
+        result = gather_dict_diff(dict1, dict2)
+        expected_output = (
+            "🔄 Modified: skills:\n"
+            "    🔹 Added: docker: beginner"
+        )
+        self.assertEqual(result, expected_output)
+
+    def test_complex_diff(self):
+        dict1 = {
+            "name": "Alice",
+            "age": 25,
+            "skills": {
+                "python": "intermediate",
+                "sql": "beginner",
+            },
+        }
+        dict2 = {
+            "name": "Alice",
+            "age": 26,
+            "skills": {
+                "python": "advanced",
+                "sql": "beginner",
+                "docker": "beginner",
+            },
+            "hobby": "cycling",
+        }
+        result = gather_dict_diff(dict1, dict2)
+        expected_output = (
+            "🔄 Modified: age:\n"
+            "    - Old: 25\n"
+            "    - New: 26\n"
+            "🔄 Modified: skills:\n"
+            "    🔄 Modified: python:\n"
+            "        - Old: intermediate\n"
+            "        - New: advanced\n"
+            "    🔹 Added: docker: beginner\n"
+            "🔹 Added: hobby: cycling"
+        )
+        self.assertEqual(result, expected_output)
+
+
+class HbwUtilTest(
+    TestDictDiff,
+    unittest.TestCase,
+):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -97,3 +211,7 @@ def some_config_function(config: od.Config) -> str:
 
         # on second call, function should not be called -> returns None
         self.assertEqual(some_config_function(self.config_inst), None)
+
+
+if __name__ == "__main__":
+    unittest.main()