add obfuscator methods to decision tables and dp groups objects

this is based on discussion in #795. Not sure if we're going to keep this or not.

Author: ahouseholder

src/ssvc/decision_tables/base.py

@@ -166,6 +166,26 @@ def validate_mapping(self):
 
         return self
 
+    def obfuscate(self) -> "DecisionTable":
+        """
+        Obfuscate the decision table by renaming the dict keys.
+        """
+        obfuscated_dpg, translator = self.decision_point_group.obfuscate()
+
+        new_table = self.copy(deep=True)
+        new_table.decision_point_group = obfuscated_dpg
+        new_table.outcome = translator.get(self.outcome, self.outcome)
+        # replace all the keys in mapping dicts
+        new_table.mapping = []
+        for row in self.mapping:
+            new_row = {}
+            for key in row.keys():
+                new_key = translator[key]
+                new_row[new_key] = row[key]
+            new_table.mapping.append(new_row)
+
+        return new_table
+
 
 def decision_table_to_df(dt: DecisionTable, longform=False) -> pd.DataFrame:
     """
@@ -531,6 +551,10 @@ def main() -> None:
     print(table.model_dump_json(indent=2))
     print("```")
 
+    print("## Obfuscated JSON representation of the decision table:")
+    obfuscated = table.obfuscate()
+    print(obfuscated.model_dump_json(indent=2))
+
 
 if __name__ == "__main__":
     main()

src/ssvc/dp_groups/base.py

@@ -22,6 +22,7 @@
 """
 Provides a DecisionPointGroup object for use in SSVC.
 """
+import secrets
 from collections.abc import MutableMapping
 from itertools import product
 
@@ -86,6 +87,37 @@ def add(self, decision_point: DecisionPoint) -> None:
         # set the decision point in the dictionary
         self.decision_points[decision_point.id] = decision_point
 
+    def obfuscate(self) -> tuple["DecisionPointGroup", dict[str, str]]:
+        """
+        Returns a new DecisionPointGroup object, with the keys of the decision points dict obfuscated.
+
+        Returns:
+            tuple: A tuple containing the new DecisionPointGroup and a dictionary mapping old keys to new obfuscated keys.
+        """
+        token_len = 4
+        new_dict = {}
+        translator = {}
+        for old_key in self.decision_points.keys():
+            while True:
+                new_key = secrets.token_hex(token_len)
+                # make the new key match NNNN-NNNN...
+                new_key = "-".join(
+                    new_key[i : i + token_len]
+                    for i in range(0, len(new_key), token_len)
+                )
+                # uppercase the new key
+                new_key = new_key.upper()
+                if new_key not in translator:
+                    break
+            # got a unique new_key
+            translator[old_key] = new_key
+            new_dict[new_key] = self.decision_points[old_key]
+
+        new_group = self.copy(deep=True)
+        new_group.decision_points = new_dict
+
+        return (new_group, translator)
+
     def combination_strings(self) -> list[tuple[str, ...]]:
         """
         Generate all combinations of decision point values as strings.