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

endoreg_db/models/metadata/video_prediction_meta.py

@@ -7,9 +7,7 @@ from django.db import models
 
 from endoreg_db.models.label import LabelSet
 
-from ..label.label_video_segment import (
-    LabelVideoSegment,
-)
+from ..label.label_video_segment import LabelVideoSegment
 from ..utils import find_segments_in_prediction_array
 
 logger = logging.getLogger(__name__)
@@ -49,7 +47,12 @@ class VideoPredictionMeta(models.Model):
         label_video_segments: "models.Manager[LabelVideoSegment]"
 
     class Meta:
-        constraints = [models.UniqueConstraint(fields=["model_meta", "video_file"], name="unique_prediction_per_video_model")]
+        constraints = [
+            models.UniqueConstraint(
+                fields=["model_meta", "video_file"],
+                name="unique_prediction_per_video_model",
+            )
+        ]
         indexes = [
             models.Index(fields=["model_meta", "video_file"]),
         ]
@@ -72,11 +75,15 @@ class VideoPredictionMeta(models.Model):
     def __str__(self):
         try:
             video_obj = self.get_video()
-            return f"Prediction Meta for Video {video_obj.uuid} - {self.model_meta.name}"
+            return f"Prediction Meta for Video {video_obj.video_hash} - {self.model_meta.name}"
         except ValueError:
             return f"Prediction Meta {self.pk} (Error: No VideoFile) - {self.model_meta.name}"
         except Exception as e:
-            logger.warning("Error generating string representation for VideoPredictionMeta %s: %s", self.pk, e)
+            logger.warning(
+                "Error generating string representation for VideoPredictionMeta %s: %s",
+                self.pk,
+                e,
+            )
             return f"Prediction Meta {self.pk} (Error: {e})"
 
     def get_labelset(self) -> Optional["LabelSet"]:
@@ -123,19 +130,29 @@ class VideoPredictionMeta(models.Model):
         num_frames = video_obj.frame_count
 
         if num_frames is None or num_frames <= 0:
-            logger.warning(f"Cannot calculate prediction array for {video_obj} with invalid frame count ({num_frames}).")
+            logger.warning(
+                f"Cannot calculate prediction array for {video_obj} with invalid frame count ({num_frames})."
+            )
             return
 
         if not label_list:
-            logger.warning(f"No labels found for model {model_meta}. Cannot calculate prediction array.")
+            logger.warning(
+                f"No labels found for model {model_meta}. Cannot calculate prediction array."
+            )
             return
 
         prediction_array = np.zeros((num_frames, len(label_list)))
 
-        base_pred_qs = ImageClassificationAnnotation.objects.filter(model_meta=model_meta, frame__video_file=video_obj)
+        base_pred_qs = ImageClassificationAnnotation.objects.filter(
+            model_meta=model_meta, frame__video_file=video_obj
+        )
 
         for i, label in enumerate(label_list):
-            predictions = base_pred_qs.filter(label=label).order_by("frame__frame_number").values_list("frame__frame_number", "float_value")
+            predictions = (
+                base_pred_qs.filter(label=label)
+                .order_by("frame__frame_number")
+                .values_list("frame__frame_number", "float_value")
+            )
 
             confidences = np.full(num_frames, 0.5)
             found_predictions = False
@@ -144,19 +161,27 @@ class VideoPredictionMeta(models.Model):
                     confidences[frame_num] = confidence
                     found_predictions = True
                 else:
-                    logger.warning(f"Prediction found for out-of-bounds frame number {frame_num} (max: {num_frames - 1}). Skipping.")
+                    logger.warning(
+                        f"Prediction found for out-of-bounds frame number {frame_num} (max: {num_frames - 1}). Skipping."
+                    )
 
             if not found_predictions:
-                logger.warning(f"No predictions found for label '{label.name}' in {video_obj}. Using default confidence.")
+                logger.warning(
+                    f"No predictions found for label '{label.name}' in {video_obj}. Using default confidence."
+                )
 
