endoreg-db 0.8.9.2__py3-none-any.whl → 0.8.9.10__py3-none-any.whl

endoreg_db/models/state/processing_history/processing_history.py

@@ -0,0 +1,136 @@
+from typing import Optional
+from logging import getLogger
+from pathlib import Path
+from django.db import models
+from endoreg_db.utils.file_operations import get_content_hash_filename
+
+logger = getLogger(__name__)
+
+
+class ProcessingHistory(models.Model):
+    """
+    Processing history keyed by a stable file *content hash*.
+
+    - For videos: use VideoFile.video_hash (raw mp4 bytes)
+    - For reports: use RawPdfFile.pdf_hash (raw pdf bytes)
+
+    We *optionally* link back to a concrete model instance using
+    (content_type, object_id), but the logical identity is file_hash.
+    """
+
+    file_hash = models.CharField(
+        max_length=64,
+        primary_key=True,
+        help_text="Content hash of the original file (e.g. video_hash/pdf_hash).",
+        blank=True,
+    )
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    success = models.BooleanField(default=False, blank=True)
+
+    object_id = models.PositiveBigIntegerField(null=True, blank=True)
+
+    class Meta:
+        ordering = ["-created_at"]
+
+    # ------------------------------------------------------------------
+    # Core helpers
+    # ------------------------------------------------------------------
+    @staticmethod
+    def get_content_hash(path: Path):
+        return get_content_hash_filename(path)
+
+    @classmethod
+    def get_or_create_for_hash(
+        cls,
+        *,
+        file_hash: str,
+        obj: Optional[models.Model] = None,
+        success: Optional[bool] = None,
+    ) -> "ProcessingHistory":
+        """
+        Get or create history row for a given *file hash*.
+
+        - PK is file_hash
+        - Optionally set/overwrite:
+            - content_type/object_id
+            - success flag
+        """
+        defaults: dict[str, object] = {}
+        if success is not None:
+            defaults["success"] = success
+
+        ph, created = cls.objects.get_or_create(
+            file_hash=file_hash,
+            defaults=defaults,
+        )
+
+        changed: list[str] = []
+
+        if obj is not None:
+            if ph.object_id != obj.pk:
+                ph.object_id = obj.pk
+                changed.append("object_id")
+
+        if success is not None and ph.success != success:
+            ph.success = success
+            changed.append("success")
+
+        if changed:
+            ph.save(update_fields=changed)
+
+        if created:
+            logger.info(
+                "Created ProcessingHistory for hash=%s (success=%s).",
+                file_hash,
+                ph.success,
+            )
+
+        return ph
+
+    @classmethod
+    def has_history_for_hash(
+        cls,
+        *,
+        file_hash: str,
+        success: Optional[bool] = None,
+    ) -> bool:
+        qs = cls.objects.filter(file_hash=file_hash)
+        if success is not None:
+            qs = qs.filter(success=success)
+        return qs.exists()
+
+    # ------------------------------------------------------------------
+    # Convenience methods
+    # ------------------------------------------------------------------
+    @classmethod
+    def update_status(
+        cls,
+        *,
+        file_hash: str,
+        success: bool,
+        obj: Optional[models.Model] = None,
+    ) -> "ProcessingHistory":
+        return cls.get_or_create_for_hash(
+            file_hash=file_hash,
+            obj=obj,
+            success=success,
+        )
+
+    @classmethod
+    def mark_success(
+        cls,
+        *,
+        file_hash: str,
+        obj: Optional[models.Model] = None,
+    ) -> "ProcessingHistory":
+        return cls.update_status(file_hash=file_hash, success=True, obj=obj)
+
+    @classmethod
+    def mark_failure(
+        cls,
+        *,
+        file_hash: str,
+        obj: Optional[models.Model] = None,
+    ) -> "ProcessingHistory":
+        return cls.update_status(file_hash=file_hash, success=False, obj=obj)

endoreg_db/models/state/raw_pdf.py

