From 85015b13f0e9b9cb978ed2812e46ee4049a71500 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Kara=C5=9B?= <michal.karas@10clouds.com>
Date: Sat, 11 Apr 2020 13:15:30 +0200
Subject: [PATCH 01/11] wip write first test for pretty_form

---
 deepdiff/diff.py        |  3 +++
 tests/test_diff_tree.py | 13 +++++++++++++
 2 files changed, 16 insertions(+)

diff --git a/deepdiff/diff.py b/deepdiff/diff.py
index 6ad557fe..85edf0c1 100755
--- a/deepdiff/diff.py
+++ b/deepdiff/diff.py
@@ -721,6 +721,9 @@ def to_dict(self):
             result = dict(self)
         return result
 
+    def pretty_form(self):
+        pass
+
 
 if __name__ == "__main__":  # pragma: no cover
     import doctest
diff --git a/tests/test_diff_tree.py b/tests/test_diff_tree.py
index 44abd648..43ab8006 100644
--- a/tests/test_diff_tree.py
+++ b/tests/test_diff_tree.py
@@ -184,3 +184,16 @@ def test_adding_list_diff(self):
         ddiff = DeepDiff(t1, t2, view='tree')
         addition = ddiff + t1
         assert addition == t2
+
+
+class TestDeepDiffPrettyForm:
+    """Tests for pretty_form() method of DeepDiff"""
+
+    @pytest.mark.parametrize('t1, t2, changed_item, old_type, new_type, old_val_displayed, new_val_displayed',
+                             [
+                                 [{2: 2, 4: 4}, {2: 'b', 5: 5}, '[2]', 'int', 'str', '2', '"b"'],
+                             ]
+                             )
+    def test_pretty_form_type_and_value_changes(self, t1, t2, changed_item, old_type, new_type, old_val_displayed, new_val_displayed):
+        ddiff = DeepDiff(t1, t2, view='tree')
+        assert ddiff.pretty_form() == f'Type of {changed_item} changed from {old_type} to {new_type} and value changed from {old_val_displayed} to {new_val_displayed}'

From d5f65915df63f1fae9e59ef9e1852f50cc9aa685 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Kara=C5=9B?= <michal.karas@10clouds.com>
Date: Fri, 17 Apr 2020 12:23:15 +0200
Subject: [PATCH 02/11] wip add pretty form for values changed, type changed
 with tests

---
 deepdiff/diff.py        | 17 ++++++++++++++++-
 tests/test_diff_tree.py | 18 +++++++++++++++---
 2 files changed, 31 insertions(+), 4 deletions(-)

diff --git a/deepdiff/diff.py b/deepdiff/diff.py
index 85edf0c1..2a1c898c 100755
--- a/deepdiff/diff.py
+++ b/deepdiff/diff.py
@@ -722,7 +722,22 @@ def to_dict(self):
         return result
 
     def pretty_form(self):
-        pass
+        result = []
+        for key in self.tree.keys():
+            for item_key in self.tree[key]:
+                result += [pretty_print_diff(item_key)]
+
+        return '\n'.join(result)
+
+
+def pretty_print_diff(diff: DiffLevel):
+    if diff.report_type == "type_changes":
+        return f'Type of {diff.path(root="")} changed from {type(diff.t1).__name__} to {type(diff.t2).__name__}' \
+               f' and value changed from {str(diff.t1)} to {str(diff.t2)}'
+    elif diff.report_type == "values_changed":
+        return f'Value of {diff.path(root="")} changed from {str(diff.t1)} to {str(diff.t2)}'
+    else:
+        return ''
 
 
 if __name__ == "__main__":  # pragma: no cover
diff --git a/tests/test_diff_tree.py b/tests/test_diff_tree.py
index 43ab8006..10a318a6 100644
--- a/tests/test_diff_tree.py
+++ b/tests/test_diff_tree.py
@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 import pytest
 from deepdiff import DeepDiff
+from deepdiff.diff import pretty_print_diff
 from deepdiff.helper import pypy3, notpresent
 from deepdiff.model import DictRelationship, NonSubscriptableIterableRelationship
 
@@ -191,9 +192,20 @@ class TestDeepDiffPrettyForm:
 
     @pytest.mark.parametrize('t1, t2, changed_item, old_type, new_type, old_val_displayed, new_val_displayed',
                              [
-                                 [{2: 2, 4: 4}, {2: 'b', 5: 5}, '[2]', 'int', 'str', '2', '"b"'],
+                                 [{2: 2, 4: 4}, {2: 'b', 4: 4}, '[2]', 'int', 'str', '2', 'b'],
                              ]
                              )
-    def test_pretty_form_type_and_value_changes(self, t1, t2, changed_item, old_type, new_type, old_val_displayed, new_val_displayed):
+    def test_pretty_print_diff_type_and_value_changes(self, t1, t2, changed_item, old_type, new_type, old_val_displayed,
+                                                      new_val_displayed):
         ddiff = DeepDiff(t1, t2, view='tree')
-        assert ddiff.pretty_form() == f'Type of {changed_item} changed from {old_type} to {new_type} and value changed from {old_val_displayed} to {new_val_displayed}'
+        result = pretty_print_diff(ddiff.tree['type_changes'].items[0])
+        assert result == f'Type of {changed_item} changed from {old_type} to {new_type} and value changed from {old_val_displayed} to {new_val_displayed}'
+
+    def test_pretty_form_method(self):
+        t1 = {2: 2, 4: 4}
+        t2 = {2: 'b', 4: 5}
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = ddiff.pretty_form()
+        expected = ("Value of [4] changed from 4 to 5"
+                    "\nType of [2] changed from int to str and value changed from 2 to b")
+        assert result == expected

From 9f2540e6553cda71b57ed8eb4750a8999d9521db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Kara=C5=9B?= <michal.karas@10clouds.com>
Date: Sun, 19 Apr 2020 16:39:27 +0200
Subject: [PATCH 03/11] wip pretty form

---
 deepdiff/diff.py        | 15 +++++++-
 tests/test_diff_tree.py | 82 ++++++++++++++++++++++++++++++++++++++---
 2 files changed, 91 insertions(+), 6 deletions(-)

diff --git a/deepdiff/diff.py b/deepdiff/diff.py
index 2a1c898c..a6cfae94 100755
--- a/deepdiff/diff.py
+++ b/deepdiff/diff.py
@@ -723,7 +723,8 @@ def to_dict(self):
 
     def pretty_form(self):
         result = []