-            smooth_confidences = self.apply_running_mean(confidences, window_size_in_seconds)
+            smooth_confidences = self.apply_running_mean(
+                confidences, window_size_in_seconds
+            )
             binary_predictions = smooth_confidences > 0.5
             prediction_array[:, i] = binary_predictions
 
         self.save_prediction_array(prediction_array)
         logger.info(f"Calculated and saved prediction array for {self}")
 
-    def apply_running_mean(self, confidence_array, window_size_in_seconds: Optional[float] = None):
+    def apply_running_mean(
+        self, confidence_array, window_size_in_seconds: Optional[float] = None
+    ):
         """
         Apply a running mean filter to the confidence array for smoothing, assuming a padding
         of 0.5 for the edges.
@@ -165,7 +190,9 @@ class VideoPredictionMeta(models.Model):
         fps = video_obj.get_fps()
 
         if fps is None or fps <= 0:
-            logger.warning(f"Invalid FPS ({fps}) for {video_obj}. Cannot apply running mean. Returning original array.")
+            logger.warning(
+                f"Invalid FPS ({fps}) for {video_obj}. Cannot apply running mean. Returning original array."
+            )
             return confidence_array
 
         if not window_size_in_seconds:
@@ -190,19 +217,25 @@ class VideoPredictionMeta(models.Model):
         running_mean = running_mean[start_index:end_index]
 
         if running_mean.shape != confidence_array.shape:
-            logger.warning(f"Running mean output shape {running_mean.shape} differs from input {confidence_array.shape}. Check padding/slicing.")
+            logger.warning(
+                f"Running mean output shape {running_mean.shape} differs from input {confidence_array.shape}. Check padding/slicing."
+            )
             return confidence_array
 
         return running_mean
 
-    def create_video_segments_for_label(self, segments: List[Tuple[int, int]], label: "Label"):
+    def create_video_segments_for_label(
+        self, segments: List[Tuple[int, int]], label: "Label"
+    ):
         """
         Creates LabelVideoSegment instances for the given label and segments.
         """
         from endoreg_db.models import InformationSource
 
         video_obj = self.get_video()
-        information_source, _ = InformationSource.objects.get_or_create(name="prediction")
+        information_source, _ = InformationSource.objects.get_or_create(
+            name="prediction"
+        )
 
         segments_to_create = []
         for start_frame, end_frame in segments:
@@ -215,17 +248,27 @@ class VideoPredictionMeta(models.Model):
                 "video_file": video_obj,
             }
             if not LabelVideoSegment.objects.filter(
-                video_file=video_obj, prediction_meta=self, label=label, start_frame_number=start_frame, end_frame_number=end_frame
+                video_file=video_obj,
+                prediction_meta=self,
+                label=label,
+                start_frame_number=start_frame,
+                end_frame_number=end_frame,
             ).exists():
                 segments_to_create.append(LabelVideoSegment(**segment_data))
 
         if segments_to_create:
             LabelVideoSegment.objects.bulk_create(segments_to_create)
-            logger.info(f"Created {len(segments_to_create)} video segments for label '{label.name}' in {video_obj}.")
+            logger.info(
+                f"Created {len(segments_to_create)} video segments for label '{label.name}' in {video_obj}."
+            )
         else:
-            logger.info(f"No new video segments needed for label '{label.name}' in {video_obj}.")
+            logger.info(
+                f"No new video segments needed for label '{label.name}' in {video_obj}."
+            )
 
-    def create_video_segments(self, segment_length_threshold_in_s: Optional[float] = None):
+    def create_video_segments(
+        self, segment_length_threshold_in_s: Optional[float] = None
+    ):
         """
         Generates LabelVideoSegments based on the stored prediction array.
         """
@@ -236,7 +279,9 @@ class VideoPredictionMeta(models.Model):
         fps = video_obj.get_fps()
 
         if fps is None or fps <= 0:
-            logger.warning(f"Cannot create video segments for {video_obj} with invalid FPS ({fps}).")
+            logger.warning(
+                f"Cannot create video segments for {video_obj} with invalid FPS ({fps})."
+            )
             return
 
         min_frame_length = int(segment_length_threshold_in_s * fps)
@@ -250,17 +295,25 @@ class VideoPredictionMeta(models.Model):
             self.calculate_prediction_array()
             prediction_array = self.get_prediction_array()
             if prediction_array is None:
-                logger.error(f"Failed to get or calculate prediction array for {self}. Cannot create segments.")
+                logger.error(
+                    f"Failed to get or calculate prediction array for {self}. Cannot create segments."
+                )
                 return
 
         if prediction_array.shape[1] != len(label_list):
-            logger.warning(f"Prediction array shape {prediction_array.shape} incompatible with label list length {len(label_list)} for {self}.")
+            logger.warning(
+                f"Prediction array shape {prediction_array.shape} incompatible with label list length {len(label_list)} for {self}."
+            )
             return
 
-        logger.info(f"Creating video segments for {self} (min length: {min_frame_length} frames)...")
+        logger.info(
+            f"Creating video segments for {self} (min length: {min_frame_length} frames)..."
+        )
         for i, label in enumerate(label_list):
             binary_predictions = prediction_array[:, i].astype(bool)
-            segments = find_segments_in_prediction_array(binary_predictions, min_frame_length)
+            segments = find_segments_in_prediction_array(
+                binary_predictions, min_frame_length
+            )
             if segments:
                 self.create_video_segments_for_label(segments, label)
         logger.info(f"Finished creating video segments for {self}.")

endoreg_db/models/operation_log.py

@@ -0,0 +1,63 @@
+from django.conf import settings
+from django.db import models
+
+
+class OperationLog(models.Model):
+    """
+    Lightweight log of user-triggered operations (audit-like).
+    """
+
+    # actor_id – internal Django user ID (primary key)
+    # Who did it
+    actor_user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="operation_logs",
+    )
+    actor_username = models.CharField(max_length=150, blank=True)
+    actor_email = models.EmailField(blank=True)
+    actor_keycloak_id = models.CharField(
+        max_length=255,
+        blank=True,
+        help_text="Keycloak subject/ID if you later want to store it.",
+    )
+
+    # What happened
+    action = models.CharField(
+        max_length=100,
+        help_text="e.g. 'anonymization.start', 'anonymization.validate'",
+    )
+    http_method = models.CharField(max_length=10, blank=True)
+    path = models.CharField(max_length=512, blank=True)
+
+    # On what resource
+    resource_type = models.CharField(
+        max_length=50,
+        blank=True,
+        help_text="e.g. 'video', 'pdf'",
+    )
+    resource_id = models.IntegerField(
+        null=True,
+        blank=True,
+        help_text="ID of VideoFile / RawPdfFile etc.",
+    )
+
+    # State before/after
+    status_before = models.CharField(max_length=50, blank=True)
+    status_after = models.CharField(max_length=50, blank=True)
+
+    # Extra info
+    meta = models.JSONField(null=True, blank=True)
+
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    #
+    class Meta:
+        verbose_name = "Operation Log"
+        verbose_name_plural = "Operation Logs"
+        ordering = ["-created_at"]
+
+    def __str__(self) -> str:
+        return f"[{self.created_at.isoformat()}] {self.action} by {self.actor_username or 'unknown'}"

endoreg_db/models/other/__init__.py

@@ -22,19 +22,19 @@ from .unit import Unit
 from .tag import Tag
 
 __all__ = [
-    'Material',
-    'Resource',
-    'TransportRoute',
-    'Waste',
-    'BaseValueDistribution',
-    'NumericValueDistribution',
-    'SingleCategoricalValueDistribution',
-    'MultipleCategoricalValueDistribution',
-    'DateValueDistribution',
+    "Material",
+    "Resource",
+    "TransportRoute",
+    "Waste",
+    "BaseValueDistribution",
+    "NumericValueDistribution",
+    "SingleCategoricalValueDistribution",
+    "MultipleCategoricalValueDistribution",
+    "DateValueDistribution",
     "Gender",
     "InformationSource",
     "InformationSourceType",
     "Unit",
     "EmissionFactor",
     "Tag",
-]
+]

endoreg_db/models/other/distribution/__init__.py

@@ -1,18 +1,20 @@
-'''Module for distribution models.'''
+"""Module for distribution models."""
 
 from .base_value_distribution import BaseValueDistribution
 from .numeric_value_distribution import NumericValueDistribution
 from .single_categorical_value_distribution import SingleCategoricalValueDistribution
-from .multiple_categorical_value_distribution import MultipleCategoricalValueDistribution
+from .multiple_categorical_value_distribution import (
+    MultipleCategoricalValueDistribution,
+)
 from .date_value_distribution import DateValueDistribution
 
 
 __all__ = [
-    'BaseValueDistribution',
-    'NumericValueDistribution',
-    'SingleCategoricalValueDistribution',
-    'MultipleCategoricalValueDistribution',
-    'DateValueDistribution',
+    "BaseValueDistribution",
+    "NumericValueDistribution",
+    "SingleCategoricalValueDistribution",
+    "MultipleCategoricalValueDistribution",
+    "DateValueDistribution",
 ]
 
 # Example Usage

endoreg_db/models/other/distribution/base_value_distribution.py

@@ -1,9 +1,11 @@
 from django.db import models
 
+
 class BaseValueDistribution(models.Model):
     """
     Abstract base class for value distributions.
     """
+
     name = models.CharField(max_length=100)
 
     class Meta:
@@ -15,6 +17,6 @@ class BaseValueDistribution(models.Model):
         Must be implemented by subclasses.
         """
         raise NotImplementedError("Subclasses must implement this method")
