Bug fixes and recursive searching for all matches (#2)

This implements:

- a feature to search all fitting matches 
  recursively
- an endpoint `get_all_matches` of the server
- a bug fix, changing the listen address from 
  `127.0.0.1` to `0.0.0.0` to work inside of 
  docker networks
- a bug fix, to not empty the matches list and 
  actually return all relevant matches

Author: dxvidnrt

README.md

@@ -9,5 +9,5 @@ using Python.
 docker build -t semantic_matching_service .
 ```
 ```commandline
-docker run -p 8000:8000 semantic_matching_service
+docker run -d -p 8000:8000 semantic_matching_service
 ```

config.ini.default

@@ -1,4 +1,8 @@
 [SERVICE]
 endpoint=http://127.0.0.1
 port=8000
-equivalence_table_file=./data/equivalence_table.json
+equivalence_table_file=./data/equivalence_table.json
+
+[RESOLVER]
+endpoint=http://semantic_id_resolver
+port=8125

dockerfile

@@ -1,6 +1,9 @@
 # Use the official Alpine Linux as the base image
 FROM python:3.9-alpine
 
+# Install Git
+RUN apk update && apk add --no-cache git
+
 # Set the working directory in the container
 WORKDIR /app
 
@@ -13,6 +16,9 @@ COPY . .
 # Install Python dependencies
 RUN pip install --no-cache-dir -r requirements.txt
 
+# Set PYTHONPATH to the app directory
+ENV PYTHONPATH=/app
+
 # Expose the port that FastAPI will run on
 EXPOSE 8000
 

semantic_matcher/model.py

@@ -22,7 +22,8 @@ class EquivalenceTable(BaseModel):
 
     def add_semantic_match(self, match: SemanticMatch) -> None:
         if self.matches.get(match.base_semantic_id) is not None:
-            self.matches[match.base_semantic_id].append(match)
+            if match not in self.matches[match.base_semantic_id]:
+                self.matches[match.base_semantic_id].append(match)
         else:
             self.matches[match.base_semantic_id] = [match]
 
@@ -32,16 +33,31 @@ def remove_semantic_match(self, match: SemanticMatch) -> None:
             if len(self.matches.get(match.base_semantic_id)) == 0:
                 self.matches.pop(match.base_semantic_id)
 
+    def remove_all_semantic_matches(self):
+        self.matches.clear()
+
     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 []
+        matching_result = []
         for match in equivalence_table_result:
-            matching_result = []
             if match.score > score_limit:
                 matching_result.append(match)
+                rec_result = self.get_local_matches(match.match_semantic_id, score_limit/match.score)
+                for rec_match in rec_result:
+                    rec_match.base_semantic_id = match.base_semantic_id
+                    rec_match.score *= match.score
+                    if "path" not in rec_match.meta_information:
+                        rec_match.meta_information["path"] = []
+                    rec_match.meta_information["path"].insert(0, match.match_semantic_id)
+                if rec_result is not None:
+                    matching_result += rec_result
         return matching_result
 
+    def get_all_matches(self) -> List[SemanticMatch]:
+        return self.matches
+
     def to_file(self, filename: str) -> None:
         with open(filename, "w") as file:
             file.write(self.model_dump_json(indent=4))

semantic_matcher/service.py

@@ -3,8 +3,7 @@
 import requests
 from fastapi import APIRouter
 
-import model
-import service_model
+from semantic_matcher import model, service_model
 
 
 class SemanticMatchingService:
@@ -38,6 +37,12 @@ def __init__(
             equivalences that this :class:`~.SemanticMatchingService` contains.
         """
         self.router = APIRouter()
+
+        self.router.add_api_route(
+            "/all_matches",
+            self.get_all_matches,
+            methods=["GET"]
+        )
         self.router.add_api_route(
             "/get_matches",
             self.get_matches,
@@ -48,9 +53,24 @@ def __init__(
             self.post_matches,
             methods=["POST"]
         )
+        self.router.add_api_route(
+            "/clear",
+            self.remove_all_matches,
+            methods=["POST"]
+        )
         self.endpoint: str = endpoint
         self.equivalence_table: model.EquivalenceTable = equivalences
 
+    def get_all_matches(self):
+        """
+        Returns all matches stored in the equivalence table-
+        """
+        matches = self.equivalence_table.get_all_matches()
+        return matches
+
+    def remove_all_matches(self):
+        self.equivalence_table.remove_all_semantic_matches()
+
     def get_matches(
             self,
             request_body: service_model.MatchRequest
@@ -71,7 +91,12 @@ def get_matches(
         # Now look for remote matches:
         additional_remote_matches: List[model.SemanticMatch] = []
         for match in matches:
+            if match.base_semantic_id.split("/")[0] == match.match_semantic_id.split("/")[0]:
+                #match_id is local
+                continue
             remote_matching_service = self._get_matcher_from_semantic_id(match.match_semantic_id)
+            if remote_matching_service is None:
+                continue
             remote_matching_request = service_model.MatchRequest(
                 semantic_id=match.match_semantic_id,
                 # This is a simple "Ungleichung"
@@ -86,14 +111,14 @@ def get_matches(
                 name=request_body.name,
                 definition=request_body.definition
             )
-            new_matches_response = requests.get(remote_matching_service, data=remote_matching_request)
-            match_response: service_model.MatchesList = service_model.MatchesList.model_validate_json(
-                new_matches_response.json()
-            )
+            url = f"{remote_matching_service}/get_matches"
+            new_matches_response = requests.get(url, json=remote_matching_request.dict())
+            match_response = service_model.MatchesList.model_validate_json(new_matches_response.text)
             additional_remote_matches.extend(match_response.matches)
         # Finally, put all matches together and return
         matches.extend(additional_remote_matches)
-        return service_model.MatchesList(matches=matches)
+        res = service_model.MatchesList(matches=matches)
+        return res
 
     def post_matches(
             self,
@@ -109,7 +134,20 @@ def _get_matcher_from_semantic_id(self, semantic_id: str) -> str:
 
         :returns: The endpoint with which the `SemanticMatchingService` can be accessed
         """
-        return self.endpoint  # todo
+        request_body = {"semantic_id": semantic_id}
+        endpoint = config['RESOLVER']['endpoint']
+        port = config['RESOLVER'].getint('port')
+        url = f"{endpoint}:{port}/get_semantic_matching_service"
+        response = requests.get(url, json=request_body.dict())
+
+        # Check if the response is successful (status code 200)
+        if response.status_code == 200:
+            # Parse the JSON response and construct SMSResponse object
+            response_json = response.json()
+            response_endpoint = response_json['semantic_matching_service_endpoint']
+            return response_endpoint
+
+        return None
 
 
 if __name__ == '__main__':
@@ -142,4 +180,4 @@ def _get_matcher_from_semantic_id(self, semantic_id: str) -> str:
     APP.include_router(
         SEMANTIC_MATCHING_SERVICE.router
     )
-    uvicorn.run(APP, host="127.0.0.1", port=int(config["SERVICE"]["PORT"]))
+    uvicorn.run(APP, host="0.0.0.0", port=int(config["SERVICE"]["PORT"]))

semantic_matcher/service_model.py

@@ -2,7 +2,7 @@
 
 from pydantic import BaseModel
 
-import model
+from semantic_matcher import model
 
 
 class MatchRequest(BaseModel):