@@ -3,7 +3,6 @@ Defines state tracking models related to report processing, including extraction
 """
 
 import logging
-from enum import Enum
 from typing import TYPE_CHECKING
 
 from django.db import models, transaction

endoreg_db/models/state/video.py

@@ -3,8 +3,7 @@ Defines state tracking models related to video processing.
 """
 
 import logging
-from enum import Enum
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from django.db import models, transaction
 
@@ -97,7 +96,6 @@ class VideoState(models.Model):
 
     objects = models.Manager()
 
-
     @property
     def anonymization_status(self) -> AnonymizationState:
         """
@@ -117,7 +115,7 @@ class VideoState(models.Model):
             return AnonymizationState.STARTED
         if self.anonymized:
             return AnonymizationState.ANONYMIZED
-        
+
         return AnonymizationState.NOT_STARTED
 
     def mark_processing_not_started(self) -> None:

endoreg_db/models/utils.py

@@ -23,8 +23,10 @@ TRANSCODING_DIR = data_paths["transcoding"]
 FRAME_DIR = data_paths["frame"]
 WEIGHTS_DIR = data_paths["weights"]
 REPORT_DIR = data_paths["import_report"]
-DOCUMENT_DIR = data_paths["documents"] #TODO Verify if this is still used and assign correct dir
-
+DOCUMENT_DIR = data_paths[
+    "documents"
+]  # TODO Verify if this is still used and assign correct dir
+ANONYM_VIDEO_DIR = data_paths["anonym_video"]
 TEST_RUN = os.environ.get("TEST_RUN", "False")
 TEST_RUN = TEST_RUN.lower() == "true"
 

endoreg_db/queries/__init__.py

@@ -1,7 +1,3 @@
-from .annotations import (
-    generate_legacy_dataset_output
-)
+from .annotations import generate_legacy_dataset_output
 
-__all__ = [
-    "generate_legacy_dataset_output"  
-]
+__all__ = ["generate_legacy_dataset_output"]

endoreg_db/queries/annotations/__init__.py

@@ -1,3 +1 @@
-from .legacy import (
-    get_legacy_annotations_for_labelset, generate_legacy_dataset_output
-)
+from .legacy import get_legacy_annotations_for_labelset, generate_legacy_dataset_output

endoreg_db/queries/annotations/legacy.py

@@ -1,5 +1,5 @@
 from ...models import LabelSet, ImageClassificationAnnotation
-from django.db.models import Q, F
+from django.db.models import F
 from django.db import models
 from tqdm import tqdm
 from collections import defaultdict
@@ -69,7 +69,6 @@ from collections import defaultdict
 #     return organized_annotations
 
 
-
 def get_legacy_annotations_for_labelset(labelset_name, version=None):
     """
     ... [rest of your docstring]
@@ -79,7 +78,9 @@ def get_legacy_annotations_for_labelset(labelset_name, version=None):
     if version:
         labelset = LabelSet.objects.get(name=labelset_name, version=version)
     else:
-        labelset = LabelSet.objects.filter(name=labelset_name).order_by('-version').first()
+        labelset = (
+            LabelSet.objects.filter(name=labelset_name).order_by("-version").first()
+        )
         if not labelset:
             raise ValueError(f"No label set found with the name: {labelset_name}")
 
@@ -87,36 +88,37 @@ def get_legacy_annotations_for_labelset(labelset_name, version=None):
     labels_in_set = labelset.labels.all()
 
     # Get the most recent annotations for each frame/label combination
-    annotations = (ImageClassificationAnnotation.objects
-                   .filter(label__in=labels_in_set)
-                   .select_related('legacy_image', 'label')  # Reduce number of queries
-                   .annotate(
-                        latest_annotation=models.Window(
-                            expression=models.functions.RowNumber(),
-                            partition_by=[F('legacy_image'), F('label')],
-                            order_by=F('date_modified').desc()
-                        )
-                    ).filter(latest_annotation=1))
+    annotations = (
+        ImageClassificationAnnotation.objects.filter(label__in=labels_in_set)
+        .select_related("legacy_image", "label")  # Reduce number of queries
+        .annotate(
+            latest_annotation=models.Window(
+                expression=models.functions.RowNumber(),
+                partition_by=[F("legacy_image"), F("label")],
+                order_by=F("date_modified").desc(),
+            )
+        )
+        .filter(latest_annotation=1)
+    )
 
     # Organize the annotations by image/frame using a defaultdict
