Feature/user problems

backend/langpro_annotator/urls.py

@@ -21,11 +21,14 @@
 
 from rest_framework import routers
 
+from problem.views.problem import ProblemView
+
 from .index import index
 from .proxy_frontend import proxy_frontend
 from .i18n import i18n
 
 api_router = routers.DefaultRouter()  # register viewsets with this router
+api_router.register(r"problem", ProblemView, basename="problem")
 
 
 if settings.PROXY_FRONTEND:

backend/problem/models.py

@@ -1,5 +1,4 @@
 from django.db import models
-from django.contrib.postgres.fields import ArrayField
 from django.db.models import QuerySet
 
 from problem.services import FracasData, SNLIData, SickData
@@ -58,30 +57,6 @@ def get_index(self, qs: QuerySet) -> int | None:
             logger.exception(f"Error getting index for problem {self.pk}: {e}")
             return None
 
-    def serialize(self) -> dict:
-        """
-        Serialize the Problem instance to a dictionary.
-        """
-
-        match self.dataset:
-            case self.Dataset.SICK:
-                serialized_extra_data = SickData.serialize(self.extra_data)
-            case self.Dataset.FRACAS:
-                serialized_extra_data = FracasData.serialize(self.extra_data)
-            case self.Dataset.SNLI:
-                serialized_extra_data = SNLIData.serialize(self.extra_data)
-            case _:
-                serialized_extra_data = {}
-
-        return {
-            "id": self.pk,
-            "dataset": self.dataset,
-            "premises": [premise.text for premise in self.premises.all()],
-            "hypothesis": self.hypothesis.text,
-            "entailmentLabel": self.entailment_label,
-            "extraData": serialized_extra_data,
-        }
-
 
 class KnowledgeBase(models.Model):
     class Relationship(models.TextChoices):
@@ -105,3 +80,11 @@ class Relationship(models.TextChoices):
         on_delete=models.CASCADE,
         related_name="knowledge_bases",
     )
+
+    def serialize(self) -> dict:
+        return {
+            "id": self.pk,
+            "entity1": self.entity1,
+            "entity2": self.entity2,
+            "relationship": self.relationship,
+        }

backend/problem/problem_details.py

@@ -1,4 +1,3 @@
-from typing import Optional
 from dataclasses import dataclass
 
 from django.http import QueryDict
@@ -10,16 +9,16 @@
 
 @dataclass
 class RelatedProblemIds:
-    first: Optional[str] = None
-    previous: Optional[str] = None
-    next: Optional[str] = None
-    last: Optional[str] = None
-    total: Optional[int] = None
+    first: int | None = None
+    previous: int | None = None
+    next: int | None = None
+    last: int | None = None
+    total: int | None = None
 
 
 def get_related_problem_ids(
     problem_qs: QuerySet[Problem],
-    problem_id: Optional[int],
+    problem_id: int | None = None,
 ) -> RelatedProblemIds:
     """
     Retrieves the IDs of surrounding problem objects
@@ -44,10 +43,10 @@ def get_related_problem_ids(
             problem = None
 
     return RelatedProblemIds(
-        first=str(first_problem.pk) if first_problem else None,
-        previous=str(previous_problem.pk) if previous_problem else None,
-        next=str(next_problem.pk) if next_problem else None,
-        last=str(last_problem.pk) if last_problem else None,
+        first=first_problem.pk if first_problem else None,
+        previous=previous_problem.pk if previous_problem else None,
+        next=next_problem.pk if next_problem else None,
+        last=last_problem.pk if last_problem else None,
         total=total,
     )
 
@@ -70,8 +69,9 @@ def get_filters(query_params: QueryDict) -> Q | None:
         filters &= Q(dataset=dataset)
     if entailment_label:
         filters &= Q(entailment_label=entailment_label)
-    if gold is not None:
-        raise NotImplementedError()
+    if gold:
+        logger.warning(f"Filtering by gold is not implemented yet.")
+        pass
     if text:
         filters &= Q(
             Q(hypothesis__text__icontains=text) | Q(premises__text__icontains=text)

backend/problem/serializers.py

@@ -0,0 +1,200 @@
+from rest_framework import serializers
+from problem.services import FracasData, SNLIData, SickData
+from problem.models import Problem, KnowledgeBase, Sentence
+
+
+class KnowledgeBaseSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = KnowledgeBase
+        fields = ["id", "entity1", "entity2", "relationship"]
+        extra_kwargs = {
+            # Without this, the relationship field is not required during validation.
+            "relationship": {"required": True},
+        }
+
+    def validate_id(self, value):
+        """Validate that the KnowledgeBase ID exists if provided."""
+        if value is not None:
+            if not KnowledgeBase.objects.filter(id=value).exists():
+                raise serializers.ValidationError(
+                    f"KnowledgeBase item with ID {value} does not exist."
+                )
+        return value
+
+    def create_for_problem(
+        self, validated_data: dict, problem: Problem
+    ) -> KnowledgeBase:
+        """Create a new KnowledgeBase item for a problem."""
+        return KnowledgeBase.objects.create(
+            **validated_data,
+            problem=problem,
+        )
+
+    def update(self, instance: KnowledgeBase, validated_data: dict) -> KnowledgeBase:
+        """Update an existing KnowledgeBase item."""
+        instance.entity1 = validated_data["entity1"]
+        instance.relationship = validated_data["relationship"]
+        instance.entity2 = validated_data["entity2"]
+        instance.save()
+        return instance
+
+
+class ProblemSerializer(serializers.ModelSerializer):
+    """
+    Serializer for Problem model output.
+    Handles serialization of problems with all related data including labels.
+    """
+
+    premises = serializers.SerializerMethodField()
+    hypothesis = serializers.SerializerMethodField()
+    entailmentLabel = serializers.CharField(source="entailment_label")
+    extraData = serializers.SerializerMethodField()
+    kbItems = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Problem
+        fields = [
+            "id",
+            "dataset",
+            "premises",
+            "hypothesis",
+            "entailmentLabel",
+            "extraData",
+            "kbItems",
+        ]
+
+    def get_premises(self, problem):
+        """Get list of premise texts."""
+        return [premise.text for premise in problem.premises.all()]
+
+    def get_hypothesis(self, problem):
+        """Get hypothesis text."""
+        return problem.hypothesis.text
+
+    def get_extraData(self, problem):
+        """Get dataset-specific extra data."""
+        match problem.dataset:
+            case Problem.Dataset.SICK:
+                return SickData.serialize(problem.extra_data)
+            case Problem.Dataset.FRACAS:
+                return FracasData.serialize(problem.extra_data)
+            case Problem.Dataset.SNLI:
+                return SNLIData.serialize(problem.extra_data)
+            case _:
+                return {}
+
+    def get_kbItems(self, problem):
+        """Get knowledge base items."""
+        kb_items = problem.knowledge_bases.all()
+        return KnowledgeBaseSerializer(kb_items, many=True).data
+
+    def create(self, validated_data: dict) -> Problem:
+        """
+        Create a new Problem instance from validated input data.
+        Handles creation of related Sentence and KnowledgeBase objects.
+        """
+        premise_sentences = [
+            Sentence.objects.get_or_create(text=premise)[0]
+            for premise in validated_data["premises"]
+        ]
+
+        hypothesis_sentence = Sentence.objects.get_or_create(
+            text=validated_data["hypothesis"]
+        )[0]
+
+        problem = Problem.objects.create(
+            hypothesis=hypothesis_sentence,
+            dataset=Problem.Dataset.USER,
+            # TODO: Determine entailment label based on LangPro parser output.
+            entailment_label=Problem.EntailmentLabel.UNKNOWN,
+            extra_data={},
+        )
+
+        problem.premises.set(premise_sentences)
+
+        kb_items = validated_data.get("kbItems", [])
+        if kb_items:
+            self._update_or_create_kb_items(problem, kb_items)
+
+        return problem
+
+    def update(self, instance: Problem, validated_data: dict) -> Problem:
+        """
+        Update an existing Problem instance from validated input data.
+        Handles updating of related Sentence and KnowledgeBase objects.
+        """
+        if instance.dataset != Problem.Dataset.USER:
+            raise serializers.ValidationError(
+                "Cannot update a problem that is not a user-created problem."
+            )
+
+        instance.hypothesis = Sentence.objects.get_or_create(
+            text=validated_data["hypothesis"],
+        )[0]
+        instance.save()
+
+        premise_sentences = [
+            Sentence.objects.get_or_create(text=premise)[0]
+            for premise in validated_data["premises"]
+        ]
+        instance.premises.set(premise_sentences)
+
+        self._update_or_create_kb_items(instance, validated_data.get("kbItems", []))
+
+        return instance
+
+    def _update_or_create_kb_items(
+        self, problem: Problem, kb_items: list[dict]
+    ) -> None:
+        """Create or update KnowledgeBase items for a problem."""
+        kb_ids: list[int] = []
+        kb_serializer = KnowledgeBaseSerializer()
+
+        for item in kb_items:
+            kb_id = item.get("id", None)
+
+            if kb_id is None:
+                kb = kb_serializer.create_for_problem(item, problem=problem)  # type: ignore
+            else:
+                kb_instance = KnowledgeBase.objects.get(id=kb_id, problem_id=problem.pk)
+                kb = kb_serializer.update(kb_instance, item)
+
+            kb_ids.append(kb.pk)
+
+        # Delete existing knowledge bases associated to this problem that are
+        # not included in the input.
+        KnowledgeBase.objects.filter(problem_id=problem.pk).exclude(
+            id__in=kb_ids
+        ).delete()
+
+
+class ProblemInputSerializer(serializers.Serializer):
+    """
+    Serializer for validating problem input data.
+    This is used for both creating and updating user-created problems.
+    """
+
+    id = serializers.IntegerField(required=False, allow_null=True)
+    premises = serializers.ListField(
+        child=serializers.CharField(allow_blank=False),
+        allow_empty=False,
+        help_text="List of premise sentence texts",
+    )
+    hypothesis = serializers.CharField(
+        allow_blank=False, help_text="Hypothesis sentence text"
+    )
+    kbItems = KnowledgeBaseSerializer(
+        many=True, allow_empty=True, help_text="List of knowledge base items"
+    )
+
+    def validate_id(self, value):
+        """Validate that the Problem ID, if provided, exists and belongs to a user-created problem."""
+        if value is not None:
+            if not Problem.objects.filter(
+                id=value, dataset=Problem.Dataset.USER
+            ).exists():
+                raise serializers.ValidationError(
+                    f"Problem with ID {value} does not exist."
+                )
+        return value