-        for key in self.tree.keys():
+        keys = sorted(self.tree.keys())  # sorting keys to guarantee constant order in Python<3.7
+        for key in keys:
             for item_key in self.tree[key]:
                 result += [pretty_print_diff(item_key)]
 
@@ -736,6 +737,18 @@ def pretty_print_diff(diff: DiffLevel):
                f' and value changed from {str(diff.t1)} to {str(diff.t2)}'
     elif diff.report_type == "values_changed":
         return f'Value of {diff.path(root="")} changed from {str(diff.t1)} to {str(diff.t2)}'
+    elif diff.report_type == "dictionary_item_added":
+        return f'Item {diff.path(root="")} added to dictionary.'
+    elif diff.report_type == "dictionary_item_removed":
+        return f'Item {diff.path(root="")} removed from dictionary.'
+    elif diff.report_type == "iterable_item_added":
+        return f'Item {diff.path(root="")} added to iterable.'
+    elif diff.report_type == "iterable_item_removed":
+        return f'Item {diff.path(root="")} removed from iterable.'
+    elif diff.report_type == "attribute_added":
+        return f'Attribute {diff.path(root="root")} added.'
+    elif diff.report_type == "attribute_removed":
+        return f'Attribute {diff.path(root="root")} removed.'
     else:
         return ''
 
diff --git a/tests/test_diff_tree.py b/tests/test_diff_tree.py
index 10a318a6..bb64ae0c 100644
--- a/tests/test_diff_tree.py
+++ b/tests/test_diff_tree.py
@@ -190,22 +190,94 @@ def test_adding_list_diff(self):
 class TestDeepDiffPrettyForm:
     """Tests for pretty_form() method of DeepDiff"""
 
-    @pytest.mark.parametrize('t1, t2, changed_item, old_type, new_type, old_val_displayed, new_val_displayed',
+    @pytest.mark.parametrize('t1, t2, item_path, old_type, new_type, old_val_displayed, new_val_displayed',
                              [
                                  [{2: 2, 4: 4}, {2: 'b', 4: 4}, '[2]', 'int', 'str', '2', 'b'],
                              ]
                              )
-    def test_pretty_print_diff_type_and_value_changes(self, t1, t2, changed_item, old_type, new_type, old_val_displayed,
+    def test_pretty_print_diff_type_changes(self, t1, t2, item_path, old_type, new_type, old_val_displayed,
                                                       new_val_displayed):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['type_changes'].items[0])
-        assert result == f'Type of {changed_item} changed from {old_type} to {new_type} and value changed from {old_val_displayed} to {new_val_displayed}'
+        assert result == f'Type of {item_path} changed from {old_type} to {new_type} and value changed from {old_val_displayed} to {new_val_displayed}'
+
+    @pytest.mark.parametrize('t1, t2, item_path',
+                             [
+                                 [{2: 2, 4: 4}, {2: 2, 4: 4, 5: 5}, '[5]'],
+                             ]
+                             )
+    def test_pretty_print_diff_dictionary_item_added(self, t1, t2, item_path):
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = pretty_print_diff(ddiff.tree['dictionary_item_added'].items[0])
+        assert result == f'Item {item_path} added to dictionary.'
+
+    @pytest.mark.parametrize('t1, t2, item_path',
+                             [
+                                 [{2: 2, 4: 4}, {2: 2}, '[4]'],
+                             ]
+                             )
+    def test_pretty_print_diff_dictionary_item_removed(self, t1, t2, item_path):
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = pretty_print_diff(ddiff.tree['dictionary_item_removed'].items[0])
+        assert result == f'Item {item_path} removed from dictionary.'
+
+    @pytest.mark.parametrize('t1, t2, item_path, old_val_displayed, new_val_displayed',
+                             [
+                                 [{2: 2, 4: 4}, {2: 3, 4: 4}, '[2]', '2', '3'],
+                             ]
+                             )
+    def test_pretty_print_diff_values_changed(self, t1, t2, item_path, old_val_displayed, new_val_displayed):
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = pretty_print_diff(ddiff.tree['values_changed'].items[0])
+        assert result == f'Value of {item_path} changed from {old_val_displayed} to {new_val_displayed}'
+
+    @pytest.mark.parametrize('t1, t2, item_path',
+                             [
+                                 [[1, 2, 3], [1, 2, 3, 4], '[3]'],
+                             ]
+                             )
+    def test_pretty_print_diff_iterable_item_added(self, t1, t2, item_path):
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = pretty_print_diff(ddiff.tree['iterable_item_added'].items[0])
+        assert result == f'Item {item_path} added to iterable.'
+
+    @pytest.mark.parametrize('t1, t2, item_path',
+                             [
+                                 [[1, 2, 3], [1, 2], '[2]'],
+                             ]
+                             )
+    def test_pretty_print_diff_iterable_item_removed(self, t1, t2, item_path):
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = pretty_print_diff(ddiff.tree['iterable_item_removed'].items[0])
+        assert result == f'Item {item_path} removed from iterable.'
+
+    @pytest.mark.parametrize('t1, t2, item_path',
+                             [
+                                 [[1, 2, 3], [1, 2], 'root.two'],
+                             ]
+                             )
+    def test_pretty_print_diff_attribute_added(self, t1, t2, item_path):
+        cls = self.get_testing_class()
+        t1 = cls()
+        t2 = cls()
+        t2.two = 2
+
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = pretty_print_diff(ddiff.tree['attribute_added'].items[0])
+        assert result == f'Attribute {item_path} added.'
 
     def test_pretty_form_method(self):
         t1 = {2: 2, 4: 4}
         t2 = {2: 'b', 4: 5}
         ddiff = DeepDiff(t1, t2, view='tree')
         result = ddiff.pretty_form()
-        expected = ("Value of [4] changed from 4 to 5"
-                    "\nType of [2] changed from int to str and value changed from 2 to b")
+        expected = ("Type of [2] changed from int to str and value changed from 2 to b"
+                    "\nValue of [4] changed from 4 to 5")
         assert result == expected
+
+    @staticmethod
+    def get_testing_class():
+        class TestingClass:
+            one = 1
+
+        return TestingClass

From 2b5fafb4fc7b22b9b8043d57ecdb1de51b9f9c20 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Kara=C5=9B?= <michal.karas@10clouds.com>
Date: Mon, 20 Apr 2020 06:30:15 +0200
Subject: [PATCH 04/11] wip add all single prints with tests

---
 deepdiff/diff.py        |  6 ++++++
 tests/test_diff_tree.py | 45 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+)

