reworked merging and added strategies

Author: Michael Fritzsche

src/hermes/model/merge/action.py

@@ -7,7 +7,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Callable, Union
+from typing import TYPE_CHECKING, Any, Callable, Union
 from typing_extensions import Self
 
 from ..types import ld_dict, ld_list
@@ -76,9 +76,8 @@ def merge(
             This value will always be value.
         :rtype: ld_merge_list
         """
-        # If necessary, add the entry that data has been rejected.
-        if value != update:
-            target.reject(key, update)
+        # Add the entry that data has been rejected.
+        target.reject(key, update)
         # Return value unchanged.
         return value
 
@@ -111,8 +110,7 @@ def merge(
         :rtype: BASIC_TYPE | TIME_TYPE | ld_dict | ld_list
         """
         # If necessary, add the entry that data has been replaced.
-        if value != update:
-            target.replace(key, value)
+        target.replace(key, value)
         # Return the new value.
         return update
 
@@ -151,32 +149,21 @@ def merge(
 
 
 class Collect(MergeAction):
-    def __init__(
-        self: Self,
-        match: Union[
-            Callable[
-                [
-                    Union[BASIC_TYPE, TIME_TYPE, ld_merge_dict, ld_merge_list],
-                    Union[BASIC_TYPE, TIME_TYPE, ld_dict, ld_list]
-                ],
-                bool
-            ],
-            Callable[[ld_merge_dict, ld_dict], bool]
-        ]
-    ) -> None:
+    def __init__(self: Self, match: Callable[[Any, Any], bool], reject_incoming: bool = True) -> None:
         """
-        Set the match function for this collect merge action.
+        Set the match function for this collect merge action. And the behaivior for matches.
 
         :param match: The function used to evaluate equality while merging.
-        :type match: Callable[
-            [BASIC_TYPE | TIME_TYPE | ld_merge_dict | ld_merge_list, BASIC_TYPE | TIME_TYPE | ld_dict | ld_list],
-            bool
-        ] | Callable[[ld_merge_dict, ld_dict], bool]
+        :type match: Callable[[Any, Any], bool]
+        :param reject_incoming: If an incoming item matches an already collected one, if ``reject_incoming`` True,
+            the incoming item gets rejected, if ``reject_incoming`` False, the match of the incoming item gets replaced.
+        :type reject_incoming: bool
 
         :return:
         :rtype: None
         """
         self.match = match
+        self.reject_incoming = reject_incoming
 
     def merge(
         self: Self,
@@ -206,44 +193,31 @@ def merge(
 
         # iterate over all new items
         for update_item in update:
-            # If the current new item has no occurence in value (according to self.match) add it to value.
-            if not any(self.match(item, update_item) for item in value):
+            # Iterate over all items in value and if a match is found replace the first one or reject update_item.
+            for index, item in enumerate(value):
+                if self.match(item, update_item):
+                    if not self.reject_incoming:
+                        value[index] = update_item
+                    break
+            else:
+                # If the current new item has no occurence in value (according to self.match) add it to value.
                 value.append(update_item)
 
         return value
 
 
 class MergeSet(MergeAction):
-    def __init__(
-        self: Self,
-        match: Union[
-            Callable[
-                [
-                    Union[BASIC_TYPE, TIME_TYPE, ld_merge_dict, ld_merge_list],
-                    Union[BASIC_TYPE, TIME_TYPE, ld_dict, ld_list]
-                ],
-                bool
-            ],
-            Callable[[ld_merge_dict, ld_dict], bool]
-        ],
-        merge_items: bool = True
-    ) -> None:
+    def __init__(self: Self, match: Callable[[Any, Any], bool]) -> None:
         """
         Set the match function for this collect merge action.
 
         :param match: The function used to evaluate equality while merging.
-        :type match: Callable[
-            [BASIC_TYPE | TIME_TYPE | ld_merge_dict | ld_merge_list, BASIC_TYPE | TIME_TYPE | ld_dict | ld_list],
-            bool
-        ] | Callable[[ld_merge_dict, ld_dict], bool]
-        :param merge_items: Whether or to to merge similar items. (If false this is basically :class:`Concat`)
-        :type merge_items: bool
+        :type match: Callable[[ANy, Any], bool]
 
         :return:
         :rtype: None
         """
         self.match = match
-        self.merge_items = merge_items
 
     def merge(
         self: Self,
@@ -271,13 +245,19 @@ def merge(
         if not isinstance(update, (list, ld_list)):
             update = [update]
 
-        for item in update:
+        for update_item in update:
             # For each new item merge it into a similar item (according to match) inside target[key[-1]]
-            # (aka inside value) if such an item exists and merging is permitted.
+            # (aka inside value) if such an item exists.
             # Otherwise append it to target[key[-1]] (aka to value).
-            target_item = target.match(key[-1], item, self.match)
-            if target_item and self.merge_items:
-                target_item.update(item)
+            for index, item in enumerate(value):
+                if self.match(item, update_item):
+                    if isinstance(item, ld_dict) and isinstance(update_item, ld_dict):
+                        item.update(update_item)
+                    elif isinstance(item, ld_list) and isinstance(update_item, ld_list):
+                        self.merge(target, [*key, index], item, update_item)
+                    elif isinstance(item, (ld_dict,  ld_list)) or isinstance(update_item, (ld_dict, ld_list)):
+                        """ FIXME: log error """
+                    break
             else:
                 value.append(item)
         # Return the merged values.

src/hermes/model/merge/container.py

@@ -7,15 +7,15 @@
 
 from __future__ import annotations
 
-from typing import Callable, Union, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Union
 from typing_extensions import Self
 
 from ..types import ld_container, ld_context, ld_dict, ld_list
 from ..types.ld_container import (
     BASIC_TYPE, EXPANDED_JSON_LD_VALUE, JSON_LD_CONTEXT_DICT, JSON_LD_VALUE, TIME_TYPE
 )
 from ..types.pyld_util import bundled_loader
-from .strategy import CODEMETA_STRATEGY, PROV_STRATEGY, REPLACE_STRATEGY
+from .strategy import CODEMETA_STRATEGY, PROV_STRATEGY
 
 if TYPE_CHECKING:
     from .action import MergeAction
@@ -153,8 +153,7 @@ def __init__(
         self.update_context(ld_context.HERMES_PROV_CONTEXT)
 
         # add strategies
-        self.strategies = {**REPLACE_STRATEGY}
-        self.add_strategy(CODEMETA_STRATEGY)
+        self.strategies = {**CODEMETA_STRATEGY}
         self.add_strategy(PROV_STRATEGY)
 
     def update_context(
@@ -238,16 +237,7 @@ def match(
         self: Self,
         key: str,
         value: Union[BASIC_TYPE, TIME_TYPE, ld_dict, ld_list],
-        match: Union[
-            Callable[
-                [
-                    Union[BASIC_TYPE, TIME_TYPE, "ld_merge_dict", ld_merge_list],
-                    Union[BASIC_TYPE, TIME_TYPE, ld_dict, ld_list]
-                ],
-                bool
-            ],
-            Callable[["ld_merge_dict", ld_dict], bool]
-        ]
+        match: Callable[[Any, Any],  bool]
     ) -> Union[BASIC_TYPE, TIME_TYPE, "ld_merge_dict", ld_merge_list]:
         """
         Returns the first item in self[key] for which match(item, value) returns true.
@@ -260,10 +250,7 @@ def match(
         :param value: The value a match is searched for in self[key].
         :type value: Union[JSON_LD_VALUE, BASIC_TYPE, TIME_TYPE, ld_dict, ld_list]
         :param match: The method defining if two objects are a match.
-        :type match: Callable[
-            [BASIC_TYPE | TIME_TYPE | ld_merge_dict | ld_merge_list, BASIC_TYPE | TIME_TYPE | ld_dict | ld_list],
-            bool
-        ] | Callable[[ld_merge_dict, ld_dict], bool]
+        :type match: Callable[[Any, Any], bool]
 
         :return: The item in self[key] that is a match to value if one exists else None
         :rtype: BASIC_TYPE | TIME_TYPE | ld_merge_dict | ld_merge_list
@@ -317,6 +304,7 @@ def _add_related(
         :return:
         :rtype: None
         """
+        # FIXME: key not only string
         # make sure appending is possible
         self.emplace(rel)
         # append the new entry
@@ -338,6 +326,7 @@ def reject(self: Self, key: str, value: Union[BASIC_TYPE, TIME_TYPE, ld_dict, ld
         :return:
         :rtype: None
         """
+        # FIXME: key not only string
         self._add_related("hermes-rt:reject", key, value)
 
     def replace(self: Self, key: str, value: Union[BASIC_TYPE, TIME_TYPE, ld_dict, ld_list]) -> None:
@@ -356,4 +345,5 @@ def replace(self: Self, key: str, value: Union[BASIC_TYPE, TIME_TYPE, ld_dict, l
         :return:
         :rtype: None
         """
+        # FIXME: key not only string
         self._add_related("hermes-rt:replace", key, value)

src/hermes/model/merge/match.py

@@ -5,15 +5,10 @@
 # SPDX-FileContributor: Michael Meinel
 # SPDX-FileContributor: Michael Fritzsche
 
-from __future__ import annotations
-
-from typing import Any, Callable, TYPE_CHECKING
+from typing import Any, Callable
 
 from ..types import ld_dict
 
-if TYPE_CHECKING:
-    from .container import ld_merge_dict
-
 
 def match_equals(a: Any, b: Any) -> bool:
     """
@@ -30,26 +25,29 @@ def match_equals(a: Any, b: Any) -> bool:
     return a == b
 
 
-def match_keys(
-    *keys: list[str]
-) -> Callable[[ld_merge_dict, ld_dict], bool]:
+def match_keys(*keys: list[str], fall_back_to_equals: bool = False) -> Callable[[Any, Any], bool]:
     """
     Creates a function taking to parameters that returns true
     if both given parameter have at least one common key in the given list of keys
-    and for all common keys in the given list of keys the values of both objects are the same.
+    and for all common keys in the given list of keys the values of both objects are the same.<br>
+    If fall_back_to_equals is True, the returned function returns the value of normal == comparison
+    if no key from keys is in both objects.
 
     :param keys: The list of important keys for the comparison method.
     :type keys: list[str]
+    :param fall_back_to_equals: Whether or not a fall back option should be used.
+    :type fall_back_to_equals: bool
 
     :return: A function comparing two given objects values for the keys in keys.
     :rtype: Callable[[ld_merge_dict, ld_dict], bool]
     """
 
     # create and return the match function using the given keys
-    def match_func(left: ld_merge_dict, right: ld_dict) -> bool:
+    def match_func(left: Any, right: Any) -> bool:
         """
         Compares left to right by checking if a) they have at least one common key in a predetermined list of keys and
-        b) testing if both objects have equal values for all common keys in the predetermined key list.
+        b) testing if both objects have equal values for all common keys in the predetermined key list.<br>
+        It may fall back on == if no common key in the predetermined list of keys exists.
 
         :param left: The first object for the comparison.
         :type left: ld_merge_dict
@@ -59,12 +57,27 @@ def match_func(left: ld_merge_dict, right: ld_dict) -> bool:
         :return: The result of the comparison.
         :rtype: bool
         """
-        # TODO: This method maybe should try == comparison instead of returning false if active_keys == [].
+        if not (isinstance(left, ld_dict) and isinstance(right, ld_dict)):
+            return fall_back_to_equals and (left == right)
         # create a list of all common important keys
         active_keys = [key for key in keys if key in left and key in right]
+        # fall back to == if no active keys
+        if fall_back_to_equals and not active_keys:
+            return left == right
         # check if both objects have the same values for all active keys
         pairs = [(left[key] == right[key]) for key in active_keys]
         # return whether or not both objects had the same values for all active keys
         # and there was at least one active key
         return len(active_keys) > 0 and all(pairs)
     return match_func
+
+
+def match_person(left: Any, right: Any) -> bool:
+    if not (isinstance(left, ld_dict) and isinstance(right, ld_dict)):
+        return left == right
+    if "@id" in left and "@id" in right:
+        return left["@id"] == right["@id"]
+    if "schema:email" in left and "schema:email" in right:
+        mails_right = right["schema:email"]
+        return any((mail in mails_right) for mail in left["schema:email"])
+    return left == right