pl-dict-diff 0.0.1__py3-none-any.whl

inspire_dictdiffer/resolve.py

@@ -0,0 +1,153 @@
+# This file is part of Dictdiffer.
+#
+# Copyright (C) 2015 CERN.
+# Copyright (C) 2017 ETH Zurich, Swiss Data Science Center, Jiri Kuncar.
+#
+# Dictdiffer is free software; you can redistribute it and/or modify
+# it under the terms of the MIT License; see LICENSE file for more
+# details.
+
+"""Sub module to handle the conflict resolution."""
+
+from .utils import get_path
+
+
+class UnresolvedConflictsException(Exception):
+    """Exception raised in case of an unresolveable conflict.
+
+    Exception raised in case of conflicts, that can not be resolved using
+    the provided actions in the automated merging process.
+    """
+
+    def __init__(self, unresolved_conflicts):
+        """Initialize the UnresolvedConflictsException.
+
+        :param unresolved_conflicts: list of unresolved conflicts.
+                                     dictdiffer.conflict.Conflict objects.
+        """
+        self.message = (
+            "The unresolved conflicts are stored in the *content* "
+            "attribute of this exception or in the "
+            "*unresolved_conflicts* attribute of the "
+            "dictdiffer.merge.Merger object."
+        )
+        self.content = unresolved_conflicts
+
+    def __repr__(self):
+        """Return the object representation."""
+        return self.message
+
+    def __str__(self):
+        """Return the string representation."""
+        return self.message
+
+
+class NoFurtherResolutionException(Exception):
+    """Exception raised to stop the automated resolution process.
+
+    Raised in case that the automatic conflict resolution process should stop
+    trying more general keys.
+    """
+
+    pass
+
+
+class Resolver:
+    """Class handling the conflict resolution process.
+
+    Presents the given conflicts to actions designed to solve them.
+    """
+
+    def __init__(self, actions, additional_info=None):
+        """Initialize the Resolver.
+
+        :param action: dict object containing the necessary resolution
+                       functions
+        :param additional_info: any additional information required by the
+                                actions
+        """
+        self.actions = actions
+        self.additional_info = additional_info
+
+        self.unresolved_conflicts = []
+
+    def _auto_resolve(self, conflict):
+        """Try to auto resolve conflicts.
+
+        Method trying to auto resolve conflicts in case that the perform the
+        same amendment.
+        """
+        if conflict.first_patch == conflict.second_patch:
+            conflict.take = "f"
+            return True
+        return False
+
+    def _find_conflicting_path(self, conflict):
+        """Return the shortest path commown to two patches."""
+        p1p = get_path(conflict.first_patch)
+        p2p = get_path(conflict.second_patch)
+
+        # This returns the shortest path
+        return p1p if len(p1p) <= len(p2p) else p2p
+
+    def _consecutive_slices(self, iterable):
+        """Build a list of consecutive slices of a given path.
+
+        >>> r = Resolver(None, None)
+        >>> list(r._consecutive_slices([1, 2, 3]))
+        [[1, 2, 3], [1, 2], [1]]
+        """
+        return (iterable[:i] for i in reversed(range(1, len(iterable) + 1)))
+
+    def resolve_conflicts(self, first_patches, second_patches, conflicts):
+        """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
+        will strip the last element of the path and try again, until the
+        resolution is just not possible.
+
+        :param first_patches: list of dictdiffer.diff patches
+        :param second_patches: list of dictdiffer.diff patches
+        :param conflicts: list of Conflict objects
+        """
+        for conflict in conflicts:
+            conflict_path = self._find_conflicting_path(conflict)
+
+            if self._auto_resolve(conflict):
+                continue
+            # Let's do some cascading here
+            for sub_path in self._consecutive_slices(conflict_path):
+                try:
+                    if self.actions[sub_path](
+                        conflict, first_patches, second_patches, self.additional_info
+                    ):
+                        break
+                except NoFurtherResolutionException:
+                    self.unresolved_conflicts.append(conflict)
+                    break
+                except KeyError:
+                    pass
+            else:
+                # The conflict could not be resolved
+                self.unresolved_conflicts.append(conflict)
+
+        if self.unresolved_conflicts:
+            raise UnresolvedConflictsException(self.unresolved_conflicts)
+
+    def manual_resolve_conflicts(self, picks):
+        """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
+        Conflict objects.
+
+        :param picks: list of 'f' or 's' strings, utilizing the *take*
+                      parameter of each Conflict object
+        """
+        if len(picks) != len(self.unresolved_conflicts):
+            raise UnresolvedConflictsException(self.unresolved_conflicts)
+        for pick, conflict in zip(picks, self.unresolved_conflicts):
+            conflict.take = pick
+
+        self.unresolved_conflicts = []

