endoreg-db 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

endoreg_db/models/requirement/requirement_evaluation/requirement_type_parser.py

@@ -0,0 +1,102 @@
+# Currently those strings MUST match the ones
+# in the requirement_type data definitions
+from collections import namedtuple
+from endoreg_db.models import (
+    Requirement,
+    RequirementType,
+    PatientExamination,
+    PatientFindingIntervention,
+    Examination,
+    ExaminationIndication,
+    Disease,
+    DiseaseClassificationChoice,
+    PatientEvent,
+    PatientFinding,
+    PatientFindingMorphology,
+)
+from typing import List
+from icecream import ic
+# Requirement has RequirementTypes
+# Requirement has RequirementOperators
+# For each Operator/Type pair, there must be a custom function
+# for evaluation
+
+OperatorTypeTuple = namedtuple("OperatorTypeTuple", ["operator", "requirement_type"])
+
+
+data_model_dict = {
+    "patient_examination": PatientExamination,
+    "finding_intervention": PatientFindingIntervention,
+    "finding_interventions": List[PatientFindingIntervention],
+    "examination": Examination,
+    "examination_indication": ExaminationIndication,
+    "disease": Disease,
+    "disease_classification_choice": DiseaseClassificationChoice,
+    "event": PatientEvent,
+    "finding": PatientFinding,
+    "finding_morphology": PatientFindingMorphology,
+    # Add more mappings as needed
+}
+
+
+def evaluate_operator_type_tuple(
+    operator_type_tuple: OperatorTypeTuple, data: object, **kwargs
+):
+    """
+    Evaluates the requirement type and operator tuple against the provided data.
+
+    Args:
+        operator_type_tuple (OperatorTypeTuple): Tuple containing requirement type and operator.
+        data (object): The data to evaluate.
+        **kwargs: Additional keyword arguments.
+
+    Returns:
+        bool: True if the evaluation is successful, False otherwise.
+    """
+    # data = kwargs.get(name, None)
+
+    # # make sure data type matches the model for the req_type name
+    # if data is None:
+    #     raise ValueError(f"No data found for requirement type: {name}")
+    # if name not in data_model_dict:
+    #     raise ValueError(f"Unknown requirement type: {name}")
+
+    # model = data_model_dict[name]
+    # if not isinstance(data, model):
+    #     raise TypeError(
+    #         f"Data type mismatch for {name}: expected {model}, got {type(data)}"
+    #     )
+
+    requirement_type = operator_type_tuple.requirement_type
+    operator = operator_type_tuple.operator
+
+    # Call the appropriate function based on the requirement type and operator
+    # This is a placeholder; actual implementation will depend on your logic
+    return True  # Replace with actual evaluation logic
+
+
+def evaluate_requirement(requirement: Requirement, **kwargs):
+    requirement_types = requirement.requirement_types.all()
+    requirement_operators = requirement.operators.all()
+    operator_return_values = {}
+    operator_evaluation_results = {}
+
+    for requirement_operator in requirement_operators:
+        # Create tuples
+        requirement_type_operator_tuples = [
+            OperatorTypeTuple(requirement_operator, rt) for ro in requirement_types
+        ]
+
+        eval_result = [
+            evaluate_operator_type_tuple(t, **kwargs)
+            for t in requirement_type_operator_tuples
+        ]
+
+        operator_evaluation_results[requirement_operator.name] = eval_result
+
+        # TODO FIX
+        operator_return_values[requirement_operator.name] = (
+            requirement_operator.evaluate_return_values()
+        )
+
+    return operator_evaluation_results, operator_return_values

endoreg_db/models/requirement/requirement_operator.py

@@ -0,0 +1,58 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+
+class RequirementOperatorManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieve a RequirementOperator instance by its natural key.
+        
+        Args:
+            name (str): The unique name representing the natural key.
+        
+        Returns:
+            RequirementOperator: The model instance matching the provided name.
+        """
+        return self.get(name=name)
+
+
+class RequirementOperator(models.Model):
+    """
+    A class representing a requirement operator.
+
+    Attributes:
+        name (str): The name of the requirement operator.
+        name_de (str): The German name of the requirement operator.
+        name_en (str): The English name of the requirement operator.
+        description (str): A description of the requirement operator.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = RequirementOperatorManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.requirement.requirement import Requirement
+
+        requirements: models.QuerySet[Requirement]
+
+    def natural_key(self):
+        """
+        Return the natural key for the requirement operator.
+        
+        This method returns a tuple containing the operator's name, which serves as its
+        natural key for serialization and unique identification within the system.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return the string representation of the requirement operator.
+        
+        Returns:
+            str: The name attribute of the operator.
+        """
+        return str(self.name)

endoreg_db/models/requirement/requirement_set.py

