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

endoreg_db/models/requirement/requirement_set.py

@@ -1,7 +1,16 @@
 from django.db import models
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List
 
 
+REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP = {
+    "all": all,
+    "any": any,
+    "none": lambda x: not any(x),  # Custom function for 'none'
+    "exactly_1": lambda x: sum(1 for item in x if item) == 1,
+    "at_least_1": lambda x: sum(1 for item in x if item) >= 1,  # Equivalent to any(x)
+    "at_most_1": lambda x: sum(1 for item in x if item) <= 1,
+}
+
 class RequirementSetTypeManager(models.Manager):
     """
     Manager for RequirementSetType with custom query methods.
@@ -26,13 +35,9 @@ class RequirementSetType(models.Model):
 
     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()
@@ -72,46 +77,58 @@ class RequirementSet(models.Model):
 
     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(
+    requirements = models.ManyToManyField(  # type: ignore[assignment]
         "Requirement",
         blank=True,
         related_name="requirement_sets",
     )
-    links_to_sets = models.ManyToManyField(
+    links_to_sets = models.ManyToManyField(  # type: ignore[assignment]
         "RequirementSet",
         blank=True,
         related_name="links_from_sets",
     )
-    requirement_set_type = models.ForeignKey(
+    requirement_set_type = models.ForeignKey(  # type: ignore[assignment]
         "RequirementSetType",
         on_delete=models.CASCADE,
         related_name="requirement_sets",
         blank=True,
         null=True,
     )
-    information_sources = models.ManyToManyField(
+    information_sources = models.ManyToManyField(  # type: ignore[assignment]
         "InformationSource",
         related_name="requirement_sets",
         blank=True,
     )
+    
+    reqset_exam_links = models.ManyToManyField(  # type: ignore[assignment]
+        "ExaminationRequirementSet",
+        related_name="requirement_set",
+        blank=True,
+    )
+    
+    tags = models.ManyToManyField(  # type: ignore[assignment]
+        "Tag",
+        related_name="requirement_sets",
+        blank=True,
+    )
+    
     objects = RequirementSetManager()
 
     if TYPE_CHECKING:
-        from endoreg_db.models import Requirement, InformationSource
+        from endoreg_db.models import Tag, Requirement, InformationSource
+        from typing import Optional
 
-        requirements: models.QuerySet[Requirement]
-        information_source: InformationSource
-        requirement_set_type: RequirementSetType
-        linked_sets: models.QuerySet["RequirementSet"]
+        tags: "models.ManyToManyField[Tag]"
+        requirements: "models.Manager[Requirement]"
+        information_sources: "models.Manager[InformationSource]"
+        requirement_set_type: Optional[RequirementSetType]
+        links_to_sets: "models.Manager[RequirementSet]"
+        links_from_sets: "models.Manager[RequirementSet]"
 
     def natural_key(self):
         """Return the natural key as a tuple containing the instance's name."""
@@ -119,9 +136,152 @@ class RequirementSet(models.Model):
 
     def __str__(self):
         """
-        Return the string representation of the requirement set.
+        Returns the name of the requirement set as its string representation.
+        """
+        return str(self.name)
+    
+    def evaluate_requirements(self, input_object, mode="loose") -> List[bool]:
+        """
+        Evaluates all requirements in the set against the provided input object.
+        
+        Intelligently selects the appropriate input data for each requirement based on its expected model types.
+        For example, if a requirement expects PatientFinding but receives a PatientExamination, 
+        it will use the examination's patient_findings instead.
+        
+        Args:
+            input_object: The object to be evaluated by each requirement.
+            mode: Optional evaluation mode passed to each requirement (default is "loose").
         
         Returns:
-            str: The name of the requirement set.
+            A list of boolean values indicating whether each requirement is satisfied.
         """
