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

endoreg_db/models/requirement/requirement_operator.py

@@ -1,7 +1,10 @@
 from logging import getLogger  # Added logger
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Union
 
 from django.db import models
+from pydantic import BaseModel
+
+from endoreg_db.utils.requirement_operator_logic.new_operator_logic import REQUIREMENT_OPERATORS, model_attribute_set_any
 
 # see how operator evaluation function is fetched, add to docs #TODO
 # endoreg_db/utils/requirement_operator_logic/model_evaluators.py
@@ -14,6 +17,65 @@ if TYPE_CHECKING:
 logger = getLogger(__name__)  # Added logger instance
 
 
+class OperatorInstructions(BaseModel):
+    input_targets: List[str] = []
+    requirement_targets: List[str] = []
+    kwargs: Dict[str, Union[str, int, float, bool]] = {}
+    args: List[Union[str, int, float, bool]] = []
+
+
+def _parse_operator_instructions(raw: str):
+    target_attributes_list = [_.strip() for _ in raw.split(";") if _.strip()]
+
+    input_targets = []
+    kwargs: Dict[str, Union[str, int, float, bool]] = {}
+    args: List[Union[str, int, float, bool]] = []
+
+    valid_prefixes = [
+        "!",  # Requirement target
+        "?",  # Input target
+        "$",  # Keyword argument, keyword and value separated by ":"
+        "@",  # Positional argument
+    ]
+
+    for entry in target_attributes_list:
+        _prefix = entry[0]
+
+        if _prefix in valid_prefixes:
+            _attribute = entry[1:].strip()
+            if _prefix == "!":
+                # Requirement target
+                input_targets.append(_attribute)
+            elif _prefix == "?":
+                # Input target
+                input_targets.append(_attribute)
+            elif _prefix == "$":
+                # Keyword argument
+                if ":" in _attribute:
+                    key, value = _attribute.split(":", 1)
+                    kwargs[key.strip()] = value.strip()
+                else:
+                    raise ValueError(f"Invalid keyword argument format in target_attributes: '{entry}'. Expected format is '$key:value'.")
+            elif _prefix == "@":
+                # Positional argument
+                args.append(_attribute)
+        else:
+            raise ValueError(f"Invalid prefix '{_prefix}' in target_attributes entry: '{entry}'. Valid prefixes are {valid_prefixes}.")
+    return OperatorInstructions(
+        input_targets=input_targets,
+        requirement_targets=input_targets,
+        kwargs=kwargs,
+        args=args,
+    )
+
+
+def _validate_operator_instructions(instance: "Requirement") -> bool:
+    """Ensures requirement fixtures declare at least one target attribute."""
+    if not instance.operator_instructions_parsed:
+        raise ValueError(f"Requirement '{instance.name}' must declare at least one target attribute.")
+    return True
+
+
 class RequirementOperatorManager(models.Manager):
     def get_by_natural_key(self, name):
         """
@@ -48,16 +110,18 @@ class RequirementOperator(models.Model):
 
         requirements: models.QuerySet[Requirement]
 
-    @property
-    def operator_evaluation_models(self):
+    @classmethod
+    def parse_instructions(cls, raw: str) -> OperatorInstructions:
         """
-        Returns a dictionary of operator evaluation models for this requirement operator.
+        Parses the raw target attributes string into structured operator instructions.
 
-        This property dynamically imports and provides access to the available operator evaluation models.
-        """
-        from .requirement_evaluation.operator_evaluation_models import operator_evaluation_models
+        Args:
+            raw: The raw target attributes string.
 
-        return operator_evaluation_models
+        Returns:
+            An OperatorInstructions instance containing parsed input targets, requirement targets, kwargs, and args.
+        """
+        return _parse_operator_instructions(raw)
 
     @property
     def data_model_dict(self):
@@ -84,96 +148,20 @@ class RequirementOperator(models.Model):
         """
         return str(self.name)
 
-    def evaluate(self, requirement_links: "RequirementLinks", input_links: "RequirementLinks", **kwargs) -> bool:  # Changed signature
-        """
-        Evaluates the requirement operator against the provided requirement links and input_links.
+    def get_operator_function(self) -> Callable[..., bool]:
+        _operator_function = REQUIREMENT_OPERATORS.get(self.name)
+        if not _operator_function:
+            raise ValueError(f"Operator function for '{self.name}' not found in REQUIREMENT_OPERATORS.")
+        return _operator_function
 