diff --git a/deepdiff/diff.py b/deepdiff/diff.py
index a6cfae94..fe93b68e 100755
--- a/deepdiff/diff.py
+++ b/deepdiff/diff.py
@@ -749,6 +749,12 @@ def pretty_print_diff(diff: DiffLevel):
         return f'Attribute {diff.path(root="root")} added.'
     elif diff.report_type == "attribute_removed":
         return f'Attribute {diff.path(root="root")} removed.'
+    elif diff.report_type == "set_item_added":
+        return f'Item [{str(diff.t2)}] added to set.'
+    elif diff.report_type == "set_item_removed":
+        return f'Item [{str(diff.t1)}] removed from set.'
+    elif diff.report_type == "repetition_change":
+        return f'Repetition change for item {diff.path(root="")}.'
     else:
         return ''
 
diff --git a/tests/test_diff_tree.py b/tests/test_diff_tree.py
index bb64ae0c..e8f6a9ec 100644
--- a/tests/test_diff_tree.py
+++ b/tests/test_diff_tree.py
@@ -266,6 +266,51 @@ def test_pretty_print_diff_attribute_added(self, t1, t2, item_path):
         result = pretty_print_diff(ddiff.tree['attribute_added'].items[0])
         assert result == f'Attribute {item_path} added.'
 
+    @pytest.mark.parametrize('t1, t2, item_path',
+                             [
+                                 [[1, 2, 3], [1, 2], 'root.two'],
+                             ]
+                             )
+    def test_pretty_print_diff_attribute_removed(self, t1, t2, item_path):
+        cls = self.get_testing_class()
+        t1 = cls()
+        t1.two = 2
+        t2 = cls()
+
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = pretty_print_diff(ddiff.tree['attribute_removed'].items[0])
+        assert result == f'Attribute {item_path} removed.'
+
+    @pytest.mark.parametrize('t1, t2, item_path',
+                             [
+                                 [{1, 2}, {1, 2, 3}, '[3]'],
+                             ]
+                             )
+    def test_pretty_print_diff_set_item_added(self, t1, t2, item_path):
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = pretty_print_diff(ddiff.tree['set_item_added'].items[0])
+        assert result == f'Item {item_path} added to set.'
+
+    @pytest.mark.parametrize('t1, t2, item_path',
+                             [
+                                 [{1, 2, 3}, {1, 2}, '[3]'],
+                             ]
+                             )
+    def test_pretty_print_diff_set_item_removed(self, t1, t2, item_path):
+        ddiff = DeepDiff(t1, t2, view='tree')
+        result = pretty_print_diff(ddiff.tree['set_item_removed'].items[0])
+        assert result == f'Item {item_path} removed from set.'
+
+    @pytest.mark.parametrize('t1, t2, item_path',
+                             [
+                                 [[1, 2, 3, 2], [1, 2, 3], '[1]'],
+                             ]
+                             )
+    def test_pretty_print_diff_repetition_change(self, t1, t2, item_path):
+        ddiff = DeepDiff(t1, t2, view='tree', ignore_order=True, report_repetition=True)
+        result = pretty_print_diff(ddiff.tree['repetition_change'].items[0])
+        assert result == f'Repetition change for item {item_path}.'
+
     def test_pretty_form_method(self):
         t1 = {2: 2, 4: 4}
         t2 = {2: 'b', 4: 5}

From dfd4dd116e7dcb608498e21ae61dcd81efb68d85 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Kara=C5=9B?= <michal.karas@10clouds.com>
Date: Mon, 20 Apr 2020 06:50:43 +0200
Subject: [PATCH 05/11] add quotation marks to string values

---
 deepdiff/diff.py        | 23 ++++++++++++++++++-----
 tests/test_diff_tree.py | 41 ++++++++++++++++-------------------------
 2 files changed, 34 insertions(+), 30 deletions(-)

diff --git a/deepdiff/diff.py b/deepdiff/diff.py
index fe93b68e..f450f5c6 100755
--- a/deepdiff/diff.py
+++ b/deepdiff/diff.py
@@ -732,11 +732,24 @@ def pretty_form(self):
 
 
 def pretty_print_diff(diff: DiffLevel):
+    type_t1 = get_type(diff.t1).__name__
+    type_t2 = get_type(diff.t2).__name__
+
+    if type_t1 == "str":
+        val_t1 = f'"{str(diff.t1)}"'
+    else:
+        val_t1 = str(diff.t1)
+
+    if type_t2 == "str":
+        val_t2 = f'"{str(diff.t2)}"'
+    else:
+        val_t2 = str(diff.t2)
+
     if diff.report_type == "type_changes":
-        return f'Type of {diff.path(root="")} changed from {type(diff.t1).__name__} to {type(diff.t2).__name__}' \
-               f' and value changed from {str(diff.t1)} to {str(diff.t2)}'
+        return f'Type of {diff.path(root="")} changed from {type_t1} to {type_t2}' \
+               f' and value changed from {val_t1} to {val_t2}'
     elif diff.report_type == "values_changed":
-        return f'Value of {diff.path(root="")} changed from {str(diff.t1)} to {str(diff.t2)}'
+        return f'Value of {diff.path(root="")} changed from {val_t1} to {val_t2}'
     elif diff.report_type == "dictionary_item_added":
         return f'Item {diff.path(root="")} added to dictionary.'
     elif diff.report_type == "dictionary_item_removed":
@@ -750,9 +763,9 @@ def pretty_print_diff(diff: DiffLevel):
     elif diff.report_type == "attribute_removed":
         return f'Attribute {diff.path(root="root")} removed.'
     elif diff.report_type == "set_item_added":
-        return f'Item [{str(diff.t2)}] added to set.'
+        return f'Item [{val_t2}] added to set.'
     elif diff.report_type == "set_item_removed":
-        return f'Item [{str(diff.t1)}] removed from set.'
+        return f'Item [{val_t1}] removed from set.'
     elif diff.report_type == "repetition_change":
         return f'Repetition change for item {diff.path(root="")}.'
     else:
