DeepDiff.to_dict() was not useful when the original view was 'tree' — it returned a

  dict containing opaque DiffLevel objects rather than a readable Python dictionary. The
  workaround was to_dict(view_override='text'), but that was locked to whatever verbose_level was
   set at init time (default 1), meaning you couldn't get the full detail that the tree view had
  access to.

  Change: Replaced the view_override parameter with verbose_level on both to_dict() and
  to_json(). These methods now always produce a text-view dictionary — an actual usable Python
  dict. The default verbosity is context-aware:

  - If the original view is 'text': uses the verbose_level from initialization (preserving
  existing behavior).
  - If the original view is 'tree': defaults to verbose_level=2 (the most detailed output), since
   tree-view users chose that view for its richness.

  In both cases, you can override the verbosity explicitly: to_dict(verbose_level=0),
  to_dict(verbose_level=1), etc.

Author: seperman

CHANGELOG.md

@@ -1,5 +1,9 @@
 # DeepDiff Change log
 
+- v8-7-0
+    - Support for python 3.14
+    - `to_dict()` and `to_json()` now accept a `verbose_level` parameter and always return a usable text-view dict. When the original view is `'tree'`, they default to `verbose_level=2` for full detail. The old `view_override` parameter is removed.
+
 - v8-6-1
     - Patched security vulnerability in the Delta class which was vulnerable to class pollution via its constructor, and when combined with a gadget available in DeltaDiff itself, it could lead to Denial of Service and Remote Code Execution (via insecure Pickle deserialization).
 

README.md

@@ -25,6 +25,7 @@ Please check the [ChangeLog](CHANGELOG.md) file for the detailed information.
 
 DeepDiff 8-7-0
 - support for python 3.14
+- `to_dict()` and `to_json()` now accept a `verbose_level` parameter and always return a usable text-view dict. When the original view is `'tree'`, they default to `verbose_level=2` for full detail. The old `view_override` parameter is removed.
 
 DeepDiff 8-6-1
 - Patched security vulnerability in the Delta class which was vulnerable to class pollution via its constructor, and when combined with a gadget available in DeltaDiff itself, it could lead to Denial of Service and Remote Code Execution (via insecure Pickle deserialization).

deepdiff/diff.py