-        Args:
-            requirement_links: The RequirementLinks object from the Requirement model.
-            input_links: The aggregated RequirementLinks object from the input arguments.
-            **kwargs: Additional keyword arguments for specific operator logic.
-                        For lab value operators, this includes 'requirement' (the Requirement model instance).
-                        The 'requirement' instance is now passed for all operators.
+    def evaluate(self, operator_instructions: "OperatorInstructions", requirement: "Requirement", input_obj: Any, **kwargs) -> bool:
+        """ """
+        eval_result: bool = False
+        requirement_links: "RequirementLinks" = requirement.links
+        expected_input_models = requirement.expected_models
+        operator_function = self.get_operator_function()
 
-        Returns:
-            True if the condition defined by the operator is met, False otherwise.
+        input_model = type(input_obj)
+        assert input_model in expected_input_models, f"Input model {input_model} not in expected models {expected_input_models}"
 
-        Raises:
-            NotImplementedError: If the evaluation logic for the operator's name is not implemented.
-        """
-        # kwargs should contain 'requirement' (the Requirement instance) passed from Requirement.evaluate()
-        if self.evaluation_function_name:
-            eval_func = getattr(self, self.evaluation_function_name, None)
-            if eval_func and callable(eval_func):
-                result = eval_func(requirement_links=requirement_links, input_links=input_links, **kwargs)
-                assert isinstance(result, bool), (
-                    f"Evaluation function '{self.evaluation_function_name}' for operator '{self.name}' must return a boolean value."
-                )
-                return result
-            else:
-                logger.error(
-                    f"Evaluation function '{self.evaluation_function_name}' not found or not callable on {self.__class__.__name__} for operator '{self.name}'."
-                )
-                raise NotImplementedError(f"Evaluation function '{self.evaluation_function_name}' not implemented correctly for operator '{self.name}'.")
-        else:
-            # Fallback to the central dispatcher if no specific function name is provided
-            from endoreg_db.utils.requirement_operator_logic.model_evaluators import dispatch_operator_evaluation
-
-            return dispatch_operator_evaluation(
-                operator_name=self.name,
-                requirement_links=requirement_links,
-                input_links=input_links,
-                operator_instance=self,  # Pass the operator instance
-                **kwargs,
-            )
-
-    from ..medical.medication import MedicationSchedule as MedicationScheduleTemplate  # Added with alias
-    from ..medical.patient.patient_medication import PatientMedication  # Added
-
-    def _evaluate_patient_medication_schedule_matches_template(
-        self,
-        requirement_links: "RequirementLinks",
-        input_links: "RequirementLinks",
-        requirement: "Requirement",  # Added requirement
-        **kwargs,
-    ) -> bool:
-        """
-        Checks if any PatientMedication in the input PatientMedicationSchedule
-        matches the profile (medication, dose, unit, intake times)
-        of any MedicationSchedule template linked to the requirement.
-        """
-        # Get MedicationSchedule templates from the requirement
-        req_schedule_templates = requirement_links.medication_schedules
-        if not req_schedule_templates:
-            # If the requirement doesn't specify any templates to match against,
-            # it's ambiguous. Consider this a non-match.
-            return False
-
-        # Get PatientMedication instances from the input (derived from PatientMedicationSchedule.links)
-        input_patient_medications = input_links.patient_medications
-        if not input_patient_medications:
-            # If the input schedule has no medications, it cannot match any template.
-            return False
-
-        for pm_instance in input_patient_medications:
-            pm_intake_times_set = set(pm_instance.intake_times.all())
-            for schedule_template in req_schedule_templates:
-                template_intake_times_set = set(schedule_template.intake_times.all())
-
-                # Check for profile match
-                medication_match = pm_instance.medication == schedule_template.medication
-                dose_match = pm_instance.dosage == schedule_template.dose
-                unit_match = pm_instance.unit == schedule_template.unit
-                intake_times_match = pm_intake_times_set == template_intake_times_set
-
-                # Debugging output (optional, can be removed)
-                # print(f"Comparing PM ID {pm_instance.id} with Template {schedule_template.name}:")
-                # print(f"  Medication: {pm_instance.medication} vs {schedule_template.medication} -> {medication_match}")
-                # print(f"  Dose: {pm_instance.dosage} vs {schedule_template.dose} -> {dose_match}")
-                # print(f"  Unit: {pm_instance.unit} vs {schedule_template.unit} -> {unit_match}")
-                # print(f"  Intake Times: {pm_intake_times_set} vs {template_intake_times_set} -> {intake_times_match}")
-
-                if medication_match and dose_match and unit_match and intake_times_match:
-                    return True  # Found a match
-
-        return False  # No PatientMedication matched any template
+        return eval_result

endoreg_db/models/state/audit_ledger.py

@@ -89,7 +89,7 @@ class AuditLedger(models.Model):
         """
         payload = {
             "ts": self.ts.isoformat(),
-            "uid": str(self.user_id),
+            "uid": str(self.id),
             "obj": f"{self.object_type}:{self.object_pk}",
             "act": self.action,
             "data": self.data,
@@ -97,7 +97,7 @@ class AuditLedger(models.Model):
         }
         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.
 