-    
+
     def natural_key(self):
         return (self.name,)

endoreg_db/models/other/distribution/date_value_distribution.py

@@ -43,7 +43,9 @@ class DateValueDistribution(BaseValueDistribution):
     date_min = models.DateField(blank=True, null=True)
     date_max = models.DateField(blank=True, null=True)
     date_mean = models.DateField(blank=True, null=True)
-    date_std_dev = models.IntegerField(blank=True, null=True)  # Standard deviation in days
+    date_std_dev = models.IntegerField(
+        blank=True, null=True
+    )  # Standard deviation in days
 
     # Timedelta-related fields
     timedelta_days_min = models.IntegerField(blank=True, null=True)
@@ -127,18 +129,30 @@ class DateValueDistribution(BaseValueDistribution):
             mean_ordinal = self.date_mean_safe.toordinal()
             std_dev_days = self.date_std_dev_safe
             random_ordinal = int(np.random.normal(mean_ordinal, std_dev_days))
-            random_ordinal = np.clip(random_ordinal, self.date_min_safe.toordinal(), self.date_max_safe.toordinal())
+            random_ordinal = np.clip(
+                random_ordinal,
+                self.date_min_safe.toordinal(),
+                self.date_max_safe.toordinal(),
+            )
             return date.fromordinal(random_ordinal)
         else:
             raise ValueError("Unsupported distribution type")
 
     def _generate_timedelta_value(self):
         if self.distribution_type == "uniform":