diff --git a/tests/test_diff_tree.py b/tests/test_diff_tree.py
index e8f6a9ec..052232ba 100644
--- a/tests/test_diff_tree.py
+++ b/tests/test_diff_tree.py
@@ -192,11 +192,11 @@ class TestDeepDiffPrettyForm:
 
     @pytest.mark.parametrize('t1, t2, item_path, old_type, new_type, old_val_displayed, new_val_displayed',
                              [
-                                 [{2: 2, 4: 4}, {2: 'b', 4: 4}, '[2]', 'int', 'str', '2', 'b'],
-                             ]
-                             )
+                                 [{2: 2, 4: 4}, {2: 'b', 4: 4}, '[2]', 'int', 'str', '2', '"b"'],
+                                 [[1, 2, 3], [1, '2', 3], '[1]', 'int', 'str', '2', '"2"'],
+                             ])
     def test_pretty_print_diff_type_changes(self, t1, t2, item_path, old_type, new_type, old_val_displayed,
-                                                      new_val_displayed):
+                                            new_val_displayed):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['type_changes'].items[0])
         assert result == f'Type of {item_path} changed from {old_type} to {new_type} and value changed from {old_val_displayed} to {new_val_displayed}'
@@ -204,8 +204,7 @@ def test_pretty_print_diff_type_changes(self, t1, t2, item_path, old_type, new_t
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
                                  [{2: 2, 4: 4}, {2: 2, 4: 4, 5: 5}, '[5]'],
-                             ]
-                             )
+                             ])
     def test_pretty_print_diff_dictionary_item_added(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['dictionary_item_added'].items[0])
@@ -214,8 +213,7 @@ def test_pretty_print_diff_dictionary_item_added(self, t1, t2, item_path):
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
                                  [{2: 2, 4: 4}, {2: 2}, '[4]'],
-                             ]
-                             )
+                             ])
     def test_pretty_print_diff_dictionary_item_removed(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['dictionary_item_removed'].items[0])
@@ -224,8 +222,8 @@ def test_pretty_print_diff_dictionary_item_removed(self, t1, t2, item_path):
     @pytest.mark.parametrize('t1, t2, item_path, old_val_displayed, new_val_displayed',
                              [
                                  [{2: 2, 4: 4}, {2: 3, 4: 4}, '[2]', '2', '3'],
-                             ]
-                             )
+                                 [['a', 'b', 'c'], ['a', 'b', 'd'], '[2]', '"c"', '"d"']
+                             ])
     def test_pretty_print_diff_values_changed(self, t1, t2, item_path, old_val_displayed, new_val_displayed):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['values_changed'].items[0])
@@ -234,8 +232,7 @@ def test_pretty_print_diff_values_changed(self, t1, t2, item_path, old_val_displ
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
                                  [[1, 2, 3], [1, 2, 3, 4], '[3]'],
-                             ]
-                             )
+                             ])
     def test_pretty_print_diff_iterable_item_added(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['iterable_item_added'].items[0])
@@ -244,8 +241,7 @@ def test_pretty_print_diff_iterable_item_added(self, t1, t2, item_path):
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
                                  [[1, 2, 3], [1, 2], '[2]'],
-                             ]
-                             )
+                             ])
     def test_pretty_print_diff_iterable_item_removed(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['iterable_item_removed'].items[0])
@@ -254,8 +250,7 @@ def test_pretty_print_diff_iterable_item_removed(self, t1, t2, item_path):
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
                                  [[1, 2, 3], [1, 2], 'root.two'],
-                             ]
-                             )
+                             ])
     def test_pretty_print_diff_attribute_added(self, t1, t2, item_path):
         cls = self.get_testing_class()
         t1 = cls()
@@ -269,8 +264,7 @@ def test_pretty_print_diff_attribute_added(self, t1, t2, item_path):
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
                                  [[1, 2, 3], [1, 2], 'root.two'],
-                             ]
-                             )
+                             ])
     def test_pretty_print_diff_attribute_removed(self, t1, t2, item_path):
         cls = self.get_testing_class()
         t1 = cls()
@@ -284,8 +278,7 @@ def test_pretty_print_diff_attribute_removed(self, t1, t2, item_path):
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
                                  [{1, 2}, {1, 2, 3}, '[3]'],
-                             ]
-                             )
+                             ])
     def test_pretty_print_diff_set_item_added(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['set_item_added'].items[0])
@@ -294,8 +287,7 @@ def test_pretty_print_diff_set_item_added(self, t1, t2, item_path):
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
                                  [{1, 2, 3}, {1, 2}, '[3]'],
-                             ]
-                             )
+                             ])
     def test_pretty_print_diff_set_item_removed(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['set_item_removed'].items[0])
@@ -304,8 +296,7 @@ def test_pretty_print_diff_set_item_removed(self, t1, t2, item_path):
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
                                  [[1, 2, 3, 2], [1, 2, 3], '[1]'],
