In-place patch/revert

dictdiffer/__init__.py

@@ -245,9 +245,19 @@ def check(key):
             yield CHANGE, dotted_node, (deepcopy(first), deepcopy(second))
 
 
-def patch(diff_result, destination):
-    """Patch the diff result to the old dictionary."""
-    destination = deepcopy(destination)
+def patch(diff_result, destination, in_place=False):
+    """Patch the diff result to the destination dictionary.
+
+    :param diff_result: Changes returned by ``diff``.
+    :param destination: Structure to apply the changes to.
+    :param in_place: By default, destination dictionary is deep copied
+                     before applying the patch, and the copy is returned.
+                     Setting ``in_place=True`` means that patch will apply
+                     the changes directly to and return the destination
+                     structure.
+    """
+    if not in_place:
+        destination = deepcopy(destination)
 
     def add(node, changes):
         for key, value in changes:
@@ -330,7 +340,7 @@ def change(node, changes):
         yield swappers[action](node, change)
 
 
-def revert(diff_result, destination):
+def revert(diff_result, destination, in_place=False):
     """Call swap function to revert patched dictionary object.
 
     Usage example:
@@ -341,5 +351,12 @@ def revert(diff_result, destination):
         >>> revert(diff(first, second), second)
         {'a': 'b'}
 
+    :param diff_result: Changes returned by ``diff``.
+    :param destination: Structure to apply the changes to.
+    :param in_place: By default, destination dictionary is deep
+                     copied before being reverted, and the copy
+                     is returned. Setting ``in_place=True`` means
+                     that revert will apply the changes directly to
+                     and return the destination structure.
     """
-    return patch(swap(diff_result), destination)
+    return patch(swap(diff_result), destination, in_place)

dictdiffer/merge.py

@@ -37,7 +37,7 @@ class Merger(object):
     def __init__(self,
                  lca, first, second, actions,
                  path_limits=[], additional_info=None):
-        """Initialization of Merger object.
+        """Initialize the Merger object.
 
         :param lca: latest common ancestor of the two diverging data structures
         :param first: first data structure

dictdiffer/resolve.py

@@ -19,7 +19,7 @@ class UnresolvedConflictsException(Exception):
     """
 
     def __init__(self, unresolved_conflicts):
-        """Initialization of UnresolvedConflictsException.
+        """Initialize the UnresolvedConflictsException.
 
         :param unresolved_conflicts: list of unresolved conflicts.
                                      dictdiffer.conflict.Conflict objects.
@@ -31,11 +31,11 @@ def __init__(self, unresolved_conflicts):
         self.content = unresolved_conflicts
 
     def __repr__(self):
-        """String representation."""
+        """Return the object representation."""
         return self.message
 
     def __str__(self):
-        """String representation."""
+        """Return the string representation."""
         return self.message
 
 
@@ -56,7 +56,7 @@ class Resolver(object):
     """
 
     def __init__(self, actions, additional_info=None):
-        """Initialization of the Resolver.
+        """Initialize the Resolver.
 
         :param action: dict object containing the necessary resolution
                        functions
@@ -97,7 +97,7 @@ def _consecutive_slices(self, iterable):
         return (iterable[:i] for i in reversed(range(1, len(iterable)+1)))
 
     def resolve_conflicts(self, first_patches, second_patches, conflicts):
-        """Method to present the given conflicts to the actions.
+        """Convert the given conflicts to the actions.
 
         The method, will map the conflicts to an actions based on the path of
         the conflict. In case that the resolution attempt is not successful, it
@@ -134,7 +134,7 @@ def resolve_conflicts(self, first_patches, second_patches, conflicts):
             raise UnresolvedConflictsException(self.unresolved_conflicts)
 
     def manual_resolve_conflicts(self, picks):
-        """Method to manually resolve conflicts.
+        """Resolve manually the conflicts.
 
         This method resolves conflicts that could not be resolved in an
         automatic way. The picks parameter utilized the *take* attribute of the

dictdiffer/utils.py

@@ -16,7 +16,7 @@
 
 
 class WildcardDict(dict):
-    """A dictionary that provides special wildcard keys.
+    """Provide possibility to use special wildcard keys to access values.
 
     Those wildcards are:
         *:  wildcard for everything that follows
@@ -34,7 +34,7 @@ class WildcardDict(dict):
     """
 
     def __init__(self, values=None):
-        """A dictionary that provides special wildcard keys.
+        """Set lookup key indices.
 
         :param values: a dictionary
         """
@@ -130,7 +130,7 @@ def __init__(self, path_limits=[], final_key=None):
             containing[self.final_key] = True
 
     def path_is_limit(self, key_path):
-        """Querie the PathLimit object if the given key_path is a limit.
+        """Query the PathLimit object if the given key_path is a limit.
 
         >>> pl = PathLimit( [('foo', 'bar')] , final_key='!@#$%FINAL')
         >>> pl.path_is_limit( ('foo', 'bar') )

tests/test_dictdiffer.py

@@ -550,6 +550,18 @@ def test_dict_combined_key_type(self):
         assert second == patch(first_patch, first)
         assert first_patch[0] == list(diff(first, second))[0]
 
+    def test_in_place_patch_and_revert(self):
+        first = {'a': 1}
+        second = {'a': 2}
+        changes = list(diff(first, second))
+        patched_copy = patch(changes, first)
+        assert first != patched_copy
+        reverted_in_place = revert(changes, patched_copy, in_place=True)
+        assert first == reverted_in_place
+        assert patched_copy == reverted_in_place
+        patched_in_place = patch(changes, first, in_place=True)
+        assert first == patched_in_place
+
 
 class SwapperTests(unittest.TestCase):
     def test_addition(self):