inspire_dictdiffer/testing.py

@@ -0,0 +1,36 @@
+# This file is part of Dictdiffer.
+#
+# Copyright (C) 2021 CERN.
+#
+# Dictdiffer is free software; you can redistribute it and/or modify
+# it under the terms of the MIT License; see LICENSE file for more
+# details.
+"""Define helper functions for testing."""
+
+from pprint import pformat
+
+from . import diff
+
+
+def assert_no_diff(*args, **kwargs):
+    """Compare two dictionary/list/set objects and raise error on difference.
+
+    When there is a difference, this will print a formatted diff.
+    This is especially useful for pytest.
+
+    Usage example:
+
+        >>> from dictdiffer.testing import assert_no_diff
+        >>> result = {'a': 'b'}
+        >>> expected = {'a': 'c'}
+        >>> assert_no_diff(result, expected)
+        Traceback (most recent call last):
+          File "<stdin>", line 1, in <module>
+          File "<stdin>", line 14, in assert_no_diff
+        AssertionError: [('change', 'a', ('b', 'c'))]
+
+    :param args: Positional arguments to the ``diff`` function.
+    :param second: Named arguments to the ``diff`` function.
+    """
+    d = [d for d in diff(*args, **kwargs)]
+    assert not d, pformat(d)

inspire_dictdiffer/unify.py

@@ -0,0 +1,53 @@
+# This file is part of Dictdiffer.
+#
+# Copyright (C) 2015 CERN.
+#
+# Dictdiffer is free software; you can redistribute it and/or modify
+# it under the terms of the MIT License; see LICENSE file for more
+# details.
+
+"""Sub module to handle the unification of patches after the merge."""
+
+from .utils import get_path, nested_hash
+
+
+class Unifier:
+    """Class handling the unification process after the merge."""
+
+    def unify(self, first_patches, second_patches, conflicts):
+        """Unify two lists of patches into one.
+
+        Takes into account their appearance in the given list of conflicts.
+
+        :param first_patches: list of dictdiffer.diff patches
+        :param second_patches: list of dictdiffer.diff patches
+        :param conflicts: list of Conflict objects
+        """
+        self.unified_patches = []
+        self._build_index(conflicts)
+
+        sorted_patches = sorted(first_patches + second_patches, key=get_path)
+
+        for patch in sorted_patches:
+            conflict = self._index.get(nested_hash(patch))
+
+            # Apply only the patches that were taken as part of conflict
+            # resolution.
+            if conflict:
+                if conflict.take_patch() != patch:
+                    continue
+
+            self.unified_patches.append(patch)
+
+        return self.unified_patches
+
+    def _build_index(self, conflicts):
+        """Create a dictionary attribute mapping patches to conflicts.
+
+        Creates a dictionary attribute mapping the tuplefied version of each
+        patch to it's containing Conflict object.
+        """
+        self._index = {}
+        for conflict in conflicts:
+            self._index[nested_hash(conflict.first_patch)] = conflict
+            self._index[nested_hash(conflict.second_patch)] = conflict