-                             ]
-                             )
+                             ])
     def test_pretty_print_diff_repetition_change(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree', ignore_order=True, report_repetition=True)
         result = pretty_print_diff(ddiff.tree['repetition_change'].items[0])
@@ -316,7 +307,7 @@ def test_pretty_form_method(self):
         t2 = {2: 'b', 4: 5}
         ddiff = DeepDiff(t1, t2, view='tree')
         result = ddiff.pretty_form()
-        expected = ("Type of [2] changed from int to str and value changed from 2 to b"
+        expected = ('Type of [2] changed from int to str and value changed from 2 to "b"'
                     "\nValue of [4] changed from 4 to 5")
         assert result == expected
 

From 0cbeff1c23e1313b83fa8f1bfcbcdf9ff4963f16 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Kara=C5=9B?= <michal.karas@10clouds.com>
Date: Mon, 20 Apr 2020 07:11:52 +0200
Subject: [PATCH 06/11] refactor pretty_print_diff

---
 deepdiff/diff.py | 56 ++++++++++++++++++------------------------------
 1 file changed, 21 insertions(+), 35 deletions(-)

diff --git a/deepdiff/diff.py b/deepdiff/diff.py
index f450f5c6..37e4416f 100755
--- a/deepdiff/diff.py
+++ b/deepdiff/diff.py
@@ -735,41 +735,27 @@ def pretty_print_diff(diff: DiffLevel):
     type_t1 = get_type(diff.t1).__name__
     type_t2 = get_type(diff.t2).__name__
 
-    if type_t1 == "str":
-        val_t1 = f'"{str(diff.t1)}"'
-    else:
-        val_t1 = str(diff.t1)
-
-    if type_t2 == "str":
-        val_t2 = f'"{str(diff.t2)}"'
-    else:
-        val_t2 = str(diff.t2)
-
-    if diff.report_type == "type_changes":
-        return f'Type of {diff.path(root="")} changed from {type_t1} to {type_t2}' \
-               f' and value changed from {val_t1} to {val_t2}'
-    elif diff.report_type == "values_changed":
-        return f'Value of {diff.path(root="")} changed from {val_t1} to {val_t2}'
-    elif diff.report_type == "dictionary_item_added":
-        return f'Item {diff.path(root="")} added to dictionary.'
-    elif diff.report_type == "dictionary_item_removed":
-        return f'Item {diff.path(root="")} removed from dictionary.'
-    elif diff.report_type == "iterable_item_added":
-        return f'Item {diff.path(root="")} added to iterable.'
-    elif diff.report_type == "iterable_item_removed":
-        return f'Item {diff.path(root="")} removed from iterable.'
-    elif diff.report_type == "attribute_added":
-        return f'Attribute {diff.path(root="root")} added.'
-    elif diff.report_type == "attribute_removed":
-        return f'Attribute {diff.path(root="root")} removed.'
-    elif diff.report_type == "set_item_added":
-        return f'Item [{val_t2}] added to set.'
-    elif diff.report_type == "set_item_removed":
-        return f'Item [{val_t1}] removed from set.'
-    elif diff.report_type == "repetition_change":
-        return f'Repetition change for item {diff.path(root="")}.'
-    else:
-        return ''
+    val_t1 = f'"{str(diff.t1)}"' if type_t1 == "str" else str(diff.t1)
+    val_t2 = f'"{str(diff.t2)}"' if type_t2 == "str" else str(diff.t2)
+
+    diff_path = diff.path(root='root') if diff.report_type in ['attribute_added', 'attribute_removed'] else diff.path(root='')
+
+    texts = {
+        "type_changes": "Type of {diff_path} changed from {type_t1} to {type_t2} and value changed from {val_t1} to {val_t2}",
+        "values_changed": "Value of {diff_path} changed from {val_t1} to {val_t2}",
+        "dictionary_item_added": "Item {diff_path} added to dictionary.",
+        "dictionary_item_removed": "Item {diff_path} removed from dictionary.",
+        "iterable_item_added": "Item {diff_path} added to iterable.",
+        "iterable_item_removed": "Item {diff_path} removed from iterable.",
+        "attribute_added": "Attribute {diff_path} added.",
+        "attribute_removed": "Attribute {diff_path} removed.",
+        "set_item_added": "Item [{val_t2}] added to set.",
+        "set_item_removed": "Item [{val_t1}] removed from set.",
+        "repetition_change": "Repetition change for item {diff_path}.",
+             }
+
+    return texts.get(diff.report_type, "").format(diff_path=diff_path, type_t1=type_t1, type_t2=type_t2, val_t1=val_t1,
+                                                  val_t2=val_t2)
 
 
 if __name__ == "__main__":  # pragma: no cover

From 7dbdf7db876a7e47eec72ec89ca7ef4643269add Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Kara=C5=9B?= <michal.karas@10clouds.com>
Date: Mon, 20 Apr 2020 07:44:59 +0200
Subject: [PATCH 07/11] add root to paths

---
 deepdiff/diff.py        |  6 +++---
 tests/test_diff_tree.py | 29 ++++++++++++++++-------------
 2 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/deepdiff/diff.py b/deepdiff/diff.py
index 37e4416f..5b3d4dff 100755
--- a/deepdiff/diff.py
+++ b/deepdiff/diff.py
@@ -738,7 +738,7 @@ def pretty_print_diff(diff: DiffLevel):
     val_t1 = f'"{str(diff.t1)}"' if type_t1 == "str" else str(diff.t1)
     val_t2 = f'"{str(diff.t2)}"' if type_t2 == "str" else str(diff.t2)
 
-    diff_path = diff.path(root='root') if diff.report_type in ['attribute_added', 'attribute_removed'] else diff.path(root='')
+    diff_path = diff.path(root='root')
 
     texts = {
         "type_changes": "Type of {diff_path} changed from {type_t1} to {type_t2} and value changed from {val_t1} to {val_t2}",
@@ -749,8 +749,8 @@ def pretty_print_diff(diff: DiffLevel):
         "iterable_item_removed": "Item {diff_path} removed from iterable.",
         "attribute_added": "Attribute {diff_path} added.",
         "attribute_removed": "Attribute {diff_path} removed.",
-        "set_item_added": "Item [{val_t2}] added to set.",
-        "set_item_removed": "Item [{val_t1}] removed from set.",
+        "set_item_added": "Item root[{val_t2}] added to set.",
+        "set_item_removed": "Item root[{val_t1}] removed from set.",
         "repetition_change": "Repetition change for item {diff_path}.",
              }
 
diff --git a/tests/test_diff_tree.py b/tests/test_diff_tree.py
index 052232ba..7ac4a770 100644
--- a/tests/test_diff_tree.py
+++ b/tests/test_diff_tree.py
@@ -121,6 +121,8 @@ def test_non_subscriptable_iterable_path(self):
         assert change.path() is None
         assert change.path(force='yes') == 'root(unrepresentable)'
         assert change.path(force='fake') == 'root[2]'
+        print(ddiff.pretty_form())
+        a="a"
 
     def test_significant_digits(self):
         ddiff = DeepDiff(
@@ -192,8 +194,9 @@ class TestDeepDiffPrettyForm:
 
     @pytest.mark.parametrize('t1, t2, item_path, old_type, new_type, old_val_displayed, new_val_displayed',
                              [
-                                 [{2: 2, 4: 4}, {2: 'b', 4: 4}, '[2]', 'int', 'str', '2', '"b"'],
-                                 [[1, 2, 3], [1, '2', 3], '[1]', 'int', 'str', '2', '"2"'],
+                                 [{2: 2, 4: 4}, {2: 'b', 4: 4}, 'root[2]', 'int', 'str', '2', '"b"'],
+                                 [[1, 2, 3], [1, '2', 3], 'root[1]', 'int', 'str', '2', '"2"'],
+                                 [[1, 2, 3], {1, 2, 3}, 'root', 'list', 'set', '[1, 2, 3]', '{1, 2, 3}']
                              ])
     def test_pretty_print_diff_type_changes(self, t1, t2, item_path, old_type, new_type, old_val_displayed,
                                             new_val_displayed):
@@ -203,7 +206,7 @@ def test_pretty_print_diff_type_changes(self, t1, t2, item_path, old_type, new_t
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
-                                 [{2: 2, 4: 4}, {2: 2, 4: 4, 5: 5}, '[5]'],
+                                 [{2: 2, 4: 4}, {2: 2, 4: 4, 5: 5}, 'root[5]'],
                              ])
     def test_pretty_print_diff_dictionary_item_added(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
@@ -212,7 +215,7 @@ def test_pretty_print_diff_dictionary_item_added(self, t1, t2, item_path):
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
-                                 [{2: 2, 4: 4}, {2: 2}, '[4]'],
+                                 [{2: 2, 4: 4}, {2: 2}, 'root[4]'],
                              ])
     def test_pretty_print_diff_dictionary_item_removed(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
@@ -221,8 +224,8 @@ def test_pretty_print_diff_dictionary_item_removed(self, t1, t2, item_path):
 
     @pytest.mark.parametrize('t1, t2, item_path, old_val_displayed, new_val_displayed',
                              [
-                                 [{2: 2, 4: 4}, {2: 3, 4: 4}, '[2]', '2', '3'],
-                                 [['a', 'b', 'c'], ['a', 'b', 'd'], '[2]', '"c"', '"d"']
+                                 [{2: 2, 4: 4}, {2: 3, 4: 4}, 'root[2]', '2', '3'],
+                                 [['a', 'b', 'c'], ['a', 'b', 'd'], 'root[2]', '"c"', '"d"']
                              ])
     def test_pretty_print_diff_values_changed(self, t1, t2, item_path, old_val_displayed, new_val_displayed):
         ddiff = DeepDiff(t1, t2, view='tree')
@@ -231,7 +234,7 @@ def test_pretty_print_diff_values_changed(self, t1, t2, item_path, old_val_displ
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
-                                 [[1, 2, 3], [1, 2, 3, 4], '[3]'],
+                                 [[1, 2, 3], [1, 2, 3, 4], 'root[3]'],
                              ])
     def test_pretty_print_diff_iterable_item_added(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
@@ -240,7 +243,7 @@ def test_pretty_print_diff_iterable_item_added(self, t1, t2, item_path):
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
-                                 [[1, 2, 3], [1, 2], '[2]'],
+                                 [[1, 2, 3], [1, 2], 'root[2]'],
                              ])
     def test_pretty_print_diff_iterable_item_removed(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
@@ -277,7 +280,7 @@ def test_pretty_print_diff_attribute_removed(self, t1, t2, item_path):
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
-                                 [{1, 2}, {1, 2, 3}, '[3]'],
+                                 [{1, 2}, {1, 2, 3}, 'root[3]'],
                              ])
     def test_pretty_print_diff_set_item_added(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
@@ -286,7 +289,7 @@ def test_pretty_print_diff_set_item_added(self, t1, t2, item_path):
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
-                                 [{1, 2, 3}, {1, 2}, '[3]'],
+                                 [{1, 2, 3}, {1, 2}, 'root[3]'],
                              ])
     def test_pretty_print_diff_set_item_removed(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
@@ -295,7 +298,7 @@ def test_pretty_print_diff_set_item_removed(self, t1, t2, item_path):
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
-                                 [[1, 2, 3, 2], [1, 2, 3], '[1]'],
+                                 [[1, 2, 3, 2], [1, 2, 3], 'root[1]'],
                              ])
     def test_pretty_print_diff_repetition_change(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree', ignore_order=True, report_repetition=True)
@@ -307,8 +310,8 @@ def test_pretty_form_method(self):
         t2 = {2: 'b', 4: 5}
         ddiff = DeepDiff(t1, t2, view='tree')
         result = ddiff.pretty_form()
-        expected = ('Type of [2] changed from int to str and value changed from 2 to "b"'
-                    "\nValue of [4] changed from 4 to 5")
+        expected = ('Type of root[2] changed from int to str and value changed from 2 to "b"'
+                    "\nValue of root[4] changed from 4 to 5")
         assert result == expected
 
     @staticmethod

From dc7f6a962574c93cff30e258a0fa133377105489 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Kara=C5=9B?= <michal.karas@10clouds.com>
Date: Mon, 20 Apr 2020 07:52:56 +0200
Subject: [PATCH 08/11] refactor tests

---
 tests/test_diff_tree.py | 52 +++++++++++++++++------------------------
 1 file changed, 21 insertions(+), 31 deletions(-)

diff --git a/tests/test_diff_tree.py b/tests/test_diff_tree.py
index 7ac4a770..18e97cb0 100644
--- a/tests/test_diff_tree.py
+++ b/tests/test_diff_tree.py
@@ -121,8 +121,6 @@ def test_non_subscriptable_iterable_path(self):
         assert change.path() is None
         assert change.path(force='yes') == 'root(unrepresentable)'
         assert change.path(force='fake') == 'root[2]'
-        print(ddiff.pretty_form())
-        a="a"
 
     def test_significant_digits(self):
         ddiff = DeepDiff(
@@ -192,6 +190,11 @@ def test_adding_list_diff(self):
 class TestDeepDiffPrettyForm:
     """Tests for pretty_form() method of DeepDiff"""
 
+    class TestingClass:
+        one = 1
+
+    testing_class = TestingClass
+
     @pytest.mark.parametrize('t1, t2, item_path, old_type, new_type, old_val_displayed, new_val_displayed',
                              [
                                  [{2: 2, 4: 4}, {2: 'b', 4: 4}, 'root[2]', 'int', 'str', '2', '"b"'],
@@ -250,33 +253,23 @@ def test_pretty_print_diff_iterable_item_removed(self, t1, t2, item_path):
         result = pretty_print_diff(ddiff.tree['iterable_item_removed'].items[0])
         assert result == f'Item {item_path} removed from iterable.'
 
-    @pytest.mark.parametrize('t1, t2, item_path',
-                             [
-                                 [[1, 2, 3], [1, 2], 'root.two'],
-                             ])
-    def test_pretty_print_diff_attribute_added(self, t1, t2, item_path):
-        cls = self.get_testing_class()
-        t1 = cls()
-        t2 = cls()
+    def test_pretty_print_diff_attribute_added(self):
+        t1 = self.testing_class()
+        t2 = self.testing_class()
         t2.two = 2
 
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['attribute_added'].items[0])
-        assert result == f'Attribute {item_path} added.'
+        assert result == 'Attribute root.two added.'
 
-    @pytest.mark.parametrize('t1, t2, item_path',
-                             [
-                                 [[1, 2, 3], [1, 2], 'root.two'],
-                             ])
-    def test_pretty_print_diff_attribute_removed(self, t1, t2, item_path):
-        cls = self.get_testing_class()
-        t1 = cls()
+    def test_pretty_print_diff_attribute_removed(self):
+        t1 = self.testing_class()
         t1.two = 2
-        t2 = cls()
+        t2 = self.testing_class()
 
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['attribute_removed'].items[0])
-        assert result == f'Attribute {item_path} removed.'
+        assert result == f'Attribute root.two removed.'
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
@@ -306,17 +299,14 @@ def test_pretty_print_diff_repetition_change(self, t1, t2, item_path):
         assert result == f'Repetition change for item {item_path}.'
 
     def test_pretty_form_method(self):
-        t1 = {2: 2, 4: 4}
-        t2 = {2: 'b', 4: 5}
+        t1 = {2: 2, 3: 3, 4: 4}
+        t2 = {2: 'b', 4: 5, 5: 5}
         ddiff = DeepDiff(t1, t2, view='tree')
         result = ddiff.pretty_form()
-        expected = ('Type of root[2] changed from int to str and value changed from 2 to "b"'
-                    "\nValue of root[4] changed from 4 to 5")
+        expected = (
+            'Item root[5] added to dictionary.'
+            '\nItem root[3] removed from dictionary.'
+            '\nType of root[2] changed from int to str and value changed from 2 to "b"'
+            '\nValue of root[4] changed from 4 to 5'
+        )
         assert result == expected
-
-    @staticmethod
-    def get_testing_class():
-        class TestingClass:
-            one = 1
-
-        return TestingClass

From e1d076ebfaf74aa1b9cd0987607cfc374dd0ee14 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Kara=C5=9B?= <michal.karas@10clouds.com>
Date: Mon, 20 Apr 2020 08:10:11 +0200
Subject: [PATCH 09/11] fix fullstops in pretty texts

---
 deepdiff/diff.py        | 4 ++--
 tests/test_diff_tree.py | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/deepdiff/diff.py b/deepdiff/diff.py
index 5b3d4dff..4f37675f 100755
--- a/deepdiff/diff.py
+++ b/deepdiff/diff.py
@@ -741,8 +741,8 @@ def pretty_print_diff(diff: DiffLevel):
     diff_path = diff.path(root='root')
 
     texts = {
-        "type_changes": "Type of {diff_path} changed from {type_t1} to {type_t2} and value changed from {val_t1} to {val_t2}",
-        "values_changed": "Value of {diff_path} changed from {val_t1} to {val_t2}",
+        "type_changes": "Type of {diff_path} changed from {type_t1} to {type_t2} and value changed from {val_t1} to {val_t2}.",
+        "values_changed": "Value of {diff_path} changed from {val_t1} to {val_t2}.",
         "dictionary_item_added": "Item {diff_path} added to dictionary.",
         "dictionary_item_removed": "Item {diff_path} removed from dictionary.",
         "iterable_item_added": "Item {diff_path} added to iterable.",
diff --git a/tests/test_diff_tree.py b/tests/test_diff_tree.py
index 18e97cb0..45d2aafd 100644
--- a/tests/test_diff_tree.py
+++ b/tests/test_diff_tree.py
@@ -205,7 +205,7 @@ def test_pretty_print_diff_type_changes(self, t1, t2, item_path, old_type, new_t
                                             new_val_displayed):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['type_changes'].items[0])
-        assert result == f'Type of {item_path} changed from {old_type} to {new_type} and value changed from {old_val_displayed} to {new_val_displayed}'
+        assert result == f'Type of {item_path} changed from {old_type} to {new_type} and value changed from {old_val_displayed} to {new_val_displayed}.'
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
@@ -233,7 +233,7 @@ def test_pretty_print_diff_dictionary_item_removed(self, t1, t2, item_path):
     def test_pretty_print_diff_values_changed(self, t1, t2, item_path, old_val_displayed, new_val_displayed):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['values_changed'].items[0])
-        assert result == f'Value of {item_path} changed from {old_val_displayed} to {new_val_displayed}'
+        assert result == f'Value of {item_path} changed from {old_val_displayed} to {new_val_displayed}.'
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
@@ -306,7 +306,7 @@ def test_pretty_form_method(self):
         expected = (
             'Item root[5] added to dictionary.'
             '\nItem root[3] removed from dictionary.'
-            '\nType of root[2] changed from int to str and value changed from 2 to "b"'
-            '\nValue of root[4] changed from 4 to 5'
+            '\nType of root[2] changed from int to str and value changed from 2 to "b".'
+            '\nValue of root[4] changed from 4 to 5.'
         )
         assert result == expected

From 22294d3681ed7babeba4d0e5c74b231440a3de3e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Kara=C5=9B?= <michal.karas@10clouds.com>
Date: Tue, 21 Apr 2020 07:44:06 +0200
Subject: [PATCH 10/11] fix intendation

---
 deepdiff/diff.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/deepdiff/diff.py b/deepdiff/diff.py
index 670323b3..2cc00ad0 100755
--- a/deepdiff/diff.py
+++ b/deepdiff/diff.py
@@ -774,13 +774,13 @@ def to_delta_dict(self, directed=True):
         if self.ignore_order:
             result['ignore_order'] = True
         return result
-      
+
     def pretty_form(self):
-      result = []
-      keys = sorted(self.tree.keys())  # sorting keys to guarantee constant order in Python<3.7
-      for key in keys:
-          for item_key in self.tree[key]:
-              result += [pretty_print_diff(item_key)]
+        result = []
+        keys = sorted(self.tree.keys())  # sorting keys to guarantee constant order in Python<3.7
+        for key in keys:
+            for item_key in self.tree[key]:
+                result += [pretty_print_diff(item_key)]
 
         return '\n'.join(result)
 
@@ -806,11 +806,12 @@ def pretty_print_diff(diff: DiffLevel):
         "set_item_added": "Item root[{val_t2}] added to set.",
         "set_item_removed": "Item root[{val_t1}] removed from set.",
         "repetition_change": "Repetition change for item {diff_path}.",
-             }
+    }
 
     return texts.get(diff.report_type, "").format(diff_path=diff_path, type_t1=type_t1, type_t2=type_t2, val_t1=val_t1,
                                                   val_t2=val_t2)
 