-    organized_annotations_dict = defaultdict(lambda: {
-        "legacy_image": None,
-        "annotations": []
-    })
+    organized_annotations_dict = defaultdict(
+        lambda: {"legacy_image": None, "annotations": []}
+    )
 
     for annotation in tqdm(annotations):
         organized_entry = organized_annotations_dict[annotation.legacy_image.id]
         organized_entry["legacy_image"] = annotation.legacy_image
-        organized_entry["annotations"].append({
-            "label": annotation.label.name,
-            "value": annotation.value
-        })
+        organized_entry["annotations"].append(
+            {"label": annotation.label.name, "value": annotation.value}
+        )
 
     # Convert organized_annotations_dict to a list
     organized_annotations = list(organized_annotations_dict.values())
 
     return organized_annotations
 
+
 def generate_legacy_dataset_output(labelset_name, version=None):
     """
     Generate an output suitable for creating PyTorch datasets.
@@ -143,15 +145,24 @@ def generate_legacy_dataset_output(labelset_name, version=None):
     for entry in organized_annotations:
         # Prepare a dictionary for each frame
         frame_data = {
-            "path": entry['legacy_image'].image.path,  # Assuming 'image' field stores the file path
-            "labels": [-1] * len(all_labels)  # Initialize with -1 for all labels
+            "path": entry[
+                "legacy_image"
+            ].image.path,  # Assuming 'image' field stores the file path
+            "labels": [-1] * len(all_labels),  # Initialize with -1 for all labels
         }
 
         # Update the labels based on the annotations
-        for annotation in entry['annotations']:
-            index = next((i for i, label in enumerate(all_labels) if label.name == annotation['label']), None)
+        for annotation in entry["annotations"]:
+            index = next(
+                (
+                    i
+                    for i, label in enumerate(all_labels)
+                    if label.name == annotation["label"]
+                ),
+                None,
+            )
             if index is not None:
-                frame_data['labels'][index] = int(annotation['value'])
+                frame_data["labels"][index] = int(annotation["value"])
 
         dataset_output.append(frame_data)
 

endoreg_db/root_urls.py

@@ -1,5 +1,4 @@
 # endoreg_db/root_urls.py
-from django.contrib import admin
 from django.urls import include, path
 from django.http import HttpResponse
 from django.conf import settings
@@ -8,16 +7,16 @@ from django.conf.urls.static import static
 # Import raw API urlpatterns (no prefix) from your API urls package
 from endoreg_db.urls import urlpatterns as api_urlpatterns
 
+
 def public_home(_request):
     return HttpResponse("Public home – no login required.")
 
+
 urlpatterns = [
     path("", public_home, name="public_home"),
-    #path("admin/", admin.site.urls),
-
+    # path("admin/", admin.site.urls),
     # Mount ALL API endpoints under /api/
     path("api/", include((api_urlpatterns, "endoreg_db"), namespace="api")),
-
     # OIDC (mozilla-django-oidc provides /oidc/authenticate/ and /oidc/callback/)
     path("oidc/", include("mozilla_django_oidc.urls")),
 ]

endoreg_db/schemas/examination_evaluation.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from pydantic import BaseModel, ConfigDict, Field
 from typing import List, Optional
 
+
 class RequirementEval(BaseModel):
     id: int
     name: str
@@ -10,6 +11,7 @@ class RequirementEval(BaseModel):
     satisfied: bool
     message: Optional[str] = None  # optional explanation
 
+
 class RequirementSetEval(BaseModel):
     id: int
     name: str
@@ -18,6 +20,7 @@ class RequirementSetEval(BaseModel):
     requirements: List[RequirementEval] = Field(default_factory=list)
     linked_sets: List["RequirementSetEval"] = Field(default_factory=list)
 
+
 class ExaminationEvalReport(BaseModel):
     examination_id: int | None = None
     summary: dict