inspire_dictdiffer/utils.py

@@ -0,0 +1,310 @@
+# This file is part of Dictdiffer.
+#
+# Copyright (C) 2015 CERN.
+# Copyright (C) 2017, 2019 ETH Zurich, Swiss Data Science Center, Jiri Kuncar.
+#
+# Dictdiffer is free software; you can redistribute it and/or modify
+# it under the terms of the MIT License; see LICENSE file for more
+# details.
+
+"""Utils gathers helper functions, classes for the dictdiffer module."""
+
+import sys
+
+from collections.abc import MutableMapping, MutableSequence
+from itertools import zip_longest
+
+EPSILON = sys.float_info.epsilon
+
+DICT_TYPES = (MutableMapping,)
+LIST_TYPES = (MutableSequence,)
+
+
+class RemovedObject:
+    """Removed object placeholder."""
+
+
+class WildcardDict(dict):
+    """Provide possibility to use special wildcard keys to access values.
+
+    Those wildcards are:
+        *:  wildcard for everything that follows
+        +:  wildcard for anything on the same path level
+    The intended use case of this are dictionaries, that utilize tuples as
+    keys.
+
+        >>> from dictdiffer.utils import WildcardDict
+        >>> w = WildcardDict({('foo', '*'): '* card',
+        ...                   ('banana', '+'): '+ card'})
+        >>> w[ ('foo', 'bar', 'baz') ]
+        '* card'
+        >>> w[ ('banana', 'apple') ]
+        '+ card'
+    """
+
+    def __init__(self, values=None):
+        """Set lookup key indices.
+
+        :param values: a dictionary
+        """
+        super().__init__()
+        self.star_keys = set()
+        self.plus_keys = set()
+
+        if values is not None:
+            for key, value in values.items():
+                self.__setitem__(key, value)
+
+    def __getitem__(self, key):
+        """Return the value corresponding to the key, regarding wildcards.
+
+        If the key doesn't exit it tries the '+' wildcard and then the
+        '*' wildcard.
+
+            >>> w = WildcardDict({('foo', '*'): '* card',
+            ...                   ('banana', '+'): '+ card'})
+            >>> w[ ('foo', 'bar') ]
+            '* card'
+            >>> w[ ('foo', 'bar', 'baz') ]
+            '* card'
+            >>> w[ ('banana', 'apple') ]
+            '+ card'
+            >>> w[ ('banana', 'apple', 'mango') ]
+            Traceback (most recent call last):
+                ...
+            KeyError
+        """
+        try:
+            return super().__getitem__(key)
+        except KeyError:
+            if key[:-1] in self.plus_keys:
+                return super().__getitem__(key[:-1] + ("+",))
+            for _key in [key[:-i] for i in range(1, len(key) + 1)]:
+                if _key in self.star_keys:
+                    return super().__getitem__(_key + ("*",))
+            raise KeyError
+
+    def __setitem__(self, key, value):
+        """Set the item for a given key (path)."""
+        super().__setitem__(key, value)
+
+        if key[-1] == "+":
+            self.plus_keys.add(key[:-1])
+        if key[-1] == "*":
+            self.star_keys.add(key[:-1])
+
+    def query_path(self, key):
+        """Return the key (path) that matches the queried key.
+
+        >>> w = WildcardDict({('foo', '*'): 'banana'})
+        >>> w.query_path(('foo', 'bar', 'baz'))
+        ('foo', '*')
+        """
+        if key in self:
+            return key
+        if key[:-1] in self.plus_keys:
+            return key[:-1] + ("+",)
+        for _key in [key[:-i] for i in range(1, len(key) + 1)]:
+            if _key in self.star_keys:
+                return _key + ("*",)
+
+        raise KeyError
+
+
+class PathLimit:
+    """Class to limit recursion depth during the dictdiffer.diff execution."""
+
+    def __init__(self, path_limits=[], final_key=None):
+        """Initialize a dictionary structure to determine a path limit.
+
+        :param path_limits: list of keys (tuples) determining the path limits
+        :param final_key: the key used in the dictionary to determin if the
+                          path is final
+
+            >>> pl = PathLimit( [('foo', 'bar')] , final_key='!@#$%FINAL')
+            >>> pl.dict
+            {'foo': {'bar': {'!@#$%FINAL': True}}}
+        """
+        self.final_key = final_key if final_key else "!@#$FINAL"
+        self.dict = {}
+        for key_path in path_limits:
+            containing = self.dict
+            for key in key_path:
+                try:
+                    containing = containing[key]
+                except KeyError:
+                    containing[key] = {}
+                    containing = containing[key]
+
+            containing[self.final_key] = True
+
+    def path_is_limit(self, key_path):
+        """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') )
+        True
+        """
+        containing = self.dict
+        for key in key_path:
+            try:
+                containing = containing[key]
+            except KeyError:
+                try:
+                    containing = containing["*"]
+                except KeyError:
+                    return False
+
+        return containing.get(self.final_key, False)
+
+
+def create_dotted_node(node):
+    """Create the *dotted node* notation for the dictdiffer.diff patches.
+
+    >>> create_dotted_node( ['foo', 'bar', 'baz'] )
+    'foo.bar.baz'
+    """
+    if all(map(lambda x: isinstance(x, str), node)):
+        return ".".join(node)
+    else:
+        return list(node)
+
+
+def get_path(patch):
+    """Return the path for a given dictdiffer.diff patch."""
+    if patch[1] != "":
+        keys = patch[1].split(".") if isinstance(patch[1], str) else patch[1]
+    else:
+        keys = []
+    keys = keys + [patch[2][0][0]] if patch[0] != "change" else keys
+    return tuple(keys)
+
+
+def is_super_path(path1, path2):
+    """Check if one path is the super path of the other.
+
+    Super path means, that the n values in tuple are equal to the first n of m
+    vales in tuple b.
+
+        >>> is_super_path( ('foo', 'bar'), ('foo', 'bar') )
+        True
+
+        >>> is_super_path( ('foo', 'bar'), ('foo', 'bar', 'baz') )
+        True
+
+        >>> is_super_path( ('foo', 'bar'), ('foo', 'apple', 'banana') )
+        False
+    """
+    return all(map(lambda x: x[0] == x[1] or x[0] is None, zip_longest(path1, path2)))
+
+
+def nested_hash(obj):
+    """Create a hash of nested, mutable data structures.
+
+    It shall be noted, that the uniqeness of those hashes in general cases is
+    not assured but it should be enough for the cases occurring during the
+    merging process.
+    """
+    try:
+        return hash(obj)
+    except TypeError:
+        if isinstance(obj, (list, tuple)):
+            return hash(tuple(map(nested_hash, obj)))
+        elif isinstance(obj, set):
+            return hash(tuple(map(nested_hash, sorted(obj))))
+        elif isinstance(obj, dict):
+            return hash(tuple(map(nested_hash, sorted(obj.items()))))
+
+
+def dot_lookup(source, lookup, parent=False):
+    """Allow you to reach dictionary items with string or list lookup.
+
+    Recursively find value by lookup key split by '.'.
+
+        >>> from dictdiffer.utils import dot_lookup
+        >>> dot_lookup({'a': {'b': 'hello'}}, 'a.b')
+        'hello'
+
+    If parent argument is True, returns the parent node of matched
+    object.
+
+        >>> dot_lookup({'a': {'b': 'hello'}}, 'a.b', parent=True)
+        {'b': 'hello'}
+
+    If node is empty value, returns the whole dictionary object.
+
+        >>> dot_lookup({'a': {'b': 'hello'}}, '')
+        {'a': {'b': 'hello'}}
+
+    """
+    if lookup is None or lookup == "" or lookup == []:
+        return source
+
+    value = source
+    if isinstance(lookup, str):
+        keys = lookup.split(".")
+    elif isinstance(lookup, list):
+        keys = lookup
+    else:
+        raise TypeError("lookup must be string or list")
+
+    if parent:
+        keys = keys[:-1]
+
+    for key in keys:
+        if isinstance(value, list):
+            key = int(key)
+        value = value[key]
+    return value
+
+
+def are_different(first, second, tolerance, absolute_tolerance=None):
+    """Check if 2 values are different.
+
+    In case of numerical values, the tolerance is used to check if the values
+    are different.
+    In all other cases, the difference is straight forward.
+    """
+    if first == second:
+        # values are same - simple case
+        return False
+
+    first_is_nan, second_is_nan = bool(first != first), bool(second != second)
+
+    if first_is_nan or second_is_nan:
+        # two 'NaN' values are not different (see issue #114)
+        return not (first_is_nan and second_is_nan)
+    elif isinstance(first, (int, float)) and isinstance(second, (int, float)):
+        # two numerical values are compared with tolerance
+        return not isclose(
+            first,
+            second,
+            rel_tol=tolerance or 0,
+            abs_tol=absolute_tolerance or 0,
+        )
+    # we got different values
+    return True
+
+
+def strip_removed_objects(obj):
+    """Strip all the values that are instances of ``RemovedObject``."""
+    if isinstance(obj, LIST_TYPES):
+        return [
+            strip_removed_objects(value)
+            for value in obj
+            if not isinstance(value, RemovedObject)
+        ]
+    if isinstance(obj, DICT_TYPES):
+        new_dict = {}
+        for key, value in obj.items():
+            if isinstance(value, RemovedObject):
+                continue
+            clean_value = strip_removed_objects(value)
+            new_dict[key] = clean_value
+        return new_dict
+    return obj
+
+
+def isclose(a, b, rel_tol=1e-09, abs_tol=0.0):
+    """Verify if two values are close to each other."""
+    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