+
 if __name__ == "__main__":  # pragma: no cover
     import doctest
     doctest.testmod()

From 432cfca3768de4ba413647b7e2791e6cd865df0d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Kara=C5=9B?= <michal.karas@10clouds.com>
Date: Thu, 23 Apr 2020 14:24:04 +0200
Subject: [PATCH 11/11] remove f-strings for python 3.5 compatibility

---
 deepdiff/diff.py        |  4 ++--
 tests/test_diff_tree.py | 20 ++++++++++----------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/deepdiff/diff.py b/deepdiff/diff.py
index 2cc00ad0..9e92168a 100755
--- a/deepdiff/diff.py
+++ b/deepdiff/diff.py
@@ -789,8 +789,8 @@ def pretty_print_diff(diff: DiffLevel):
     type_t1 = get_type(diff.t1).__name__
     type_t2 = get_type(diff.t2).__name__
 
-    val_t1 = f'"{str(diff.t1)}"' if type_t1 == "str" else str(diff.t1)
-    val_t2 = f'"{str(diff.t2)}"' if type_t2 == "str" else str(diff.t2)
+    val_t1 = '"{}"'.format(str(diff.t1)) if type_t1 == "str" else str(diff.t1)
+    val_t2 = '"{}"'.format(str(diff.t2)) if type_t2 == "str" else str(diff.t2)
 
     diff_path = diff.path(root='root')
 
