Add backend for population management

.github/workflows/ci.yaml

@@ -12,7 +12,6 @@ on:
 env:
   REPO_NAME: ${{ github.event.repository.name }}
 
-
 jobs:
   pre-commit:
     if: always()
@@ -98,16 +97,15 @@ jobs:
           pip install --upgrade pip
           pip install -r requirements.txt
           pip install pytest-github-actions-annotate-failures
-      
+
       - name: Install graphviz
         uses: tlylt/install-graphviz@v1
 
-
       - name: PyTest with code coverage
         continue-on-error: true
         run: |
           pytest --junitxml pytest.xml --cov=. --cov-report=term-missing --cov-report=xml --cov-branch | tee pytest-coverage.txt
-      
+
       - name: Upload Coverage Results txt
         if: always()
         uses: actions/upload-artifact@v3

pkg_api/connector.py

@@ -2,7 +2,7 @@
 import os
 from enum import Enum
 
-from rdflib import Graph
+from rdflib import Graph, Namespace
 from rdflib.query import Result
 
 from pkg_api.core.namespaces import PKGPrefixes
@@ -12,6 +12,7 @@
 # Method to execute the SPARQL query
 
 DEFAULT_STORE_PATH = "data/RDFStore"
+DEFAULT_PKG_NAMESPACE = Namespace("http://example.com/pkg")
 
 
 class RDFStore(Enum):

pkg_api/server/__init__.py

@@ -9,21 +9,21 @@
 from pkg_api.connector import DEFAULT_STORE_PATH
 from pkg_api.pkg import DEFAULT_VISUALIZATION_PATH
 from pkg_api.server.auth import AuthResource
-from pkg_api.server.facts_management import PersonalFactsResource
 from pkg_api.server.models import db
 from pkg_api.server.nl_processing import NLResource
 from pkg_api.server.pkg_exploration import PKGExplorationResource
 from pkg_api.server.service_management import ServiceManagementResource
+from pkg_api.server.statements_management import StatementsManagementResource
 
 
 def create_app(testing: bool = False) -> Flask:
-    """Create the Flask app and add the API resources.
+    """Creates the Flask app and add the API resources.
 
     Args:
         testing: Enable testing mode. Defaults to False.
 
     Returns:
-        The Flask app.
+        Flask app.
     """
     app = Flask(__name__)
 
@@ -47,7 +47,7 @@ def create_app(testing: bool = False) -> Flask:
 
     api.add_resource(AuthResource, "/auth")
     api.add_resource(ServiceManagementResource, "/service")
-    api.add_resource(PersonalFactsResource, "/facts")
+    api.add_resource(StatementsManagementResource, "/statements")
     api.add_resource(PKGExplorationResource, "/explore")
     api.add_resource(NLResource, "/nl")
 

pkg_api/server/statements_management.py

@@ -0,0 +1,55 @@
+"""Statements Management API Resource."""
+
+from typing import Dict, Tuple
+
+from flask import request
+from flask_restful import Resource
+
+from pkg_api.server.utils import (
+    open_pkg,
+    parse_query_statement_population_data,
+)
+
+
+class StatementsManagementResource(Resource):
+    def post(self) -> Tuple[Dict[str, str], int]:
+        """Adds a statement to the PKG.
+
+        Returns:
+            A dictionary containing a message, and the status code.
+        """
+        data = request.json
+        try:
+            pkg = open_pkg(data)
+        except Exception as e:
+            return {"message": str(e)}, 400
+
+        try:
+            pkg_data = parse_query_statement_population_data(data)
+            pkg.add_statement(pkg_data)
+            pkg.close()
+        except Exception as e:
+            return {"message": str(e)}, 400
+
+        return {"message": "Statement added successfully"}, 200
+
+    def delete(self) -> Tuple[Dict[str, str], int]:
+        """Deletes a statement from the PKG.
+
+        Returns:
+            A dictionary containing a message, and the status code.
+        """
+        data = request.json
+        try:
+            pkg = open_pkg(data)
+        except Exception as e:
+            return {"message": str(e)}, 400
+
+        try:
+            pkg_data = parse_query_statement_population_data(data)
+            pkg.remove_statement(pkg_data)
+            pkg.close()
+        except Exception as e:
+            return {"message": str(e)}, 400
+
+        return {"message": "Statement removed successfully"}, 200

pkg_api/server/utils.py

@@ -1,10 +1,19 @@
 """Utility functions for the server."""
-from typing import Any, Dict
+
+import uuid
+from typing import Any, Dict, Union
 
 from flask import current_app
 
 from pkg_api.connector import RDFStore
-from pkg_api.core.pkg_types import URI
+from pkg_api.core.pkg_types import (
+    URI,
+    Concept,
+    PKGData,
+    Preference,
+    Triple,
+    TripleElement,
+)
 from pkg_api.pkg import PKG
 
 
@@ -14,6 +23,9 @@ def open_pkg(data: Dict[str, str]) -> PKG:
     Args:
         data: Request data.
 
+    Raises:
+        Exception: If the owner URI is missing.
+
     Returns:
         A PKG instance.
     """