-        return str(self.name)
+        results = []
+        for requirement in self.requirements.all():
+            # Get the appropriate input for this specific requirement
+            evaluation_input = self._get_evaluation_input_for_requirement(requirement, input_object)
+            result = requirement.evaluate(evaluation_input, mode=mode)
+            results.append(result)
+        return results
+    
+    def _get_evaluation_input_for_requirement(self, requirement, input_object):
+        """
+        Determines the appropriate input object for evaluating a specific requirement.
+        
+        Args:
+            requirement: The requirement to be evaluated
+            input_object: The original input object
+            
+        Returns:
+            The most appropriate input object for the requirement evaluation
+        """
+        expected_models = requirement.expected_models
+        
+        # If the input object is already one of the expected models, use it directly
+        for expected_model in expected_models:
+            if isinstance(input_object, expected_model):
+                return input_object
+        
+        # Import here to avoid circular imports
+        from endoreg_db.models.medical.patient.patient_examination import PatientExamination
+        from endoreg_db.models.medical.patient.patient_finding import PatientFinding
+        
+        # Handle PatientExamination -> PatientFinding conversion
+        if isinstance(input_object, PatientExamination):
+            # If requirement expects PatientFinding, return the examination's findings
+            if PatientFinding in expected_models:
+                return input_object.patient_findings.all()
+
+        
+        # Handle other model conversions as needed in the future
+        # For now, return the original input object as fallback
+        return input_object
+
+    def evaluate_requirement_sets(self, input_object) -> List[bool]:
+        """
+        Evaluates all linked requirement sets against the provided input object.
+        
+        Returns:
+            A list of boolean values indicating whether each linked requirement set is satisfied.
+        """
+        results = []
+        linked_sets = self.all_linked_sets
+        if not linked_sets:
+            return results
+        for linked_set in linked_sets:
+            result = linked_set.evaluate(input_object)
+            results.append(result)
+        return results
+    
+    @property
+    def eval_function(self):
+        """
+        Returns the evaluation function associated with this requirement set's type.
+        
+        If the requirement set type is defined and matches a known type, returns the corresponding function from REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP. Returns None if no matching function is found.
+        """
+        if self.requirement_set_type and self.requirement_set_type.name in REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP:
+            return REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP[self.requirement_set_type.name]
+        return None
+
+    def evaluate(self, input_object):
+        """
+        Evaluates whether the input object satisfies this requirement set.
+        
+        Combines the evaluation results of all direct requirements and linked requirement sets, then applies the set's evaluation function (such as all, any, none, etc.) to determine if the input object meets the overall criteria.
+        
+        Args:
+            input_object: The object to be evaluated against the requirements and linked sets.
+        
+        Returns:
+            True if the input object satisfies the requirement set according to its evaluation logic; otherwise, False.
+        """
+        evaluate_r_results = self.evaluate_requirements(input_object)
+        evaluate_rs_results = self.evaluate_requirement_sets(input_object)
+
+        results = evaluate_r_results + evaluate_rs_results
+
+        eval_result = self.eval_function(results) if self.eval_function else all(results)
+
+        return eval_result
+    
+    @property
+    def all_linked_sets(self):
+        """
+        Returns all linked requirement sets, including those linked to the current set and those linked to any of its linked sets.
+        
+        Uses recursive traversal with cycle detection to safely handle circular relationships.
+        Eliminates duplicates by tracking visited sets.
+        
+        Returns:
+            List[RequirementSet]: A list of all linked requirement sets.
+        """
+        visited = set()
+        result:List["RequirementSet"] = []
+        
+        def _collect_linked_sets(requirement_set:"RequirementSet"):
+            """
+            Recursively collect linked sets while avoiding cycles and duplicates.
+            
+            Args:
+                requirement_set: The RequirementSet to process
+            """
+            # Use the primary key to track visited sets (avoids issues with object comparison)
+            if requirement_set.pk in visited:
+                return
+            
+            visited.add(requirement_set.pk)
+            
+            # Process all directly linked sets
+            for linked_set in requirement_set.links_to_sets.all():
+                if linked_set.pk not in visited:
+                    result.append(linked_set)
+                    # Recursively process the linked set's links
+                    _collect_linked_sets(linked_set)
+        
+        # Start the recursive collection from this instance
+        _collect_linked_sets(self)
+        
+        return result
+
+
+

endoreg_db/models/rule/__init__.py

@@ -0,0 +1,13 @@
+from .rule_type import RuleType
+from .rule import Rule
+from .ruleset import Ruleset
+from .rule_attribute_dtype import RuleAttributeDType
+from .rule_applicator import RuleApplicator
+
+__all__ = [
+    "RuleType",
+    "Rule",
+    "Ruleset",
+    "RuleAttributeDType",
+    "RuleApplicator",
+]

endoreg_db/models/{rules → rule}/rule.py