@@ -115,7 +115,8 @@ 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.
 
@@ -142,8 +143,6 @@ class AuditLedger(models.Model):
             "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/raw_pdf.py

@@ -1,12 +1,12 @@
 """
-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.
 """
 
 import logging
 from enum import Enum
 from typing import TYPE_CHECKING
 
-from django.db import models
+from django.db import models, transaction
 
 from endoreg_db.models.state.anonymization import AnonymizationState
 
@@ -22,7 +22,9 @@ class RawPdfState(models.Model):
     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(
@@ -31,26 +33,39 @@ class RawPdfState(models.Model):
 
     # 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."
+        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.")
+    was_created = models.BooleanField(
+        default=True, help_text="True if this state was created for the first time."
+    )
 
-    # PDF metadata extraction state
+    # report metadata extraction state
     pdf_meta_extracted = models.BooleanField(
-        default=False, help_text="True if PDF metadata has been extracted."
+        default=False, help_text="True if report metadata has been extracted."
     )
 
     if TYPE_CHECKING:
@@ -58,7 +73,7 @@ class RawPdfState(models.Model):
 
     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.pk
@@ -79,25 +94,50 @@ class RawPdfState(models.Model):
     @property
     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 self.anonymization_validated:
-            return AnonymizationState.VALIDATED #  Validation in Frontend completed -> Views related to this /home/admin/endoreg-db/endoreg_db/views/anonymization/validate.py
+            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 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.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
+            return (
+                AnonymizationState.FAILED
+            )  # /home/admin/endoreg-db/endoreg_db/services/pdf_import.py
         if self.processing_started:
-            return AnonymizationState.STARTED # /home/admin/endoreg-db/endoreg_db/services/pdf_import.py
+            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.
@@ -106,13 +146,12 @@ class RawPdfState(models.Model):
             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.
@@ -123,7 +162,7 @@ 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.
@@ -134,18 +173,18 @@ 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.
@@ -156,7 +195,7 @@ 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.
@@ -167,7 +206,7 @@ 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.
@@ -177,5 +216,5 @@ class RawPdfState(models.Model):
             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/video.py

@@ -6,7 +6,7 @@ import logging
 from enum import Enum
 from typing import TYPE_CHECKING, Optional
 
-from django.db import models
+from django.db import models, transaction
 
 from endoreg_db.models.state.anonymization import AnonymizationState
 
@@ -22,14 +22,19 @@ class VideoState(models.Model):
     Uses BooleanFields for clear, distinct states.
     """
 
-
     # Frame related states
     if TYPE_CHECKING:
         video_file: models.OneToOneField["VideoFile"]
 
-    frames_extracted = models.BooleanField(default=False, help_text="True if raw frames have been extracted to files.")
-    frames_initialized = models.BooleanField(default=False, help_text="True if Frame DB objects have been created.")
-    frame_count = models.PositiveIntegerField(null=True, blank=True, help_text="Number of frames extracted/initialized.")
+    frames_extracted = models.BooleanField(
+        default=False, help_text="True if raw frames have been extracted to files."
+    )
+    frames_initialized = models.BooleanField(
+        default=False, help_text="True if Frame DB objects have been created."
+    )
+    frame_count = models.PositiveIntegerField(
+        null=True, blank=True, help_text="Number of frames extracted/initialized."
+    )
 
     # Metadata related states
     video_meta_extracted = models.BooleanField(
@@ -41,63 +46,57 @@ class VideoState(models.Model):
     )
 
     # AI / Annotation related states
-    initial_prediction_completed = models.BooleanField(default=False, help_text="True if initial AI prediction has run.")
-    lvs_created = models.BooleanField(default=False, help_text="True if LabelVideoSegments have been created from predictions.")
-    frame_annotations_generated = models.BooleanField(default=False, help_text="True if frame-level annotations have been generated from segments.")
+    initial_prediction_completed = models.BooleanField(
+        default=False, help_text="True if initial AI prediction has run."
+    )
+    lvs_created = models.BooleanField(
+        default=False,
+        help_text="True if LabelVideoSegments have been created from predictions.",
+    )
+    frame_annotations_generated = models.BooleanField(
+        default=False,
+        help_text="True if frame-level annotations have been generated from segments.",
+    )
 
     # 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."
+        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_started = models.BooleanField(default=False, help_text="True if the processing has started, but not yet completed.")
+    processing_started = models.BooleanField(
+        default=False,
+        help_text="True if the processing has started, but not yet completed.",
+    )
 
     # Timestamps
     date_created = models.DateTimeField(auto_now_add=True)
     date_modified = models.DateTimeField(auto_now=True)
 
     # Segment Annotation State
-    segment_annotations_created = models.BooleanField(default=False, help_text="True if segment annotations have been created from LabelVideoSegments.")
-    segment_annotations_validated = models.BooleanField(default=False, help_text="True if segment annotations have been validated.")
+    segment_annotations_created = models.BooleanField(
+        default=False,
+        help_text="True if segment annotations have been created from LabelVideoSegments.",
+    )
+    segment_annotations_validated = models.BooleanField(
+        default=False, help_text="True if segment annotations have been validated."
+    )
 
-    was_created = models.BooleanField(default=True, help_text="True if this state was created for the first time.")
+    was_created = models.BooleanField(
+        default=True, help_text="True if this state was created for the first time."
+    )
 
     objects = models.Manager()
 
-    def __str__(self):
-        # Find the related VideoFile's UUID if possible
-        video_uuid = "Unknown"
-        try:
-            # Access the related VideoFile via the reverse relation 'video_file'
-            if hasattr(self, "video_file") and self.video_file:
-                video_uuid = self.video_file.uuid
-        except Exception:
-            pass  # Ignore errors if relation doesn't exist or causes issues
-            pass  # Ignore errors if relation doesn't exist or causes issues
-
-        states = [
-            f"FramesExtracted={self.frames_extracted}",
-            f"FramesInit={self.frames_initialized}",
-            f"VideoMetaExtracted={self.video_meta_extracted}",
-            f"TextMetaExtracted={self.text_meta_extracted}",
-            f"PredictionDone={self.initial_prediction_completed}",
-            f"LvsCreated={self.lvs_created}",
-            f"Anonymized={self.anonymized}",
-            f"AnonymizationValidated={self.anonymization_validated}",
-            f"SensitiveMetaProcessed={self.sensitive_meta_processed}",
-            f"FrameCount={self.frame_count}"
-            if self.frame_count is not None
-            else "FrameCount=None",
-            f"SegmentAnnotationsCreated={self.segment_annotations_created}",
-            f"SegmentAnnotationsValidated={self.segment_annotations_validated}",
-            f"DateCreated={self.date_created.isoformat()}",
-            f"DateModified={self.date_modified.isoformat()}",
-        ]
-        return f"VideoState(Video:{video_uuid}): {', '.join(states)}"
 
     @property
     def anonymization_status(self) -> AnonymizationState:
@@ -105,9 +104,9 @@ class VideoState(models.Model):
         Fast, side‑effect‑free status resolution used by API & UI.
         """
         if self.anonymization_validated:
-            return AnonymizationState.VALIDATED # Validation in Frontend completed -> Views related to this /home/admin/endoreg-db/endoreg_db/views/anonymization/validate.py
+            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 AnonymizationState.DONE_PROCESSING_ANONYMIZATION # /home/admin/endoreg-db/endoreg_db/services/video_import.py /home/admin/endoreg-db/endoreg_db/views/video/reimport.py 
+            return AnonymizationState.DONE_PROCESSING_ANONYMIZATION  # /home/admin/endoreg-db/endoreg_db/services/video_import.py /home/admin/endoreg-db/endoreg_db/views/video/reimport.py
         if self.frames_extracted and not self.anonymized:
             return AnonymizationState.PROCESSING_ANONYMIZING
         if self.was_created and not self.frames_extracted:
@@ -120,6 +119,22 @@ class VideoState(models.Model):
             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.frames_extracted = False
+            self.save()
+
     # ---- Single‑responsibility mutators ---------------------------------
     def mark_sensitive_meta_processed(self, *, save: bool = True) -> None:
         self.sensitive_meta_processed = True
@@ -165,8 +180,8 @@ class VideoState(models.Model):
         Parameters:
             save (bool): If True, immediately saves the updated state to the database.
         """
-        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: