leaving variuos implementations of summary in this commit for future

reference

Author: seperman

deepdiff/helper.py

@@ -815,3 +815,6 @@ class FlatDeltaRow(NamedTuple):
     t2_to_index: Optional[int] = None
 
     __repr__ = __str__ = named_tuple_repr
+
+
+type JSON = dict[str, "JSON"] | list["JSON"] | str | int | float | bool | None

deepdiff/summarize.py

@@ -22,6 +22,7 @@ def __init__(self, data: Any, key=None):
         self.key = key
         self.children_list: list[JSONNode] = []
         self.children_dict: list[tuple[Any, JSONNode]] = []
+        self.value: str = ""
         if isinstance(data, dict):
             self.type = "dict"
             # Preserve insertion order: list of (key, child) pairs.
@@ -39,6 +40,15 @@ def __init__(self, data: Any, key=None):
             except Exception:
                 self.value = str(data)
 
+    def __repr__(self) -> str:
+        if self.children_list:
+            return "List-[" + ",".join([str(i) for i in self.children_list]) + "]"
+        if self.children_dict:
+            return "Dict-[" + ",".join([f"{i}:{v}" for i, v in self.children_dict]) + "]"
+        return self.value
+
+    __str__ = __repr__
+
     def full_repr(self) -> str:
         """Return the full minimized JSON representation (without trimming) for this node."""
         if self.type == "primitive":
@@ -72,7 +82,7 @@ def _summarize(self, budget) -> str:
             return self._summarize_dict(budget)
         elif self.type == "list":
             return self._summarize_list(budget)
-        return self.value
+        return str(self.value)
 
     def _summarize_dict(self, budget) -> str:
         # If the dict is empty, return {}
@@ -140,12 +150,21 @@ def _summarize_list(self, budget) -> str:
             return full_repr
         # For lists, show only the first element and an omission indicator if more elements exist.
         suffix = ",..." if len(self.children_list) > 1 else ""
+
         inner_budget = budget - 2 - len(suffix)  # subtract brackets and suffix