@@ -1810,7 +1810,7 @@ def _diff(self, level, parents_ids=frozenset(), _original_type=None, local_tree=
         else:
             self._diff_obj(level, parents_ids)
 
-    def _get_view_results(self, view):
+    def _get_view_results(self, view, verbose_level=None):
         """
         Get the results based on the view
         """
@@ -1820,7 +1820,8 @@ def _get_view_results(self, view):
         if view == TREE_VIEW:
             pass
         elif view == TEXT_VIEW:
-            result = TextResult(tree_results=self.tree, verbose_level=self.verbose_level)
+            effective_verbose_level = verbose_level if verbose_level is not None else self.verbose_level
+            result = TextResult(tree_results=self.tree, verbose_level=effective_verbose_level)
             result.remove_empty_keys()
         elif view == DELTA_VIEW:
             result = self._to_delta_dict(report_repetition_required=False)

deepdiff/serialization.py

@@ -24,6 +24,7 @@
     strings,
     get_type,
     TEXT_VIEW,
+    TREE_VIEW,
     np_float32,
     np_float64,
     np_int32,
@@ -171,7 +172,7 @@ def from_json_pickle(cls, value):
         except ImportError:  # pragma: no cover. Json pickle is getting deprecated.
             logger.error('jsonpickle library needs to be installed in order to run from_json_pickle')  # pragma: no cover. Json pickle is getting deprecated.
 
-    def to_json(self, default_mapping: Optional[dict]=None, force_use_builtin_json=False, **kwargs):
+    def to_json(self, default_mapping: Optional[dict]=None, force_use_builtin_json=False, verbose_level: Optional[int]=None, **kwargs):
         """
         Dump json of the text view.
         **Parameters**
@@ -186,6 +187,8 @@ def to_json(self, default_mapping: Optional[dict]=None, force_use_builtin_json=F
             When True, we use Python's builtin Json library for serialization,
             even if Orjson is installed.
 
+        verbose_level: int, default=None
+            Override the verbose_level for the serialized output. See to_dict() for details.
 
         kwargs: Any other kwargs you pass will be passed on to Python's json.dumps()
 
@@ -208,27 +211,35 @@ def to_json(self, default_mapping: Optional[dict]=None, force_use_builtin_json=F
             >>> ddiff.to_json(default_mapping=default_mapping)
             '{"type_changes": {"root": {"old_type": "A", "new_type": "B", "old_value": "obj A", "new_value": "obj B"}}}'
         """
-        dic = self.to_dict(view_override=TEXT_VIEW)
+        dic = self.to_dict(verbose_level=verbose_level)
         return json_dumps(
             dic,
             default_mapping=default_mapping,
             force_use_builtin_json=force_use_builtin_json,
             **kwargs,
         )
 
-    def to_dict(self, view_override: Optional[str]=None) -> dict:
+    def to_dict(self, verbose_level: Optional[int]=None) -> dict:
         """
-        convert the result to a python dictionary. You can override the view type by passing view_override.
+        Convert the result to a python dictionary.
 
         **Parameters**
 
-        view_override: view type, default=None,
-            override the view that was used to generate the diff when converting to the dictionary.
-            The options are the text or tree.
+        verbose_level: int, default=None
+            Override the verbose_level for the serialized output.
+            When None, the behavior depends on the original view:
+            - If the original view is 'text', the verbose_level from DeepDiff initialization is used.
+            - If the original view is 'tree', verbose_level=2 is used to provide the most detailed output.
+            Valid values are 0, 1, or 2.
         """
-
-        view = view_override if view_override else self.view  # type: ignore
-        return dict(self._get_view_results(view))  # type: ignore
+        if verbose_level is not None and verbose_level not in {0, 1, 2}:
+            raise ValueError('verbose_level should be 0, 1, or 2.')
+        if verbose_level is None:
+            if self.view == TREE_VIEW:  # type: ignore
+                verbose_level = 2
+            else:
+                verbose_level = self.verbose_level  # type: ignore
+        return dict(self._get_view_results(TEXT_VIEW, verbose_level=verbose_level))  # type: ignore
 
     def _to_delta_dict(
         self,

docs/changelog.rst

@@ -5,6 +5,10 @@ Changelog
 
 DeepDiff Changelog
 
+- v8-7-0
+   - Support for python 3.14
+   - ``to_dict()`` and ``to_json()`` now accept a ``verbose_level`` parameter and always return a usable text-view dict. When the original view is ``'tree'``, they default to ``verbose_level=2`` for full detail. The old ``view_override`` parameter is removed.
+
 - v8-6-1
    - Patched security vulnerability in the Delta class which was vulnerable to class pollution via its constructor, and when combined with a gadget available in DeltaDiff itself, it could lead to Denial of Service and Remote Code Execution (via insecure Pickle deserialization).
 

docs/serialization.rst

@@ -11,6 +11,18 @@ To Dict
 -------
 
 In order to convert the DeepDiff object into a normal Python dictionary, use the to_dict() method.
+The result is always a text-view dictionary regardless of the original view used to create the DeepDiff object.
+
+**Parameters**
+
+verbose_level: int, default=None
+    Override the verbose_level for the serialized output.
+    When None, the behavior depends on the original view:
+
+    - If the original view is 'text', the verbose_level from DeepDiff initialization is used.
+    - If the original view is 'tree', verbose_level=2 is used to provide the most detailed output.
+
+    Valid values are 0, 1, or 2.
 
 Example:
     >>> t1 = {1: 1, 2: 2, 3: 3, 4: {"a": "hello", "b": [1, 2, 3]}}
@@ -20,15 +32,22 @@ Example:
     {'type_changes': {"root[4]['b']": {'old_type': <class 'list'>, 'new_type': <class 'str'>, 'old_value': [1, 2, 3], 'new_value': 'world\n\n\nEnd'}}}
 
 
-Note that you can override the :ref:`view_label` that was originally used to generate the diff here.
+When the original view is 'tree', to_dict() defaults to verbose_level=2 for the most detailed output:
 
 Example:
     >>> t1 = {1: 1, 2: 2, 3: 3, 4: {"a": "hello", "b": [1, 2, 3]}}
     >>> t2 = {1: 1, 2: 2, 3: 3, 4: {"a": "hello", "b": "world\n\n\nEnd"}}
     >>> ddiff = DeepDiff(t1, t2, view='tree')
-    >>> ddiff.to_dict(view_override='text')
+    >>> ddiff.to_dict()
     {'type_changes': {"root[4]['b']": {'old_type': <class 'list'>, 'new_type': <class 'str'>, 'old_value': [1, 2, 3], 'new_value': 'world\n\n\nEnd'}}}
 
+You can also override the verbose_level:
+
+Example:
+    >>> ddiff = DeepDiff(t1, t2, view='tree')
+    >>> ddiff.to_dict(verbose_level=0)
+    {'type_changes': {"root[4]['b']": {'old_type': <class 'list'>, 'new_type': <class 'str'>}}}
+
 .. _to_json_label:
 
 To Json
@@ -46,6 +65,9 @@ by default DeepDiff converts certain data types. For example Decimals into float
 If you have a certain object type that the json serializer can not serialize it, please pass the appropriate type
 conversion through this dictionary.
 
+verbose_level: int, default=None
+    Override the verbose_level for the serialized output. Same behavior as to_dict().
+
 kwargs: Any other kwargs you pass will be passed on to Python's json.dumps()
 
 

tests/test_command.py

@@ -11,7 +11,7 @@
 class TestCommands:
 
     @pytest.mark.parametrize('name1, name2, expected_in_stdout, expected_exit_code', [
-        ('t1.json', 't2.json', """dictionary_item_added": [\n    "root[0][\'key3\']""", 0),
+        ('t1.json', 't2.json', """dictionary_item_added": {\n    "root[0]['key3']": "value3\"""", 0),
         ('t1_corrupt.json', 't2.json', "Error when loading t1:", 1),
         ('t1.json', 't2_json.csv', '"old_value": "value2"', 0),
         ('t2_json.csv', 't1.json', '"old_value": "value3"', 0),

tests/test_serialization.py

@@ -123,6 +123,74 @@ def test_to_dict_at_different_verbose_level(self, verbose_level, expected):
         ddiff = DeepDiff(t1, t2, verbose_level=verbose_level)
         assert expected == ddiff.to_dict()
 
+    def test_to_dict_tree_view_defaults_to_verbose_level_2(self):
+        t1 = ['a', {1: 1, 3: 4}]
+        t2 = [10, {1: 2, 5: 6}, 'd']
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = ddiff.to_dict()
+        # tree view defaults to verbose_level=2: added/removed are dicts, not sets
+        expected = {
+            "type_changes": {"root[0]": {"old_type": str, "new_type": int, "old_value": "a", "new_value": 10}},
+            "dictionary_item_added": {"root[1][5]": 6},
+            "dictionary_item_removed": {"root[1][3]": 4},
+            "values_changed": {"root[1][1]": {"new_value": 2, "old_value": 1}},
+            "iterable_item_added": {"root[2]": "d"},
+        }
+        assert expected == result
+
+    @pytest.mark.parametrize('verbose_level, expected', [
+        (0, {"type_changes": {"root[0]": {"old_type": str, "new_type": int}}, "dictionary_item_added": ["root[1][5]"], "dictionary_item_removed": ["root[1][3]"], "iterable_item_added": {"root[2]": "d"}}),
+        (1, {"type_changes": {"root[0]": {"old_type": str, "new_type": int, "old_value": "a", "new_value": 10}}, "dictionary_item_added": ["root[1][5]"], "dictionary_item_removed": ["root[1][3]"], "values_changed": {"root[1][1]": {"new_value": 2, "old_value": 1}}, "iterable_item_added": {"root[2]": "d"}}),
+    ])
+    def test_to_dict_tree_view_with_verbose_level_override(self, verbose_level, expected):
+        t1 = ['a', {1: 1, 3: 4}]
+        t2 = [10, {1: 2, 5: 6}, 'd']
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = ddiff.to_dict(verbose_level=verbose_level)
+        assert expected == result
+
+    def test_to_dict_text_view_preserves_original_verbose_level(self):
+        t1 = ['a', {1: 1, 3: 4}]
+        t2 = [10, {1: 2, 5: 6}, 'd']
+        # verbose_level=2 at init, text view
+        ddiff = DeepDiff(t1, t2, verbose_level=2)
+        result = ddiff.to_dict()
+        # Should preserve verbose_level=2 from init
+        assert isinstance(result.get("dictionary_item_added"), dict)
+        assert result["dictionary_item_added"] == {"root[1][5]": 6}
+
+    def test_to_dict_text_view_with_verbose_level_override(self):
+        t1 = ['a', {1: 1, 3: 4}]
+        t2 = [10, {1: 2, 5: 6}, 'd']
+        # verbose_level=2 at init, but override to 1 in to_dict
+        ddiff = DeepDiff(t1, t2, verbose_level=2)
+        result = ddiff.to_dict(verbose_level=1)
+        # verbose_level=1: dictionary_item_added is not a dict (it's a SetOrdered)
+        assert not isinstance(result.get("dictionary_item_added"), dict)
+
+    def test_to_dict_invalid_verbose_level(self):
+        t1 = [1]
+        t2 = [2]
+        ddiff = DeepDiff(t1, t2)
+        with pytest.raises(ValueError):
+            ddiff.to_dict(verbose_level=3)
+
+    def test_to_json_with_verbose_level(self):
+        t1 = ['a', {1: 1, 3: 4}]
+        t2 = [10, {1: 2, 5: 6}, 'd']
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = json.loads(ddiff.to_json())
+        # tree view defaults to verbose_level=2 in to_json too
+        assert "root[1][5]" in result.get("dictionary_item_added", {})
+
+    def test_to_json_with_verbose_level_override(self):
+        t1 = ['a', {1: 1, 3: 4}]
+        t2 = [10, {1: 2, 5: 6}, 'd']
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = json.loads(ddiff.to_json(verbose_level=1))
+        # verbose_level=1: dictionary_item_added is a list
+        assert isinstance(result.get("dictionary_item_added"), list)
+
     def test_serialize_pydantic_model(self):
         obj = SampleSchema(
             works=True,