inspire_dictdiffer/version.py

@@ -0,0 +1,4 @@
+# Keep this version synchronized with pyproject.toml using bump2version.
+"""Version information for dictdiffer package."""
+
+__version__ = "0.0.7"

pl_dict_diff-0.0.1.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: pl-dict-diff
+Version: 0.0.1
+Summary: Dictdiffer is a library that helps you to diff and patch dictionaries.
+License-Expression: MIT
+License-File: LICENSE
+Author: Invenio Collaboration
+Author-email: info@inveniosoftware.org
+Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Utilities
+Provides-Extra: all
+Provides-Extra: numpy
+Provides-Extra: tests
+Requires-Dist: numpy (>=2.4.6,<3) ; extra == "all"
+Requires-Dist: numpy (>=2.4.6,<3) ; extra == "numpy"
+Requires-Dist: pytest (>=9.1.1,<10) ; extra == "all"
+Requires-Dist: pytest (>=9.1.1,<10) ; extra == "tests"
+Project-URL: Homepage, https://github.com/inspirehep/dictdiffer
+Project-URL: Repository, https://github.com/inspirehep/dictdiffer
+Description-Content-Type: text/markdown
+
+
+# Dictdiffer
+Dictdiffer is a helper module that helps you to diff and patch dictionaries.
+
+## Installation
+Requires Python 3.11 or newer.
+
+Install using pip
+ ```bash
+pip install git+https://github.com/inspirehep/dictdiffer.git
+```
+
+## Usage
+Let's start with an example on how to find the diff between two dictionaries using :func:`.diff` method:
+
+```python
+from inspire_dictdiffer import diff, patch, swap, revert
+
+first = {
+	"title": "hello",
+	"fork_count": 20,
+	"stargazers": ["/users/20", "/users/30"],
+	"settings": {
+		"assignees": [100, 101, 201],
+	}
+}
+
+second = {
+	"title": "hellooo",
+	"fork_count": 20,
+	"stargazers": ["/users/20", "/users/30", "/users/40"],
+	"settings": {
+		"assignees": [100, 101, 202],
+	}
+}
+
+result = diff(first, second)
+
+assert list(result) == [
+	('change', ['settings', 'assignees', 2], (201, 202)),
+	('add', 'stargazers', [(2, '/users/40')]),
+	('change', 'title', ('hello', 'hellooo'))]
+
+```
+
+Now we can apply the diff result with `.patch()` method:
+
+```python
+result = diff(first, second)
+patched = patch(result, first)
+
+assert patched == second
+```
+
+Also we can swap the diff result with `.swap()` method:
+
+```python
+result = diff(first, second)
+swapped = swap(result)
+
+assert list(swapped) == [
+	('change', ['settings', 'assignees', 2], (202, 201)),
+	('remove', 'stargazers', [(2, '/users/40')]),
+	('change', 'title', ('hellooo', 'hello'))]
+```
+Let's revert the last changes:
+```python
+result = diff(first, second)
+reverted = revert(result, patched)
+assert reverted == first
+```
+
+A tolerance can be used to consider closed values as equal.
+The tolerance parameter only applies for int and float.
+Let's try with a tolerance of 10% with the values 10 and 10.5:
+```python
+first = {'a': 10.0}
+second = {'a': 10.5}
+result = diff(first, second, tolerance=0.1)
+
+assert list(result) == []
+```
+
+Now with a tolerance of 1%:
+```python
+result = diff(first, second, tolerance=0.01)
+
+assert list(result) == ('change', 'a', (10.0, 10.5))
+```
+## Testing
+Running the test suite is as simple as:
+```bash
+poetry install --with dev --extras numpy
+poetry run pytest
+```
+