@@ -6,8 +6,6 @@ class RuleManager(models.Manager):
 
 class Rule(models.Model):
     name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
     description = models.TextField(blank=True, null=True)
     attribute_key = models.CharField(max_length=255)
     rule_type = models.ForeignKey("RuleType", on_delete=models.CASCADE)
@@ -20,5 +18,10 @@ class Rule(models.Model):
         verbose_name_plural = 'Rules'
 
     def natural_key(self):
+        """
+        Return a tuple representing the natural key for this Rule instance.
+        
+        Returns:
+            tuple: A one-element tuple containing the Rule's unique name.
+        """
         return (self.name,)
-    

endoreg_db/models/{rules → rule}/rule_attribute_dtype.py

@@ -7,8 +7,6 @@ class RuleAttributeDtypeManager(models.Manager):
 
 class RuleAttributeDType(models.Model):
     name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
 
     objects = RuleAttributeDtypeManager()
 

endoreg_db/models/{rules → rule}/rule_type.py

@@ -6,8 +6,6 @@ class RuleTypeManager(models.Manager):
 
 class RuleType(models.Model):
     name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
 
     objects = RuleTypeManager()
 

endoreg_db/models/{rules → rule}/ruleset.py

@@ -6,8 +6,6 @@ class RulesetManager(models.Manager):
 
 class Ruleset(models.Model):
     name = models.CharField(max_length=255, unique=True)
-    name_de = models.CharField(max_length=255, blank=True, null=True)
-    name_en = models.CharField(max_length=255, blank=True, null=True)
     rules = models.ManyToManyField('Rule')
 
     objects = RulesetManager()

endoreg_db/models/state/__init__.py

@@ -0,0 +1,12 @@
+from .sensitive_meta import SensitiveMetaState
+from .video import VideoState, AnonymizationStatus
+from .label_video_segment import LabelVideoSegmentState
+from .raw_pdf import RawPdfState
+
+__all__ = [
+    "SensitiveMetaState",
+    "VideoState",
+    "LabelVideoSegmentState",
+    "AnonymizationStatus",
+    "RawPdfState",
+]

endoreg_db/models/state/abstract.py

@@ -0,0 +1,11 @@
+from django.db import models
+
+class AbstractState(models.Model):
+    """Abstract base class for all states."""
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+
+    class Meta:
+        abstract = True

endoreg_db/models/state/audit_ledger.py

