First working version, Add dockerfile

Author: s-heppner

README.md

@@ -0,0 +1,13 @@
+# Python Semantic Matching Service
+
+This is a proof-of-concept implementation of a semantic matching service
+using Python. 
+
+## Docker
+
+```commandline
+docker build -t semantic_matching_service .
+```
+```commandline
+docker run -p 8000:8000 semantic_matching_service
+```

config.ini.default

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

data/equivalence_table.json

@@ -0,0 +1,32 @@
+{
+    "matches": {
+        "s-heppner.com/semanticID/one": [
+            {
+                "base_semantic_id": "s-heppner.com/semanticID/one",
+                "match_semantic_id": "s-heppner.com/semanticID/1",
+                "score": 1.0,
+                "meta_information": {
+                    "matchSource": "Defined by Sebastian Heppner"
+                }
+            },
+            {
+                "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"
+                }
+            }
+        ],
+        "s-heppner.com/semanticID/two": [
+            {
+                "base_semantic_id": "s-heppner.com/semanticID/two",
+                "match_semantic_id": "s-heppner.com/semanticID/2",
+                "score": 1.0,
+                "meta_information": {
+                    "matchSource": "Defined by Sebastian Heppner"
+                }
+            }
+        ]
+    }
+}

dockerfile

@@ -0,0 +1,20 @@
+# Use the official Alpine Linux as the base image
+FROM python:3.9-alpine
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the package files to the working directory
+COPY . .
+
+# Install system dependencies
+# RUN apk --no-cache add build-base libffi-dev
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose the port that FastAPI will run on
+EXPOSE 8000
+
+# Command to run the FastAPI server
+CMD ["python", "semantic_matcher/service.py"]

semantic_matcher/examples/__init__.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import List
 
 import requests
 from fastapi import APIRouter
@@ -9,21 +9,52 @@
 
 class SemanticMatchingService:
     """
-    Todo
+    A Semantic Matching Service
+
+    It offers two operations:
+
+    :func:`~.SemanticMatchingService.post_matches` allows to post
+    :class:`model.SemanticMatch`es to the :class:`~.SemanticMatchingService`.
+
+    :func:`~.SemanticMatchingService.get_matches` lets users get the
+    :class:`model.SemanticMatch`es of the :class:`~.SemanticMatchingService`
+    and the respective remote :class:`~.SemanticMatchingService`s.
+
+    Additionally, the internal function
+    :func:`~.SemanticMatchingService._get_matcher_from_semantic_id` lets the
+    :class:`~.SemanticMatchingService` find the suiting remote
+    :class:`~.SemanticMatchingService`s to a given `semantic_id`.
     """
-    def __init__(self, equivalences: model.EquivalenceTable):
+    def __init__(
+            self,
+            endpoint: str,
+            equivalences: model.EquivalenceTable
+    ):
+        """
+        Initializer of :class:`~.SemanticMatchingService`
+
+        :ivar endpoint: The endpoint on which the service listens
+        :ivar equivalences: The :class:`model.EquivalenceTable` of the semantic
+            equivalences that this :class:`~.SemanticMatchingService` contains.
+        """
         self.router = APIRouter()
         self.router.add_api_route(
-            "/get_match",
+            "/get_matches",
             self.get_matches,
             methods=["GET"]
         )
+        self.router.add_api_route(
+            "/post_matches",
+            self.post_matches,
+            methods=["POST"]
+        )
+        self.endpoint: str = endpoint
         self.equivalence_table: model.EquivalenceTable = equivalences
 
     def get_matches(
             self,
             request_body: service_model.MatchRequest
-    ) -> service_model.MatchResponse:
+    ) -> service_model.MatchesList:
         """
         A query to match two SubmodelElements semantically.
 
@@ -36,7 +67,7 @@ def get_matches(
         )
         # If the request asks us to only locally look, we're done already
         if request_body.local_only:
-            return service_model.MatchResponse(matches=matches)
+            return service_model.MatchesList(matches=matches)
         # Now look for remote matches:
         additional_remote_matches: List[model.SemanticMatch] = []
         for match in matches:
@@ -56,18 +87,59 @@ def get_matches(
                 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(
+            match_response: service_model.MatchesList = service_model.MatchesList.model_validate_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)
+        return service_model.MatchesList(matches=matches)
+
+    def post_matches(
+            self,
+            request_body: service_model.MatchesList
+    ) -> None:
+        for match in request_body.matches:
+            self.equivalence_table.add_semantic_match(match)
+        # Todo: Figure out how to properly return 200
 
     def _get_matcher_from_semantic_id(self, semantic_id: str) -> str:
         """
         Finds the suiting `SemanticMatchingService` for the given `semantic_id`.
 
         :returns: The endpoint with which the `SemanticMatchingService` can be accessed
         """
-        return "Todo"  # todo
+        return self.endpoint  # todo
+
+
+if __name__ == '__main__':
+    import os
+    import configparser
+    from fastapi import FastAPI
+    import uvicorn
+
+    config = configparser.ConfigParser()
+    config.read([
+        os.path.abspath(os.path.join(os.path.dirname(__file__), "../config.ini.default")),
+        os.path.abspath(os.path.join(os.path.dirname(__file__), "../config.ini")),
+    ])
+
+    # Read in equivalence table
+    # Note, this construct takes the path in the config.ini relative to the
+    # location of the config.ini
+    EQUIVALENCES = model.EquivalenceTable.from_file(
+        filename=os.path.abspath(os.path.join(
+            os.path.dirname(__file__),
+            "..",
+            config["SERVICE"]["equivalence_table_file"]
+        ))
+    )
+    SEMANTIC_MATCHING_SERVICE = SemanticMatchingService(
+        endpoint=config["SERVICE"]["endpoint"],
+        equivalences=EQUIVALENCES
+    )
+    APP = FastAPI()
+    APP.include_router(
+        SEMANTIC_MATCHING_SERVICE.router
+    )
+    uvicorn.run(APP, host="127.0.0.1", port=int(config["SERVICE"]["PORT"]))

semantic_matcher/service.py

@@ -21,5 +21,5 @@ class MatchRequest(BaseModel):
     definition: Optional[str] = None
 
 
-class MatchResponse(BaseModel):
+class MatchesList(BaseModel):
     matches: List[model.SemanticMatch]