diff --git a/tests/test_diff_tree.py b/tests/test_diff_tree.py
index 45d2aafd..4a03dbc9 100644
--- a/tests/test_diff_tree.py
+++ b/tests/test_diff_tree.py
@@ -205,7 +205,7 @@ def test_pretty_print_diff_type_changes(self, t1, t2, item_path, old_type, new_t
                                             new_val_displayed):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['type_changes'].items[0])
-        assert result == f'Type of {item_path} changed from {old_type} to {new_type} and value changed from {old_val_displayed} to {new_val_displayed}.'
+        assert result == 'Type of {} changed from {} to {} and value changed from {} to {}.'.format(item_path, old_type, new_type, old_val_displayed, new_val_displayed)
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
@@ -214,7 +214,7 @@ def test_pretty_print_diff_type_changes(self, t1, t2, item_path, old_type, new_t
     def test_pretty_print_diff_dictionary_item_added(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['dictionary_item_added'].items[0])
-        assert result == f'Item {item_path} added to dictionary.'
+        assert result == 'Item {} added to dictionary.'.format(item_path)
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
@@ -223,7 +223,7 @@ def test_pretty_print_diff_dictionary_item_added(self, t1, t2, item_path):
     def test_pretty_print_diff_dictionary_item_removed(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['dictionary_item_removed'].items[0])
-        assert result == f'Item {item_path} removed from dictionary.'
+        assert result == 'Item {} removed from dictionary.'.format(item_path)
 
     @pytest.mark.parametrize('t1, t2, item_path, old_val_displayed, new_val_displayed',
                              [
@@ -233,7 +233,7 @@ def test_pretty_print_diff_dictionary_item_removed(self, t1, t2, item_path):
     def test_pretty_print_diff_values_changed(self, t1, t2, item_path, old_val_displayed, new_val_displayed):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['values_changed'].items[0])
-        assert result == f'Value of {item_path} changed from {old_val_displayed} to {new_val_displayed}.'
+        assert result == 'Value of {} changed from {} to {}.'.format(item_path, old_val_displayed, new_val_displayed)
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
@@ -242,7 +242,7 @@ def test_pretty_print_diff_values_changed(self, t1, t2, item_path, old_val_displ
     def test_pretty_print_diff_iterable_item_added(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['iterable_item_added'].items[0])
-        assert result == f'Item {item_path} added to iterable.'
+        assert result == 'Item {} added to iterable.'.format(item_path)
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
@@ -251,7 +251,7 @@ def test_pretty_print_diff_iterable_item_added(self, t1, t2, item_path):
     def test_pretty_print_diff_iterable_item_removed(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['iterable_item_removed'].items[0])
-        assert result == f'Item {item_path} removed from iterable.'
+        assert result == 'Item {} removed from iterable.'.format(item_path)
 
     def test_pretty_print_diff_attribute_added(self):
         t1 = self.testing_class()
@@ -269,7 +269,7 @@ def test_pretty_print_diff_attribute_removed(self):
 
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['attribute_removed'].items[0])
-        assert result == f'Attribute root.two removed.'
+        assert result == 'Attribute root.two removed.'
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
@@ -278,7 +278,7 @@ def test_pretty_print_diff_attribute_removed(self):
     def test_pretty_print_diff_set_item_added(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['set_item_added'].items[0])
-        assert result == f'Item {item_path} added to set.'
+        assert result == 'Item {} added to set.'.format(item_path)
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
@@ -287,7 +287,7 @@ def test_pretty_print_diff_set_item_added(self, t1, t2, item_path):
     def test_pretty_print_diff_set_item_removed(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree')
         result = pretty_print_diff(ddiff.tree['set_item_removed'].items[0])
-        assert result == f'Item {item_path} removed from set.'
+        assert result == 'Item {} removed from set.'.format(item_path)
 
     @pytest.mark.parametrize('t1, t2, item_path',
                              [
@@ -296,7 +296,7 @@ def test_pretty_print_diff_set_item_removed(self, t1, t2, item_path):
     def test_pretty_print_diff_repetition_change(self, t1, t2, item_path):
         ddiff = DeepDiff(t1, t2, view='tree', ignore_order=True, report_repetition=True)
         result = pretty_print_diff(ddiff.tree['repetition_change'].items[0])
-        assert result == f'Repetition change for item {item_path}.'
+        assert result == 'Repetition change for item {}.'.format(item_path)
 
     def test_pretty_form_method(self):
         t1 = {2: 2, 3: 3, 4: 4}