@@ -43,3 +55,64 @@ def parse_query_request_data(data: Dict[str, Any]) -> str:
         A string containing SPARQL query.
     """
     return data.get("sparql_query", None)
+
+
+def _parse_triple_element(
+    element_data: Union[Dict[str, Any], str]
+) -> TripleElement:
+    """Parses a triple element received from HTTP request.
+
+    Args:
+        element_data: Data sent with HTTP request.
+
+    Returns:
+        Triple element.
+    """
+    if element_data is not None:
+        value = (
+            element_data
+            if isinstance(element_data, str)
+            else element_data.get("value")
+        )
+        if isinstance(value, dict):
+            return TripleElement(value.get("description"), Concept(**value))
+        elif isinstance(value, str):
+            try:
+                return TripleElement(value, URI(value))
+            except Exception:
+                return TripleElement(value, None)
+
+    return None
+
+
+def parse_query_statement_population_data(data: Dict[str, Any]) -> PKGData:
+    """Parses the request data to execute SPARQL query.
+
+    Args:
+        data: Request data.
+
+    Returns:
+        Associated PKGData.
+    """
+    description = data.get("description", None)
+    if description is None:
+        raise Exception("Missing description")
+
+    # Parse triple elements
+    subject = _parse_triple_element(data.get("subject", None))
+    predicate = _parse_triple_element(data.get("predicate", None))
+    statement_object = _parse_triple_element(data.get("object", None))
+
+    # Parse preference
+    preference = data.get("preference", None)
+    if preference and -1.0 <= preference <= 1.0:
+        preference = Preference(statement_object, preference)
+    else:
+        preference = None
+
+    return PKGData(
+        id=uuid.uuid1(),
+        statement=description,
+        triple=Triple(subject, predicate, statement_object),
+        preference=preference,
+    )

tests/pkg_api/server/conftest.py

@@ -1,4 +1,5 @@
 """Fixtures for the pkg_api.server package."""
+
 import os
 
 import pytest
@@ -19,3 +20,7 @@ def client() -> Flask:
     yield client
     # Delete the test database
     os.remove(f"{app.instance_path}/test.sqlite")
+    # Delete turtle files
+    for file in os.listdir(f"{app.config['STORE_PATH']}"):
+        if file.endswith(".ttl"):
+            os.remove(f"{app.config['STORE_PATH']}/{file}")

tests/pkg_api/server/test_statement_management.py

@@ -0,0 +1,93 @@
+"""Tests for the population endpoint."""
+
+from typing import Any, Dict
+
+import pytest
+from flask import Flask
+
+from pkg_api.core.pkg_types import URI, PKGData, Triple, TripleElement
+from pkg_api.server.utils import open_pkg
+
+
+def test_statement_management_with_errors(client: Flask) -> None:
+    """Tests /statements endpoint with errors."""
+    response = client.post("/statements", json={})
+    assert response.status_code == 400
+    assert response.get_json() == {"message": "Missing owner URI"}
+
+    response = client.delete("/statements", json={})
+    assert response.status_code == 400
+    assert response.get_json() == {"message": "Missing owner URI"}
+
+
+@pytest.fixture
+def request_data() -> Dict[str, Any]:
+    """Returns request data."""
+    return {
+        "owner_uri": "http://example.org/pkg#test",
+        "owner_username": "test",
+        "description": "I like Tom Cruise",
+        "subject": "http://example.org/pkg#test",
+        "predicate": {"value": {"description": "like"}},
+        "object": "https://en.wikipedia.org/wiki/Tom_Cruise",
+    }
+
+
+def test_statement_management_post(
+    client: Flask, request_data: Dict[str, Any]
+) -> None:
+    """Tests POST /statements endpoint."""
+    response = client.post("/statements", json=request_data)
+    assert response.status_code == 200
+    assert response.get_json() == {"message": "Statement added successfully"}
+
+    with client.application.app_context():
+        pkg = open_pkg(request_data)
+        statements = pkg.get_statements(
+            PKGData(
+                id=None,
+                statement="I like Tom Cruise",
+                triple=Triple(
+                    None,
+                    None,
+                    TripleElement(
+                        "Tom Cruise",
+                        URI("https://en.wikipedia.org/wiki/Tom_Cruise"),
+                    ),
+                ),
+            )
+        )
+        assert "I like Tom Cruise" in [
+            statement.statement for statement in statements
+        ]
+        pkg.close()
+
+
+def test_statement_management_delete(
+    client: Flask, request_data: Dict[str, Any]
+) -> None:
+    """Tests DELETE /statements endpoint."""
+    response = client.delete("/statements", json=request_data)
+    assert response.status_code == 200
+    assert response.get_json() == {"message": "Statement removed successfully"}
+
+    with client.application.app_context():
+        pkg = open_pkg(request_data)
+        statements = pkg.get_statements(
+            PKGData(
+                id=None,
+                statement="I like Tom Cruise",
+                triple=Triple(
+                    None,
+                    None,
+                    TripleElement(
+                        "Tom Cruise",
+                        URI("https://en.wikipedia.org/wiki/Tom_Cruise"),
+                    ),
+                ),
+            )
+        )
+        assert "I like Tom Cruise" not in [
+            statement.statement for statement in statements
+        ]
+        pkg.close()