endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

endoreg_db/models/state/audit_ledger.py

@@ -1,8 +1,11 @@
 # stats/models.py
-import hashlib, json, uuid
+import hashlib
+import json
+import uuid
+
+from django.conf import settings
 from django.db import models
 from django.utils import timezone
-from django.conf import settings
 
 """
 
@@ -31,33 +34,35 @@ Returns:
     _type_: _description_
 """
 
+# TODO implement later on
+
 
 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)
+    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'])]
+        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
+        if self._state.adding:  # only on INSERT
             self.prev_hash = self._last_hash()
-            self.hash      = self._compute_hash()
+            self.hash = self._compute_hash()
         else:
             raise RuntimeError("AuditLedger rows are immutable")
         super().save(*args, **kw)
@@ -66,36 +71,36 @@ class AuditLedger(models.Model):
     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
+        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,
+            "ts": self.ts.isoformat(),
+            "uid": str(self.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):
+
+    def log_validation(self, 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.
@@ -110,41 +115,34 @@ class AuditLedger(models.Model):
             data=extra or {},
         )
 
-    def _distinct(object_type: str, action: str):
+    @classmethod
+    def _distinct(self, 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()
-        )
+        return AuditLedger.objects.filter(object_type=object_type, action=action).values("object_pk").distinct().count()
 
-    def collect_counters():
+    def collect_counters(self):
         """
         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 …
+            "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"),
+            "videosCompleted": AuditLedger._distinct("VideoFile", "validated"),
+            "videosAnonym": AuditLedger._distinct("VideoFile", "anonymized"),
         }

endoreg_db/models/state/label_video_segment.py

@@ -1,6 +1,10 @@
+from typing import TYPE_CHECKING
+
 from django.db import models
+
 from .abstract import AbstractState
 
+
 class LabelVideoSegmentState(AbstractState):
     """State for label video segment data."""
 
@@ -20,3 +24,8 @@ class LabelVideoSegmentState(AbstractState):
     class Meta:
         verbose_name = "Label Video Segment State"
         verbose_name_plural = "Label Video Segment States"
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import LabelVideoSegment
+
+        origin: models.OneToOneField["LabelVideoSegment|None"]

endoreg_db/models/state/raw_pdf.py

@@ -1,24 +1,19 @@
 """
-Defines state tracking models related to PDF processing, including extraction of text and metadata, AI predictions, and anonymization status for RawPdfFile instances.
+Defines state tracking models related to report processing, including extraction of text and metadata, AI predictions, and anonymization status for RawPdfFile instances.
 """
-from django.db import models
-from typing import TYPE_CHECKING
+
 import logging
 from enum import Enum
+from typing import TYPE_CHECKING
+
+from django.db import models, transaction
+
+from endoreg_db.models.state.anonymization import AnonymizationState
 
 logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
     from ..media import RawPdfFile
-    
-
-class AnonymizationStatus(str, Enum):
-    NOT_STARTED             = "not_started"
-    PROCESSING_ANONYMIZING  = "processing_anonymization"
-    DONE                    = "done"
-    VALIDATED               = "validated"
-    FAILED                  = "failed"
-    STARTED                = "started"
 
 
 class RawPdfState(models.Model):
@@ -26,40 +21,62 @@ class RawPdfState(models.Model):
     Tracks the processing state of a RawPdfFile instance.
     Uses BooleanFields for clear, distinct states.
     """
-    text_meta_extracted = models.BooleanField(default=False, help_text="True if text metadata (OCR) has been extracted.")
+
+    text_meta_extracted = models.BooleanField(
+        default=False, help_text="True if text metadata (OCR) has been extracted."
+    )
 
     # AI / Annotation related states
-    initial_prediction_completed = models.BooleanField(default=False, help_text="True if initial AI prediction has run.")
+    initial_prediction_completed = models.BooleanField(
+        default=False, help_text="True if initial AI prediction has run."
+    )
 
     # Processing state
-    sensitive_meta_processed = models.BooleanField(default=False, help_text="True if the video has been fully processed, meaning a anonymized person was created.")
+    sensitive_meta_processed = models.BooleanField(
+        default=False,
+        help_text="True if the video has been fully processed, meaning a anonymized person was created.",
+    )
 
     # Anonymization state