-            random_days = np.random.randint(self.timedelta_days_min_safe, self.timedelta_days_max_safe + 1)
+            random_days = np.random.randint(
+                self.timedelta_days_min_safe, self.timedelta_days_max_safe + 1
+            )
 
         elif self.distribution_type == "normal":
-            random_days = int(np.random.normal(self.timedelta_days_mean_safe, self.timedelta_days_std_dev_safe))
-            random_days = np.clip(random_days, self.timedelta_days_min_safe, self.timedelta_days_max_safe)
+            random_days = int(
+                np.random.normal(
+                    self.timedelta_days_mean_safe, self.timedelta_days_std_dev_safe
+                )
+            )
+            random_days = np.clip(
+                random_days, self.timedelta_days_min_safe, self.timedelta_days_max_safe
+            )
 
         else:
             raise ValueError("Unsupported distribution type")

endoreg_db/models/other/distribution/multiple_categorical_value_distribution.py

@@ -19,7 +19,9 @@ class MultipleCategoricalValueDistribution(BaseValueDistribution):
     categories = models.JSONField()  # { "category": "probability", ... }
     min_count = models.IntegerField()
     max_count = models.IntegerField()
-    count_distribution_type = models.CharField(max_length=20, choices=[("uniform", "Uniform"), ("normal", "Normal")])
+    count_distribution_type = models.CharField(
+        max_length=20, choices=[("uniform", "Uniform"), ("normal", "Normal")]
+    )
     count_mean = models.FloatField(null=True, blank=True)
     count_std_dev = models.FloatField(null=True, blank=True)
 

