Restructure and implement basic functionality

Author: s-heppner

requirements.txt

@@ -1,3 +1,4 @@
 fastapi>=0.95.0
 pydantic>=1.10
-uvicorn>=0.21.1
+uvicorn>=0.21.1
+requests>=2.31.0

semantic_matcher/examples/simple_example_equivalence_table.py

@@ -0,0 +1,38 @@
+from semantic_matcher.model import SemanticMatch, EquivalenceTable
+
+
+def return_simple_example_equivalence_table() -> EquivalenceTable:
+    """
+    Returns a simple equivalence table with three semantic matches
+    """
+    table = EquivalenceTable(matches={})
+    table.add_semantic_match(
+        SemanticMatch(
+            base_semantic_id="s-heppner.com/semanticID/one",
+            match_semantic_id="s-heppner.com/semanticID/1",
+            score=1.,
+            meta_information={"matchSource": "Defined by Sebastian Heppner"}
+        )
+    )
+    table.add_semantic_match(
+        SemanticMatch(
+            base_semantic_id="s-heppner.com/semanticID/two",
+            match_semantic_id="s-heppner.com/semanticID/2",
+            score=1.,
+            meta_information={"matchSource": "Defined by Sebastian Heppner"}
+        )
+    )
+    table.add_semantic_match(
+        SemanticMatch(
+            base_semantic_id="s-heppner.com/semanticID/one",
+            match_semantic_id="s-heppner.com/semanticID/two",
+            score=0.8,
+            meta_information={"matchSource": "Defined by Sebastian Heppner"}
+        )
+    )
+    return table
+
+
+if __name__ == '__main__':
+    e = return_simple_example_equivalence_table()
+    e.to_file("example_equivalence_table.json")

semantic_matcher/matcher.py semantic_matcher/model.pysemantic_matcher/matcher.py renamed to semantic_matcher/model.py

@@ -1,4 +1,4 @@
-from typing import Optional, Dict, List
+from typing import Dict, List
 
 from pydantic import BaseModel
 
@@ -22,15 +22,25 @@ class EquivalenceTable(BaseModel):
 
     def add_semantic_match(self, match: SemanticMatch) -> None:
         if self.matches.get(match.base_semantic_id) is not None:
-            self.equivalence_table[match.base_semantic_id].append(match)
+            self.matches[match.base_semantic_id].append(match)
         else:
-            self.equivalence_table[match.base_semantic_id] = [match]
+            self.matches[match.base_semantic_id] = [match]
 
     def remove_semantic_match(self, match: SemanticMatch) -> None:
-        if self.equivalence_table.get(match.base_semantic_id) is not None:
-            self.equivalence_table.get(match.base_semantic_id).remove(match)
-            if len(self.equivalence_table.get(match.base_semantic_id)) == 0:
-                self.equivalence_table.pop(match.base_semantic_id)
+        if self.matches.get(match.base_semantic_id) is not None:
+            self.matches.get(match.base_semantic_id).remove(match)
+            if len(self.matches.get(match.base_semantic_id)) == 0:
+                self.matches.pop(match.base_semantic_id)
+
+    def get_local_matches(self, semantic_id: str, score_limit: float) -> List[SemanticMatch]:
+        equivalence_table_result = self.matches.get(semantic_id)
+        if equivalence_table_result is None:
+            return []
+        for match in equivalence_table_result:
+            matching_result = []
+            if match.score > score_limit:
+                matching_result.append(match)
+        return matching_result
 
     def to_file(self, filename: str) -> None:
         with open(filename, "w") as file:
@@ -40,3 +50,4 @@ def to_file(self, filename: str) -> None:
     def from_file(cls, filename: str) -> "EquivalenceTable":
         with open(filename, "r") as file:
             return EquivalenceTable.model_validate_json(file.read())
+

semantic_matcher/service.py

@@ -1,23 +1,24 @@
 from typing import List, Optional
 
+import requests
 from fastapi import APIRouter
 
-import matcher
+import model
 import service_model
 
 
 class SemanticMatchingService:
     """
     Todo
     """
-    def __init__(self, semantic_matcher: matcher.SemanticMatcher):
+    def __init__(self, equivalences: model.EquivalenceTable):
         self.router = APIRouter()
         self.router.add_api_route(
             "/get_match",
             self.get_matches,
             methods=["GET"]
         )
-        self.semantic_matcher: matcher.SemanticMatcher = semantic_matcher
+        self.equivalence_table: model.EquivalenceTable = equivalences
 
     def get_matches(
             self,
@@ -29,14 +30,44 @@ def get_matches(
         Returns a matching score
         """
         # Try first local matching
-        matches: Optional[List[matcher.SemanticMatch]] = self.semantic_matcher.get_matches(request_body.semantic_id)
-        if matches is None:
-            matches = []
+        matches: List[model.SemanticMatch] = self.equivalence_table.get_local_matches(
+            semantic_id=request_body.semantic_id,
+            score_limit=request_body.score_limit
+        )
         # If the request asks us to only locally look, we're done already
         if request_body.local_only:
             return service_model.MatchResponse(matches=matches)
+        # Now look for remote matches:
+        additional_remote_matches: List[model.SemanticMatch] = []
+        for match in matches:
+            remote_matching_service = self._get_matcher_from_semantic_id(match.match_semantic_id)
+            remote_matching_request = service_model.MatchRequest(
+                semantic_id=match.match_semantic_id,
+                # This is a simple "Ungleichung"
+                # Unified score is multiplied: score(A->B) * score(B->C)
+                # This score should be larger or equal than the requested score_limit:
+                # score(A->B) * score(B->C) >= score_limit
+                # score(A->B) is well known, as it is the `match.score`
+                # => score(B->C) >= (score_limit/score(A->B))
+                score_limit=float(request_body.score_limit/match.score),
+                # If we already request a remote score, it does not make sense to choose `local_only`
+                local_only=False,
+                name=request_body.name,
+                definition=request_body.definition
+            )
+            new_matches_response = requests.get(remote_matching_service, data=remote_matching_request)
+            match_response: service_model.MatchResponse = service_model.MatchResponse.model_dump_json(
+                new_matches_response.json()
+            )
+            additional_remote_matches.extend(match_response.matches)
+        # Finally, put all matches together and return
+        matches.extend(additional_remote_matches)
+        return service_model.MatchResponse(matches=matches)
 
-        # Todo: There is a difference between searching and matching two given semantic IDs
+    def _get_matcher_from_semantic_id(self, semantic_id: str) -> str:
+        """
+        Finds the suiting `SemanticMatchingService` for the given `semantic_id`.
 
-    def _get_matcher_from_semantic_id(self, semantic_id: str):
-        pass
+        :returns: The endpoint with which the `SemanticMatchingService` can be accessed
+        """
+        return "Todo"  # todo

semantic_matcher/service_model.py

@@ -2,7 +2,7 @@
 
 from pydantic import BaseModel
 
-import matcher
+import model
 
 
 class MatchRequest(BaseModel):
@@ -15,10 +15,11 @@ class MatchRequest(BaseModel):
     :ivar definition: Optional definition of the resolved semantic ID for NLP matching
     """
     semantic_id: str
+    score_limit: float
     local_only: bool = True
     name: Optional[str] = None
     definition: Optional[str] = None
 
 
 class MatchResponse(BaseModel):
-    matches: List[matcher.SemanticMatch]
+    matches: List[model.SemanticMatch]