-    anonymized = models.BooleanField(default=False, help_text="True if the anonymized video file has been created.")
-    anonymization_validated = models.BooleanField(default=False, help_text="True if the anonymization process has been validated and confirmed.")
-    
+    anonymized = models.BooleanField(
+        default=False, help_text="True if the anonymized video file has been created."
+    )
+    anonymization_validated = models.BooleanField(
+        default=False,
+        help_text="True if the anonymization process has been validated and confirmed.",
+    )
+
     # Processing state
-    processing_started = models.BooleanField(default=False, help_text="True if the processing has started, but not yet completed.")
-    processing_error = models.BooleanField(default=False, help_text="True if an error occurred during processing.")
-    
+    processing_started = models.BooleanField(
+        default=False,
+        help_text="True if the processing has started, but not yet completed.",
+    )
+    processing_error = models.BooleanField(
+        default=False, help_text="True if an error occurred during processing."
+    )
+
     # Timestamps
     date_created = models.DateTimeField(auto_now_add=True)
     date_modified = models.DateTimeField(auto_now=True)
-    
-    was_created = models.BooleanField(default=True, help_text="True if this state was created for the first time.")
 
-    # PDF metadata extraction state
-    pdf_meta_extracted = models.BooleanField(default=False, help_text="True if PDF metadata has been extracted.")
+    was_created = models.BooleanField(
+        default=True, help_text="True if this state was created for the first time."
+    )
+
+    # report metadata extraction state
+    pdf_meta_extracted = models.BooleanField(
+        default=False, help_text="True if report metadata has been extracted."
+    )
 
     if TYPE_CHECKING:
         raw_pdf_file: "RawPdfFile"
 
     def __str__(self):
         """
-        Return a string summarizing the RawPdfState instance, including the related PDF file UUID and key processing state flags with timestamps.
+        Return a string summarizing the RawPdfState instance, including the related report file UUID and key processing state flags with timestamps.
         """
         try:
-            uuid = self.raw_pdf_file.id
+            uuid = self.raw_pdf_file.pk
         except Exception:
             uuid = None
 
@@ -70,52 +87,72 @@ class RawPdfState(models.Model):
             f"AnonymizationValidated={self.anonymization_validated}",
             f"SensitiveMetaProcessed={self.sensitive_meta_processed}",
             f"DateCreated={self.date_created.isoformat()}",
-            f"DateModified={self.date_modified.isoformat()}"
+            f"DateModified={self.date_modified.isoformat()}",
         ]
         return f"RawPdfState(Pdf:{uuid}): {', '.join(states)}"
 
     @property
-    def anonymization_status(self) -> AnonymizationStatus:
+    def anonymization_status(self) -> AnonymizationState:
         """
-        Determines the current anonymization workflow status for the PDF processing state.
-        
+        Determines the current anonymization workflow status for the report processing state.
+
         Returns:
             AnonymizationStatus: The current status, reflecting progress or failure in the anonymization process.
         """
-        if getattr(self, "processing_error", False):
-            return AnonymizationStatus.FAILED
         if self.anonymization_validated:
-            return AnonymizationStatus.VALIDATED
+            return AnonymizationState.VALIDATED  #  Validation in Frontend completed -> Views related to this /home/admin/endoreg-db/endoreg_db/views/anonymization/validate.py
         if self.sensitive_meta_processed:
-            return AnonymizationStatus.DONE
-        if self.anonymized:
-            return AnonymizationStatus.DONE
-        if self.initial_prediction_completed:
-            return AnonymizationStatus.PROCESSING_ANONYMIZING
-        if self.pdf_meta_extracted:
-            return AnonymizationStatus.NOT_STARTED
+            return (
+                AnonymizationState.DONE_PROCESSING_ANONYMIZATION
+            )  # /home/admin/endoreg-db/endoreg_db/services/pdf_import.py
+        if (
+            self.processing_started
+            and not self.processing_error
+            and not self.anonymized
+        ):
+            return AnonymizationState.PROCESSING_ANONYMIZING
+        if getattr(self, "processing_error", False):
+            return (
+                AnonymizationState.FAILED
+            )  # /home/admin/endoreg-db/endoreg_db/services/pdf_import.py
         if self.processing_started:
-            return AnonymizationStatus.STARTED
-        return AnonymizationStatus.NOT_STARTED
-    
+            return (
+                AnonymizationState.STARTED
+            )  # /home/admin/endoreg-db/endoreg_db/services/pdf_import.py
+        if self.anonymized:
+            return AnonymizationState.ANONYMIZED
+        return AnonymizationState.NOT_STARTED
+
+    def mark_processing_not_started(self) -> None:
+        """
+        Mark the processing as not started and optionally save the updated state.
+
+        Parameters:
+            save (bool): If True, persist the change to the database immediately. Defaults to True.
+        """
+        with transaction.atomic():
+            self.processing_started = False
+            self.anonymized = False
+            self.was_created = False
+            self.sensitive_meta_processed = False
+            self.anonymization_validated = False
+            self.save()
 