endoreg_db/models/other/distribution/numeric_value_distribution.py

@@ -35,11 +35,27 @@ class NumericValueDistribution(BaseValueDistribution):
     distribution_type = models.CharField(max_length=20, choices=DISTRIBUTION_CHOICES)
     min_descriptor = models.CharField(max_length=20)
     max_descriptor = models.CharField(max_length=20)
-    min_value = models.FloatField(blank=True, null=True, help_text="Lower hard limit for generated values")
-    max_value = models.FloatField(blank=True, null=True, help_text="Upper hard limit for generated values")
-    mean = models.FloatField(blank=True, null=True, help_text="Mean used for normal or skewed normal distributions")
-    std_dev = models.FloatField(blank=True, null=True, help_text="Standard deviation for bell-shaped distributions")
-    skewness = models.FloatField(blank=True, null=True, help_text="Shape parameter for skewed normal distributions")
+    min_value = models.FloatField(
+        blank=True, null=True, help_text="Lower hard limit for generated values"
+    )
+    max_value = models.FloatField(
+        blank=True, null=True, help_text="Upper hard limit for generated values"
+    )
+    mean = models.FloatField(
+        blank=True,
+        null=True,
+        help_text="Mean used for normal or skewed normal distributions",
+    )
+    std_dev = models.FloatField(
+        blank=True,
+        null=True,
+        help_text="Standard deviation for bell-shaped distributions",
+    )
+    skewness = models.FloatField(
+        blank=True,
+        null=True,
+        help_text="Shape parameter for skewed normal distributions",
+    )
 
     @property
     def min_value_safe(self):
@@ -74,7 +90,9 @@ class NumericValueDistribution(BaseValueDistribution):
     def generate_value(self, lab_value: "LabValue", patient: "Patient"):
         """Generate a value based on the distribution rules."""
 
-        default_normal_range_dict = lab_value.get_normal_range(patient.age_safe, patient.gender)
+        default_normal_range_dict = lab_value.get_normal_range(
+            patient.age_safe, patient.gender
+        )
         assert isinstance(default_normal_range_dict, dict)
 
         if self.distribution_type == "uniform":
@@ -150,7 +168,10 @@ class NumericValueDistribution(BaseValueDistribution):
         value_function_dict = self.parse_value_descriptor(self.min_descriptor)
         value_function_dict.update(self.parse_value_descriptor(self.max_descriptor))
 
-        result_dict = {key: value_function(default_normal_range_dict[key]) for key, value_function in value_function_dict.items()}
+        result_dict = {
+            key: value_function(default_normal_range_dict[key])
+            for key, value_function in value_function_dict.items()
+        }
 
         # generate value
         return float(np.random.uniform(result_dict["min"], result_dict["max"]))
@@ -179,8 +200,12 @@ class NumericValueDistribution(BaseValueDistribution):
 
     def _validate_normal_parameters(self) -> None:
         if self.mean is None or self.std_dev is None:
-            raise ValueError(f"Normal distribution '{getattr(self, 'name', self.pk)}' requires both mean and std_dev.")
+            raise ValueError(
+                f"Normal distribution '{getattr(self, 'name', self.pk)}' requires both mean and std_dev."
+            )
 
     def _validate_skewed_normal_parameters(self) -> None:
         if self.mean is None or self.std_dev is None or self.skewness is None:
-            raise ValueError(f"Skewed normal distribution '{getattr(self, 'name', self.pk)}' requires mean, std_dev, and skewness.")
+            raise ValueError(
+                f"Skewed normal distribution '{getattr(self, 'name', self.pk)}' requires mean, std_dev, and skewness."
+            )

endoreg_db/models/other/emission/__init__.py

@@ -1,5 +1,5 @@
 from .emission_factor import EmissionFactor
 
 __all__ = [
-    'EmissionFactor',
+    "EmissionFactor",
 ]

endoreg_db/models/other/emission/emission_factor.py

@@ -86,9 +86,15 @@ class EmissionFactor(models.Model):
         from ...administration.product import ReferenceProduct
 
         reference_products = []