-        first_summary = self.children_list[0]._summarize(inner_budget)
-        candidate = "[" + first_summary + suffix + "]"
-        if len(candidate) <= budget:
-            return candidate
-        return _truncate(candidate, budget)
+        budget_per_element: int =  min(inner_budget, max(4, inner_budget // len(self.children_list)))
+        max_element_count: int = inner_budget // budget_per_element
+        element_summaries: list[str] = []
+        for element in self.children_list[:max_element_count]:
+            element_summaries.append(element._summarize(budget_per_element))
+        # first_summary = self.children_list[0]._summarize(budget_per_element)
+        joined_elements = ",".join(element_summaries)
+        joined_elements = joined_elements.rstrip(".")
+        joined_elements = joined_elements[:inner_budget]
+        return f"[{joined_elements}{suffix}]"
+        # if len(candidate) <= budget:
+        #     return candidate
+        # return _truncate(candidate, budget)
 
 
 def summarize(data, max_length=200):

deepdiff/summarize2.py

@@ -0,0 +1,129 @@
+from deepdiff.helper import JSON
+from deepdiff.serialization import json_dumps
+
+# type edge_weight_child_strcuture = tuple[int, int, Any]
+
+# Function to calculate node weights recursively
+def calculate_weights(node):# -> tuple[int, tuple[str, edge_weight_child_strcuture]]:
+    if isinstance(node, dict):
+        weight = 0
+        children_weights = {}
+        for k, v in node.items():
+            edge_weight = len(k)
+            child_weight, child_structure = calculate_weights(v)
+            total_weight = edge_weight + child_weight
+            weight += total_weight
+            children_weights[k] = (edge_weight, child_weight, child_structure)
+        return weight, ('dict', children_weights)
+
+    elif isinstance(node, list):
+        weight = 0
+        children_weights = []
+        for v in node:
+            edge_weight = 0  # As per updated instruction, indexes have zero weight
+            child_weight, child_structure = calculate_weights(v)
+            total_weight = edge_weight + child_weight
+            weight += total_weight
+            children_weights.append((edge_weight, child_weight, child_structure))
+        return weight, ('list', children_weights)
+
+    else:
+        if isinstance(node, str):
+            node_weight = len(node)
+        elif isinstance(node, int):
+            node_weight = len(str(node))
+        elif isinstance(node, float):
+            node_weight = len(str(round(node, 2)))
+        elif node is None:
+            node_weight = 1
+        else:
+            node_weight = 0
+        return node_weight, ('leaf', node)
+
+
+def _truncate(s: str, max_len: int) -> str:
+    """
+    Truncate string s to max_len characters.
+    If possible, keep the first (max_len-5) characters, then '...' then the last 2 characters.
+    """
+    if len(s) <= max_len:
+        return s
+    if max_len <= 5:
+        return s[:max_len]
+    return s[:max_len - 5] + "..." + s[-2:]
+
+
+# Greedy algorithm to shrink the tree
+def shrink_tree(node_structure, max_weight: int) -> tuple[JSON, int]:
+    node_type, node_info = node_structure
+
+    if node_type == 'leaf':
+        leaf_value = node_info
+        leaf_weight, _ = calculate_weights(leaf_value)
+        if leaf_weight <= max_weight:
+            return leaf_value, leaf_weight
+        else:
+            # Truncate leaf value if string
+            if isinstance(leaf_value, str):
+                truncated_value = _truncate(leaf_value, max_weight)
+                return truncated_value, len(truncated_value)
+            # For int or float, convert to string and truncate
+            elif isinstance(leaf_value, (int, float)):
+                leaf_str = str(leaf_value)
+                truncated_str = leaf_str[:max_weight]
+                # Convert back if possible
+                try:
+                    return int(truncated_str), len(truncated_str)
+                except Exception:
+                    try:
+                        return float(truncated_str), len(truncated_str)
+                    except Exception:
+                        return truncated_str, len(truncated_str)
+            elif leaf_value is None:
+                return None, 1 if max_weight >=1 else 0
+
+    elif node_type == 'dict':
+        shrunk_dict = {}
+        total_weight = 0
+        # Sort children by weight (heavy first)
+        sorted_children = sorted(node_info.items(), key=lambda x: x[1][0] + x[1][1], reverse=True)
+        for k, (edge_w, child_w, child_struct) in sorted_children:
+            if total_weight + edge_w >= max_weight:
+                continue  # Skip heavy edge entirely
+            remaining_weight = max_weight - total_weight - edge_w
+            shrunk_child, shrunk_weight = shrink_tree(child_struct, remaining_weight)
+            if shrunk_child is not None:
+                shrunk_dict[k[:edge_w]] = shrunk_child
+                total_weight += edge_w + shrunk_weight
+            if total_weight >= max_weight:
+                break
+        return shrunk_dict, total_weight
+
+    elif node_type == 'list':
+        shrunk_list = []
+        total_weight = 0
+        # Sort children by weight (heavy first)
+        sorted_children = sorted(node_info, key=lambda x: x[0] + x[1], reverse=True)
+        for edge_w, child_w, child_struct in sorted_children:
+            remaining_weight = max_weight - total_weight
+            shrunk_child, shrunk_weight = shrink_tree(child_struct, remaining_weight)
+            if shrunk_child is not None:
+                shrunk_list.append(shrunk_child)
+                total_weight += shrunk_weight
+            if total_weight >= max_weight - 1:
+                shrunk_list.append('...')
+                break
+        return shrunk_list, total_weight
+    return None, 1
+
+# Main function to summarize the tree
+def summarize_tree(tree: dict | list, max_weight: int) -> JSON:
+    total_weight, tree_structure = calculate_weights(tree)
+    if total_weight <= max_weight:
+        return tree  # No need to shrink
+    shrunk_tree, _ = shrink_tree(tree_structure, max_weight)
+    return shrunk_tree
+
+# Exposed function for user convenience
+def summarize(json_data, max_length=200) -> str:
+    return json_dumps(summarize_tree(json_data, max_length))

deepdiff/summarize3.py

@@ -0,0 +1,138 @@
+from deepdiff.helper import JSON
+from deepdiff.serialization import json_dumps
+
+
+def _truncate(s: str, max_len: int) -> str:
+    """
+    Truncate string s to max_len characters.
+    If possible, keep the first (max_len-5) characters, then '...' then the last 2 characters.
+    """
+    if len(s) <= max_len:
+        return s
+    if max_len <= 5:
+        return s[:max_len]
+    return s[:max_len - 5] + "..." + s[-2:]
+# Re-defining the functions due to environment reset
+
+
+# Function to calculate node weights recursively
+def calculate_weights(node):
+    if isinstance(node, dict):
+        weight = 0
+        children_weights = {}
+        for k, v in node.items():
+            edge_weight = len(k)
+            child_weight, child_structure = calculate_weights(v)
+            total_weight = edge_weight + child_weight
+            weight += total_weight
+            children_weights[k] = (edge_weight, child_weight, child_structure)
+        return weight, ('dict', children_weights)
+
+    elif isinstance(node, list):
+        weight = 0
+        children_weights = []
+        for v in node:
+            edge_weight = 0  # Index weights are zero
+            child_weight, child_structure = calculate_weights(v)
+            total_weight = edge_weight + child_weight
+            weight += total_weight
+            children_weights.append((edge_weight, child_weight, child_structure))
+        return weight, ('list', children_weights)
+
+    else:
+        if isinstance(node, str):
+            node_weight = len(node)
+        elif isinstance(node, int):
+            node_weight = len(str(node))
+        elif isinstance(node, float):
+            node_weight = len(str(round(node, 2)))
+        elif node is None:
+            node_weight = 1
+        else:
+            node_weight = 0
+        return node_weight, ('leaf', node)
+
+# Include previously defined functions for shrinking with threshold
+# (Implementing directly the balanced summarization algorithm as above)
+
+# Balanced algorithm (simplified version):
+def shrink_tree_balanced(node_structure, max_weight: int, balance_threshold: float):
+    node_type, node_info = node_structure
+
+    if node_type == 'leaf':
+        leaf_value = node_info
+        leaf_weight, _ = calculate_weights(leaf_value)
+        if leaf_weight <= max_weight:
+            return leaf_value, leaf_weight
+        else:
+            if isinstance(leaf_value, str):
+                truncated_value = _truncate(leaf_value, max_weight)
+                return truncated_value, len(truncated_value)
+            elif isinstance(leaf_value, (int, float)):
+                leaf_str = str(leaf_value)
+                truncated_str = leaf_str[:max_weight]
+                try:
+                    return int(truncated_str), len(truncated_str)
+                except Exception:
+                    try:
+                        return float(truncated_str), len(truncated_str)
+                    except Exception:
+                        return truncated_str, len(truncated_str)
+            elif leaf_value is None:
+                return None, 1 if max_weight >= 1 else 0
+
+    elif node_type == 'dict':
+        shrunk_dict = {}
+        total_weight = 0
+        sorted_children = sorted(node_info.items(), key=lambda x: x[1][0] + x[1][1], reverse=True)
+
+        for k, (edge_w, child_w, child_struct) in sorted_children:
+            allowed_branch_weight = min(max_weight * balance_threshold, max_weight - total_weight)
+            if allowed_branch_weight <= edge_w:
+                continue
+
+            remaining_weight = int(allowed_branch_weight - edge_w)
+            shrunk_child, shrunk_weight = shrink_tree_balanced(child_struct, remaining_weight, balance_threshold)
+            if shrunk_child is not None:
+                shrunk_dict[k[:edge_w]] = shrunk_child
+                total_weight += edge_w + shrunk_weight
+
+            if total_weight >= max_weight:
+                break
+        if not shrunk_dict:
+            return None, 0
+
+        return shrunk_dict, total_weight
+
+    elif node_type == 'list':
+        shrunk_list = []
+        total_weight = 0
+        sorted_children = sorted(node_info, key=lambda x: x[0] + x[1], reverse=True)
+        for edge_w, child_w, child_struct in sorted_children:
+            allowed_branch_weight = int(min(max_weight * balance_threshold, max_weight - total_weight))
+            shrunk_child, shrunk_weight = shrink_tree_balanced(child_struct, allowed_branch_weight, balance_threshold)
+            if shrunk_child is not None:
+                shrunk_list.append(shrunk_child)
+                total_weight += shrunk_weight
+            if total_weight >= max_weight - 1:
+                shrunk_list.append("...")
+                break
+        if not shrunk_list:
+            return None, 0
+        return shrunk_list, total_weight
+    return None, 0
+
+# Main exposed function
+def greedy_tree_summarization_balanced(json_data, max_weight: int, balance_threshold=0.6):
+    total_weight, tree_structure = calculate_weights(json_data)
+    if total_weight <= max_weight:
+        return json_data
+    shrunk_tree, _ = shrink_tree_balanced(tree_structure, max_weight, balance_threshold)
+    return shrunk_tree
+
+
+# Exposed function for user convenience
+def summarize(json_data, max_length=200, balance_threshold=0.6) -> str:
+    return json_dumps(
+        greedy_tree_summarization_balanced(json_data, max_length, balance_threshold)
+    )

tests/test_summarize.py

@@ -132,8 +132,10 @@ def test_list_summary(self):
         assert "..." not in summary
 
         data2 = list(range(1, 200))
-        summary2 = summarize(data2)
+        summary2 = summarize(data2, max_length=14)
         assert "..." in summary2
+        expected = '[1,2,...]'
+        assert expected == summary2
 
     def test_direct_truncate_function(self):
         s = "abcdefghijklmnopqrstuvwxyz"