-    
     def mark_processing_started(self, *, save: bool = True) -> None:
         """
         Mark the processing as started and optionally save the updated state.
-        
+
         Parameters:
             save (bool): If True, persist the change to the database immediately. Defaults to True.
         """
         self.processing_started = True
-        if save:
-            self.save(update_fields=["processing_started", "date_modified"])
+        self.save(update_fields=["processing_started", "date_modified"])
 
     # ---- Single‑responsibility mutators ---------------------------------
     def mark_sensitive_meta_processed(self, *, save: bool = True) -> None:
         """
-        Mark the sensitive metadata processing step as completed for this PDF state.
-        
+        Mark the sensitive metadata processing step as completed for this report state.
+
         Parameters:
             save (bool): If True, immediately saves the updated state to the database.
         """
@@ -125,8 +162,8 @@ class RawPdfState(models.Model):
 
     def mark_anonymization_validated(self, *, save: bool = True) -> None:
         """
-        Mark the anonymization as validated for this PDF processing state.
-        
+        Mark the anonymization as validated for this report processing state.
+
         Parameters:
             save (bool): If True, immediately saves the updated state to the database.
         """
@@ -136,19 +173,19 @@ class RawPdfState(models.Model):
 
     def mark_anonymized(self, *, save: bool = True) -> None:
         """
-        Mark the PDF as anonymized and optionally save the updated state.
-        
+        Mark the report as anonymized and optionally save the updated state.
+
         Parameters:
             save (bool): If True, persist the change to the database immediately. Defaults to True.
         """
-        self.anonymized = True
-        if save:
+        with transaction.atomic():
+            self.anonymized = True
             self.save(update_fields=["anonymized", "date_modified"])
 
     def mark_initial_prediction_completed(self, *, save: bool = True) -> None:
         """
-        Mark the initial AI prediction step as completed for this PDF processing state.
-        
+        Mark the initial AI prediction step as completed for this report processing state.
+
         Parameters:
             save (bool): If True, immediately saves the updated state to the database.
         """
@@ -158,8 +195,8 @@ class RawPdfState(models.Model):
 
     def mark_pdf_meta_extracted(self, *, save: bool = True) -> None:
         """
-        Mark the PDF metadata extraction step as completed for this state.
-        
+        Mark the report metadata extraction step as completed for this state.
+
         Parameters:
             save (bool): If True, immediately saves the updated state to the database.
         """
@@ -169,19 +206,15 @@ class RawPdfState(models.Model):
 
     def mark_text_meta_extracted(self, *, save: bool = True) -> None:
         """
-        Mark the text metadata extraction step as completed for this PDF processing state.
-        
+        Mark the text metadata extraction step as completed for this report processing state.
+
         Parameters:
             save (bool): If True, immediately saves the updated state to the database.
         """
         self.text_meta_extracted = True
         if save:
             self.save(update_fields=["text_meta_extracted", "date_modified"])
-    
-    
 
     class Meta:
-        verbose_name = "Raw PDF Processing State"
-        verbose_name_plural = "Raw PDF Processing States"
-
-
+        verbose_name = "Raw report Processing State"
+        verbose_name_plural = "Raw report Processing States"

endoreg_db/models/state/sensitive_meta.py

@@ -1,6 +1,9 @@
+from typing import TYPE_CHECKING
+
 from django.db import models
+
 from .abstract import AbstractState
-from typing import TYPE_CHECKING
+
 
 class SensitiveMetaState(AbstractState):
     """State for sensitive meta data."""
@@ -19,7 +22,7 @@ class SensitiveMetaState(AbstractState):
     if TYPE_CHECKING:
         from endoreg_db.models import SensitiveMeta
 
-        origin: "SensitiveMeta"
+        origin: models.OneToOneField["SensitiveMeta|None"]
 
     @property
     def is_verified(self) -> bool:
@@ -41,6 +44,7 @@ class SensitiveMetaState(AbstractState):
         """
         self.names_verified = True
         self.save(update_fields=["names_verified"])
+
     class Meta:
         verbose_name = "Sensitive Meta State"
         verbose_name_plural = "Sensitive Meta States"