-        reference_products += ReferenceProduct.objects.filter(emission_factor_total=self)
-        reference_products += ReferenceProduct.objects.filter(emission_factor_package=self)
-        reference_products += ReferenceProduct.objects.filter(emission_factor_product=self)
+        reference_products += ReferenceProduct.objects.filter(
+            emission_factor_total=self
+        )
+        reference_products += ReferenceProduct.objects.filter(
+            emission_factor_package=self
+        )
+        reference_products += ReferenceProduct.objects.filter(
+            emission_factor_product=self
+        )
 
         return reference_products
 

endoreg_db/models/other/information_source.py

@@ -58,19 +58,27 @@ class InformationSource(models.Model):
         def examinations(self) -> "models.manager.RelatedManager[Examination]": ...
 
         @property
-        def examination_indications(self) -> "models.manager.RelatedManager[ExaminationIndication]": ...
+        def examination_indications(
+            self,
+        ) -> "models.manager.RelatedManager[ExaminationIndication]": ...
 
         @property
-        def examination_times(self) -> "models.manager.RelatedManager[ExaminationTime]": ...
+        def examination_times(
+            self,
+        ) -> "models.manager.RelatedManager[ExaminationTime]": ...
 
         @property
         def findings(self) -> "models.manager.RelatedManager[Finding]": ...
 
         @property
-        def finding_interventions(self) -> "models.manager.RelatedManager[FindingIntervention]": ...
+        def finding_interventions(
+            self,
+        ) -> "models.manager.RelatedManager[FindingIntervention]": ...
 
         @property
-        def finding_classifications(self) -> "models.manager.RelatedManager[FindingClassification]": ...
+        def finding_classifications(
+            self,
+        ) -> "models.manager.RelatedManager[FindingClassification]": ...
 
     class Meta:
         verbose_name = "Information Source"
@@ -145,7 +153,9 @@ class InformationSourceType(models.Model):
         try:
             return cls.objects.get(name="prediction")
         except cls.DoesNotExist as e:
-            raise cls.DoesNotExist("The 'prediction' InformationSourceType was not found. Please check your data fixtures or initial data migrations.") from e
+            raise cls.DoesNotExist(
+                "The 'prediction' InformationSourceType was not found. Please check your data fixtures or initial data migrations."
+            ) from e
 
     @classmethod
     def get_manual_annotation_type(cls) -> "InformationSourceType":

endoreg_db/models/other/material.py

@@ -16,7 +16,9 @@ class Material(models.Model):
     objects = MaterialManager()
 
     name = models.CharField(max_length=255)
-    emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
+    emission_factor = models.ForeignKey(
+        "EmissionFactor", on_delete=models.SET_NULL, null=True
+    )
 
     if TYPE_CHECKING:
         emission_factor: models.ForeignKey["EmissionFactor|None"]

endoreg_db/models/other/transport_route.py

@@ -20,7 +20,9 @@ class TransportRoute(models.Model):
 
     distance = models.FloatField()
     name = models.CharField(max_length=255)
-    emission_factor = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True)
+    emission_factor = models.ForeignKey(
+        "EmissionFactor", on_delete=models.SET_NULL, null=True
+    )
     unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
 
     if TYPE_CHECKING:

endoreg_db/models/other/unit.py

@@ -15,8 +15,12 @@ class Unit(models.Model):
     objects = UnitManager()
 
     name = models.CharField(max_length=100)  # e.g. "Centimeter"
-    description = models.CharField(max_length=100, blank=True, null=True)  # e.g. "centimeters", "milimeters", "inches"
-    abbreviation = models.CharField(max_length=25, blank=True, null=True)  # e.g. "cm", "mm", "in"
+    description = models.CharField(
+        max_length=100, blank=True, null=True
+    )  # e.g. "centimeters", "milimeters", "inches"
+    abbreviation = models.CharField(
+        max_length=25, blank=True, null=True
+    )  # e.g. "cm", "mm", "in"
 
     if TYPE_CHECKING:
         unit_product_materials: models.QuerySet["ProductMaterial"]

endoreg_db/models/report/report.py

@@ -3,4 +3,3 @@ from django.db import models
 
 class Report(models.Model):
     name = models.CharField(max_length=100, unique=True)
-