@@ -0,0 +1,150 @@
+# stats/models.py
+import hashlib, json, uuid
+from django.db import models
+from django.utils import timezone
+from django.conf import settings
+
+"""
+
+AuditLedger Model
+
+AuditLedger is a model that tracks changes to other models in the database.
+It stores a hash of the previous state, the current state, and the action taken.
+This allows for a complete audit trail of changes made to the database.
+The model includes fields for the timestamp, user who made the change, object type,
+object primary key, action taken, and the data associated with the change.
+The save method computes the hash of the current state and the previous state
+before saving the record to the database.
+The hash is computed using SHA-256 and includes the timestamp, user ID,
+object type, object primary key, action taken, and the data associated with the change.
+The hash is stored in the database to ensure data integrity and to allow for
+verification of the data.
+The model also includes a method to retrieve the last hash from the database
+to ensure that the current hash is always based on the most recent state of the database.
+The model is designed to be immutable, meaning that once a record is created,
+it cannot be modified. This ensures that the audit trail is complete and accurate.
+
+Raises:
+    RuntimeError: _description_
+
+Returns:
+    _type_: _description_
+"""
+
+
+class AuditLedger(models.Model):
+    id           = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    ts           = models.DateTimeField(default=timezone.now, editable=False)
+    user         = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.PROTECT)
+    object_type  = models.CharField(max_length=80)            # e.g. 'VideoFile'
+    object_pk    = models.CharField(max_length=40)            # UUID or int
+    action       = models.CharField(max_length=40)            # 'created' | 'validated' | …
+    data         = models.JSONField()                         # snapshot / diff / metadata
+    prev_hash    = models.CharField(max_length=64, editable=False)
+    hash         = models.CharField(max_length=64, editable=False)
+
+    class Meta:
+        ordering = ['ts']
+        indexes  = [models.Index(fields=['object_type', 'object_pk'])]
+
+    # ------------------------------------------------------
+    def save(self, *args, **kw):
+        """
+        Saves a new immutable audit record, computing and linking cryptographic hashes.
+        
+        Raises:
+            RuntimeError: If an attempt is made to modify an existing audit record.
+        """
+        if self._state.adding:                         # only on INSERT
+            self.prev_hash = self._last_hash()
+            self.hash      = self._compute_hash()
+        else:
+            raise RuntimeError("AuditLedger rows are immutable")
+        super().save(*args, **kw)
+
+    # ------------------------------------------------------
+    def _last_hash(self) -> str:
+        """
+        Retrieves the hash of the most recent audit record.
+        
+        Returns:
+            The SHA-256 hash of the latest `AuditLedger` entry by timestamp, or a string of 64 zeros if no records exist.
+        """
+        last = AuditLedger.objects.order_by('-ts').first()
+        return last.hash if last else '0' * 64
+
+    def _compute_hash(self) -> str:
+        """
+        Computes the SHA-256 hash of the current audit record's data.
+        
+        The hash is generated from a JSON-serialized payload containing the timestamp, user ID, object type and primary key, action, associated data, and the previous record's hash. This ensures the integrity and immutability of the audit trail.
+        
+        Returns:
+            The hexadecimal SHA-256 hash string representing the current audit record.
+        """
+        payload = {
+            'ts':   self.ts.isoformat(),
+            'uid':  str(self.user_id),
+            'obj':  f'{self.object_type}:{self.object_pk}',
+            'act':  self.action,
+            'data': self.data,
+            'prev': self.prev_hash,
+        }
+        return hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest()
+    
+    def log_validation(user, instance, action: str, extra=None):
+        """
+        Creates an audit record for a validation action performed by a user on a specific model instance.
+        
+        Args:
+            user: The user performing the action.
+            instance: The model instance being validated.
+            action: The action performed (e.g., 'validated').
+            extra: Optional additional data to include in the audit record.
+        """
+        AuditLedger.objects.create(
+            user=user,
+            object_type=instance.__class__.__name__,
+            object_pk=str(instance.pk),
+            action=action,
+            data=extra or {},
+        )
+
+    def _distinct(object_type: str, action: str):
+        """
+        Returns the number of distinct objects of a given type that have a specific audit action recorded.
+        
+        Args:
+            object_type: The type of object to filter by (e.g., 'VideoFile').
+            action: The audit action to filter by (e.g., 'validated').
+        
+        Returns:
+            The count of unique object primary keys matching the specified type and action.
+        """
+        return (
+            AuditLedger.objects
+            .filter(object_type=object_type, action=action)
+            .values('object_pk')
+            .distinct()
+            .count()
+        )
+
+    def collect_counters():
+        """
+        Aggregates and returns summary statistics for audit actions and object types.
+        
+        Returns:
+            dict: A dictionary containing counts of distinct cases, videos, annotations,
+            anonymizations, images, and breakdowns of video statuses based on audit records.
+        """
+        return {
+            "totalCases":           AuditLedger._distinct("VideoFile", "created"),
+            "totalVideos":          AuditLedger._distinct("VideoFile", "created"),
+            "totalAnnotations":     AuditLedger.objects.filter(action="annotation_added").count(),
+            "totalAnonymizations":  AuditLedger._distinct("VideoFile", "anonymized"),
+            "totalImages":          AuditLedger._distinct("Image",     "created"),
+            # video breakdown
+            "videosCompleted":      AuditLedger._distinct("VideoFile", "validated"),
+            "videosAnonym":         AuditLedger._distinct("VideoFile", "anonymized"),
+            # add more as needed …
+        }

endoreg_db/models/state/label_video_segment.py

@@ -0,0 +1,22 @@
+from django.db import models
+from .abstract import AbstractState
+
+class LabelVideoSegmentState(AbstractState):
+    """State for label video segment data."""
+
+    prediction = models.BooleanField(default=False)
+    annotation = models.BooleanField(default=False)
+    frames_extracted = models.BooleanField(default=False)
+    is_validated = models.BooleanField(default=False)
+
+    origin = models.OneToOneField(
+        "LabelVideoSegment",
+        on_delete=models.CASCADE,
+        related_name="state",
+        null=True,
+        blank=True,
+    )
+
+    class Meta:
+        verbose_name = "Label Video Segment State"
+        verbose_name_plural = "Label Video Segment States"