pl_dict_diff-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+inspire_dictdiffer/__init__.py,sha256=5ML-eb_IdJVR3JPQ0cbw8mqJlUsyi0XnIoR-EZQczpw,15170
+inspire_dictdiffer/conflict.py,sha256=q9Ia9yNMo6_IBIiy62q8gJmEbP1bVVabUDandVMBgwM,2401
+inspire_dictdiffer/merge.py,sha256=04CaFpKJj4tM3j_NaYNoutZYdAX-IRuOf7kKMGZ3Ol0,5119
+inspire_dictdiffer/resolve.py,sha256=WRT5uaHbsz6dejTCZMvqwdaXRFg33VY-oUlhuUmuaoM,5373
+inspire_dictdiffer/testing.py,sha256=tOyY-8uu-sZ-do-mD8w7PZv-ksObohpnEsrELrG637o,1122
+inspire_dictdiffer/unify.py,sha256=l39HpLoI8aYv6LG62Gp39vdp6U1GvxeSvr7clZwscJE,1777
+inspire_dictdiffer/utils.py,sha256=Ia2R33-OUpsBl1yC9IDEIgYk7k_k_BYJ2ChEhJAgUoc,9562
+inspire_dictdiffer/version.py,sha256=gnhfK7jNsnB4dCOPVrnkLhkLHWUM6RZcGykwbNCvlHI,146
+pl_dict_diff-0.0.1.dist-info/licenses/LICENSE,sha256=H54Fs7mm-tJMxnRVV4vN_T6JsJolxFNppSVCA7vivdM,1398
+pl_dict_diff-0.0.1.dist-info/METADATA,sha256=q4B2_ajXRONIYzbymi4RICy7KIrD6VtXspxmI3czwcA,3244
+pl_dict_diff-0.0.1.dist-info/WHEEL,sha256=L-WvLdSBvJWHXv5zrQxDvNRnIgoBzLUpcbuiw19KCuQ,88
+pl_dict_diff-0.0.1.dist-info/RECORD,,