@@ -0,0 +1,127 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+
+class RequirementSetTypeManager(models.Manager):
+    """
+    Manager for RequirementSetType with custom query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "RequirementSetType":
+        """
+        Retrieves a RequirementSetType instance using its natural key.
+        
+        Args:
+            name (str): The unique name that serves as the natural key.
+        
+        Returns:
+            RequirementSetType: The matching RequirementSetType instance.
+        """
+        return self.get(name=name)
+
+
+class RequirementSetType(models.Model):
+    """
+    A class representing a type of requirement set.
+
+    Attributes:
+        name (str): The name of the requirement set type.
+        name_de (str): The German name of the requirement set type.
+        name_en (str): The English name of the requirement set type.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = RequirementSetTypeManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.requirement import RequirementType
+
+        requirement_types: models.QuerySet[RequirementType]
+
+    def natural_key(self):
+        """
+        Return the natural key tuple for the instance.
+        
+        Returns:
+            tuple: A one-element tuple containing the instance's name, used as its natural key.
+        """
+        return (self.name,)
+
+
+class RequirementSetManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieves a model instance by its natural key.
+        
+        Args:
+            name: The natural key value, typically corresponding to the model's unique name.
+        
+        Returns:
+            The model instance whose name matches the provided natural key.
+        """
+        return self.get(name=name)
+
+
+class RequirementSet(models.Model):
+    """
+    A class representing a set of requirements.
+
+    Attributes:
+        name (str): The name of the requirement set.
+        name_de (str): The German name of the requirement set.
+        name_en (str): The English name of the requirement set.
+        description (str): A description of the requirement set.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    requirements = models.ManyToManyField(
+        "Requirement",
+        blank=True,
+        related_name="requirement_sets",
+    )
+    links_to_sets = models.ManyToManyField(
+        "RequirementSet",
+        blank=True,
+        related_name="links_from_sets",
+    )
+    requirement_set_type = models.ForeignKey(
+        "RequirementSetType",
+        on_delete=models.CASCADE,
+        related_name="requirement_sets",
+        blank=True,
+        null=True,
+    )
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="requirement_sets",
+        blank=True,
+    )
+    objects = RequirementSetManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import Requirement, InformationSource
+
+        requirements: models.QuerySet[Requirement]
+        information_source: InformationSource
+        requirement_set_type: RequirementSetType
+        linked_sets: models.QuerySet["RequirementSet"]
+
+    def natural_key(self):
+        """Return the natural key as a tuple containing the instance's name."""
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return the string representation of the requirement set.
+        
+        Returns:
+            str: The name of the requirement set.
+        """
+        return str(self.name)

endoreg_db/models/risk/__init__.py

@@ -0,0 +1,7 @@
+from .risk import Risk
+from .risk_type import RiskType
+
+__all__ = [
+    "Risk",
+    "RiskType",
+]

endoreg_db/models/risk/risk.py

@@ -0,0 +1,72 @@
+from django.db import models
+from typing import List, TYPE_CHECKING
+
+
+class RiskManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieve a risk instance using its natural key.
+        
+        Args:
+            name: The unique name identifying the risk instance.
+        
+        Returns:
+            The risk instance with the matching name.
+        """
+        return self.get(name=name)
+
+
+class Risk(models.Model):
+    """
+    A class representing a risk.
+
+    Attributes:
+        name (str): The name of the risk.
+        name_de (str): The German name of the risk.
+        name_en (str): The English name of the risk.
+        description (str): A description of the risk.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    risk_value = models.FloatField(
+        blank=True,
+        null=True,
+        help_text="Risk value for the risk. If not set, the risk is not used in calculations.",
+    )
+
+    risk_type = models.ForeignKey(
+        "RiskType",
+        on_delete=models.CASCADE,
+        related_name="risks",
+        blank=True,
+        null=True,
+    )
+
+    objects = RiskManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.risk.risk_type import RiskType
+
+        risk_types: RiskType
+
+    def natural_key(self):
+        """
+        Return a tuple containing the natural key of the risk instance.
+        
+        The tuple consists of the unique 'name' attribute, which enables natural key lookups
+        and serialization within Django.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return the string representation of the risk.
+        
+        Returns:
+            str: The risk's name.
+        """
+        return str(self.name)

endoreg_db/models/risk/risk_type.py

@@ -0,0 +1,55 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+
+class RiskTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieves a RiskType instance using its natural key.
+        
+        Args:
+            name (str): The unique name identifying the RiskType instance.
+        
+        Returns:
+            RiskType: The matching instance with the provided name.
+        """
+        return self.get(name=name)
+
+
+class RiskType(models.Model):
+    """
+    A class representing a risk type.
+
+    Attributes:
+        name (str): The name of the risk type.
+        name_de (str): The German name of the risk type.
+        name_en (str): The English name of the risk type.
+        description (str): A description of the risk type.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = RiskTypeManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.risk.risk import Risk
+
+        risks: models.QuerySet[Risk]
+
+    def natural_key(self):
+        """
+        Return the natural key for this risk type.
+        
+        This method returns a tuple containing only the risk type's unique name, which is used
+        to identify the instance naturally.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return the risk type's name as its string representation.
+        """
+        return str(self.name)

endoreg_db/serializers/raw_pdf_anony_text_validation.py

@@ -0,0 +1,137 @@
+from pathlib import Path
+from rest_framework import serializers
+from django.conf import settings
+from ..models import RawPdfFile
+
+class RawPdfAnonyTextSerializer(serializers.ModelSerializer):
+    """
+    Serializer to fetch PDF metadata along with `anonymized_text` from `RawPdfFile`.
+    Ensures Vue.js can process JSON efficiently.
+    """
+
+    pdf_url = serializers.SerializerMethodField()
+    full_pdf_path = serializers.SerializerMethodField()
+    file = serializers.SerializerMethodField()
+
+    class Meta:
+        model = RawPdfFile
+        fields = ['id', 'file', 'pdf_url', 'full_pdf_path', 
+                  'sensitive_meta_id', 'anonymized_text']
+
+    @staticmethod
+    def get_next_pdf(last_id=None):
+        """
+        Retrieves the first available PDF if `last_id` is NOT provided.
+        Otherwise, fetches the next available PDF where `id > last_id`.
+        """
+        query_filter = {} if last_id is None else {"id__gt": int(last_id)}
+        pdf_entry = RawPdfFile.objects.filter(**query_filter).order_by('id').first()
+        return pdf_entry  
+
+    def get_pdf_url(self, obj):
+        """
+        Generates the full URL where Vue.js can fetch and display the PDF.
+        """
+        request = self.context.get('request')
+        return request.build_absolute_uri(f"/api/pdf/anony_text/?id={obj.id}") if request and obj.file else None
+
+    def get_file(self, obj):
+        """
+        Returns the relative file path stored in the database.
+        """
+        return str(obj.file.name).strip() if obj.file else None  
+
+    def get_full_pdf_path(self, obj):
+        """
+        Constructs the full absolute file path using `settings.MEDIA_ROOT`.
+        """
+        if not obj.file:
+            return None
+        pdf_relative_path = str(obj.file.name)
+        full_path = Path(settings.MEDIA_ROOT) / pdf_relative_path
+        return str(full_path) if full_path.exists() else None  
+
+    def validate_anonymized_text(self, value):
+        """
+        Ensures the anonymized_text is not empty or too long.
+        """
+        if not value.strip():
+            raise serializers.ValidationError("Anonymized text cannot be empty.")
+        if len(value) > 5000:  # Arbitrary limit to prevent excessively long text
+            raise serializers.ValidationError("Anonymized text exceeds the maximum length of 5000 characters.")
+        return value
+
+    def update(self, instance, validated_data):
+        """
+        Updates only `anonymized_text` without modifying other fields.
+        """
+        instance.anonymized_text = validated_data.get('anonymized_text', instance.anonymized_text)
+        instance.save()
+        return instance
+
+
+
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+
+const fetchPdfWithAnonymizedText = async (lastId = null) => {
+    const url = lastId 
+        ? `http://localhost:8000/api/pdf/anony_text/?last_id=${lastId}` 
+        : "http://localhost:8000/api/pdf/anony_text/";
+
+    try {
+        const response = await axios.get(url, { headers: { "Accept": "application/json" } });
+        console.log("PDF Data:", response.data);
+    } catch (error) {
+        console.error("Error fetching PDF:", error.response?.data || error);
+    }
+};
+
+fetchPdfWithAnonymizedText();
+
+"""
+
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+
+const updateAnonymizedText = async (pdfId, newText) => {
+    try {
+        const response = await axios.patch("http://localhost:8000/api/pdf/update_anony_text/", {
+            id: pdfId,
+            anonymized_text: newText
+        }, { headers: { "Content-Type": "application/json" } });
+
+        console.log("Update Success:", response.data);
+    } catch (error) {
+        console.error("Update Error:", error.response?.data || error);
+    }
+};
+
+updateAnonymizedText(1, "Updated anonymized text.");
+
+"""
+
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+
+const updateAnonymizedText = async () => {
+    const updatedData = {
+        id: 1,
+        anonymized_text: "This is the updated anonymized text."
+    };
+
+    try {
+        const response = await axios.patch("http://localhost:8000/api/pdf/update_anony_text/", updatedData, {
+            headers: { "Content-Type": "application/json" }
+        });
+
+        console.log("Update Success:", response.data);
+        alert("Anonymized text updated successfully!");
+    } catch (error) {
+        console.error("Update Error:", error.response?.data || error);
+        alert("Failed to update anonymized text.");
+    }
+};
+
+updateAnonymizedText();
+"""