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

endoreg_db/models/metadata/video_prediction_logic.py

@@ -1,20 +1,22 @@
 import logging
-from typing import TYPE_CHECKING, List, Tuple, Optional
+from typing import TYPE_CHECKING, List, Optional, Tuple
+
 import numpy as np
 
-# Import necessary models and utils used by the logic
-from ..utils import find_segments_in_prediction_array
 from ..label.label_video_segment import LabelVideoSegment
 
+# Import necessary models and utils used by the logic
+from ..utils import find_segments_in_prediction_array
 
 logger = logging.getLogger(__name__)
 
+# TODO configure via settings
 DEFAULT_WINDOW_SIZE_IN_SECONDS_FOR_RUNNING_MEAN = 1.5
 DEFAULT_VIDEO_SEGMENT_LENGTH_THRESHOLD_IN_S = 1.0
 
 if TYPE_CHECKING:
-    from .video_prediction_meta import VideoPredictionMeta
     from ..label import Label
+    from .video_prediction_meta import VideoPredictionMeta
 
 
 def apply_running_mean_logic(instance: "VideoPredictionMeta", confidence_array: np.ndarray, window_size_in_seconds: Optional[float] = None) -> np.ndarray:
@@ -63,6 +65,7 @@ def calculate_prediction_array_logic(instance: "VideoPredictionMeta", window_siz
     Does not save the array itself.
     """
     from ..label import ImageClassificationAnnotation
+
     video_obj = instance.get_video()
     model_meta = instance.model_meta
     label_list = instance.get_label_list()
@@ -78,15 +81,10 @@ def calculate_prediction_array_logic(instance: "VideoPredictionMeta", window_siz
 
     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", "confidence"
-        )
+        predictions = base_pred_qs.filter(label=label).order_by("frame__frame_number").values_list("frame__frame_number", "confidence")
 
         # Initialize with 0.5 (neutral confidence)
         confidences = np.full(num_frames, 0.5)
@@ -96,14 +94,12 @@ def calculate_prediction_array_logic(instance: "VideoPredictionMeta", window_siz
                 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.")
 
-        smooth_confidences = apply_running_mean_logic(
-            instance, confidences, window_size_in_seconds
-        )
+        smooth_confidences = apply_running_mean_logic(instance, confidences, window_size_in_seconds)
         # Threshold smoothed confidences
         binary_predictions = smooth_confidences > 0.5
         prediction_array[:, i] = binary_predictions
@@ -116,6 +112,7 @@ def create_video_segments_for_label_logic(instance: "VideoPredictionMeta", segme
     Creates LabelVideoSegment instances for the given label and segments.
     """
     from ..other import InformationSource
+
     video_obj = instance.get_video()
     information_source, _ = InformationSource.objects.get_or_create(name="prediction")
 
@@ -131,11 +128,7 @@ def create_video_segments_for_label_logic(instance: "VideoPredictionMeta", segme
         }
         # Check for existence before creating the object instance
         if not LabelVideoSegment.objects.filter(
-            video_file=video_obj,
-            prediction_meta=instance,
-            label=label,
-            start_frame_number=start_frame,
-            end_frame_number=end_frame
+            video_file=video_obj, prediction_meta=instance, label=label, start_frame_number=start_frame, end_frame_number=end_frame
         ).exists():
             segments_to_create.append(LabelVideoSegment(**segment_data))
 
@@ -161,7 +154,7 @@ def create_video_segments_logic(instance: "VideoPredictionMeta", segment_length_
         return
 
     min_frame_length = int(segment_length_threshold_in_s * fps)
-    min_frame_length = max(min_frame_length, 1) # Ensure minimum length is at least 1
+    min_frame_length = max(min_frame_length, 1)  # Ensure minimum length is at least 1
 
     label_list = instance.get_label_list()
     if not label_list:
@@ -171,8 +164,8 @@ def create_video_segments_logic(instance: "VideoPredictionMeta", segment_length_
     prediction_array = instance.get_prediction_array()
     if prediction_array is None:
         logger.info(f"Prediction array not found for {instance}. Calculating...")
-        instance.calculate_prediction_array() # This will save the array internally
-        prediction_array = instance.get_prediction_array() # Fetch again
+        instance.calculate_prediction_array()  # This will save the array internally
+        prediction_array = instance.get_prediction_array()  # Fetch again
         if prediction_array is None:
             logger.error(f"Failed to get or calculate prediction array for {instance}. Cannot create segments.")
             return

endoreg_db/models/metadata/video_prediction_meta.py

@@ -1,25 +1,25 @@
-from typing import TYPE_CHECKING, Optional, List, Tuple
-from django.db import models
 import logging
+import pickle
+from typing import TYPE_CHECKING, List, Optional, Tuple
+
+import numpy as np
+from django.db import models
 
 from endoreg_db.models.label import LabelSet
 
 from ..label.label_video_segment import (
     LabelVideoSegment,
-
 )
 from ..utils import find_segments_in_prediction_array
 
-import numpy as np
-import pickle
-
 logger = logging.getLogger(__name__)
 
 DEFAULT_WINDOW_SIZE_IN_SECONDS_FOR_RUNNING_MEAN = 1.5
 DEFAULT_VIDEO_SEGMENT_LENGTH_THRESHOLD_IN_S = 1.0
 
 if TYPE_CHECKING:
-    from endoreg_db.models import ModelMeta, Label
+    from endoreg_db.models import Label, ModelMeta
+
     from ..media.video.video_file import VideoFile
 
 
@@ -29,6 +29,7 @@ class VideoPredictionMeta(models.Model):
 
     Must be associated with exactly one `VideoFile`.
     """
+
     model_meta = models.ForeignKey("ModelMeta", on_delete=models.CASCADE)
     date_created = models.DateTimeField(auto_now_add=True)
     date_modified = models.DateTimeField(auto_now=True)
@@ -43,18 +44,24 @@ class VideoPredictionMeta(models.Model):
     )
 
     if TYPE_CHECKING:
-        model_meta: "ModelMeta"
-        video_file: "VideoFile"
+        model_meta: models.ForeignKey["ModelMeta"]
+        video_file: models.ForeignKey["VideoFile|None"]
         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"]),
         ]
 
+    @property
+    def video_file_safe(self) -> "VideoFile":
+        """Returns the associated VideoFile instance."""
+        video_file = self.video_file
+        if not video_file:
+            raise ValueError("VideoPredictionMeta is not associated with a VideoFile.")
+        return video_file
+
     def get_video(self) -> "VideoFile":
         """Returns the associated VideoFile instance."""
         if self.video_file:
@@ -83,12 +90,12 @@ class VideoPredictionMeta(models.Model):
             return labelset.get_labels_in_order()
         return []
 
-    def save_prediction_array(self, prediction_array: np.array):
+    def save_prediction_array(self, prediction_array: np.typing.NDArray):
         """
         Save the prediction array to the database.
         """
         self.prediction_array = pickle.dumps(prediction_array)
-        self.save(update_fields=['prediction_array', 'date_modified'])
+        self.save(update_fields=["prediction_array", "date_modified"])
 
     def get_prediction_array(self):
         """
@@ -103,7 +110,7 @@ class VideoPredictionMeta(models.Model):
                 logger.error(f"Error unpickling prediction array for {self}: {e}")
                 return None
 
-    def calculate_prediction_array(self, window_size_in_seconds: int = None):
+    def calculate_prediction_array(self, window_size_in_seconds: Optional[int] = None):
         """
         Fetches all predictions for the associated video, labelset, and model meta,
         applies smoothing, and saves the resulting binary prediction array.
@@ -125,15 +132,10 @@ class VideoPredictionMeta(models.Model):
 
         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
@@ -142,21 +144,19 @@ 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.")
 
-            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: int = 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.
@@ -215,11 +215,7 @@ 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))
 
@@ -229,7 +225,7 @@ class VideoPredictionMeta(models.Model):
         else:
             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: float = None):
+    def create_video_segments(self, segment_length_threshold_in_s: Optional[float] = None):
         """
         Generates LabelVideoSegments based on the stored prediction array.
         """

endoreg_db/models/other/distribution/date_value_distribution.py

@@ -1,15 +1,18 @@
-'''Model for date value distribution'''
+"""Model for date value distribution"""
 
 from datetime import date, timedelta
-from django.db import models
+
 import numpy as np
+from django.db import models
 
 from .base_value_distribution import BaseValueDistribution
 
+
 class DateValueDistributionManager(models.Manager):
-    '''Object manager for DateValueDistribution'''
+    """Object manager for DateValueDistribution"""
+
     def get_by_natural_key(self, name):
-        '''Retrieve a DateValueDistribution by its natural key.'''
+        """Retrieve a DateValueDistribution by its natural key."""
         return self.get(name=name)
 
 
@@ -20,16 +23,17 @@ class DateValueDistribution(BaseValueDistribution):
     date_min, date_max, date_mean, date_std_dev or
     timedelta_days_min, timedelta_days_max, timedelta_days_mean, timedelta_days_std_dev
     """
+
     objects = DateValueDistributionManager()
     name = models.CharField(max_length=100)
     description = models.TextField(blank=True, null=True)
     DISTRIBUTION_CHOICES = [
-        ('uniform', 'Uniform'),
-        ('normal', 'Normal'),
+        ("uniform", "Uniform"),
+        ("normal", "Normal"),
     ]
     MODE_CHOICES = [
-        ('date', 'Date'),
-        ('timedelta', 'Timedelta'),
+        ("date", "Date"),
+        ("timedelta", "Timedelta"),
     ]
 
     distribution_type = models.CharField(max_length=20, choices=DISTRIBUTION_CHOICES)
@@ -47,43 +51,99 @@ class DateValueDistribution(BaseValueDistribution):
     timedelta_days_mean = models.IntegerField(blank=True, null=True)
     timedelta_days_std_dev = models.IntegerField(blank=True, null=True)
 
+    # create *_safe properties for dates and timedeltas
+    @property
+    def date_min_safe(self):
+        _date = self.date_min
+        if _date is None:
+            raise ValueError("date_min is not set")
+        return _date
+
+    @property
+    def date_max_safe(self):
+        _date = self.date_max
+        if _date is None:
+            raise ValueError("date_max is not set")
+        return _date
+
+    @property
+    def date_mean_safe(self):
+        _date = self.date_mean
+        if _date is None:
+            raise ValueError("date_mean is not set")
+        return _date
+
+    @property
+    def date_std_dev_safe(self):
+        _std_dev = self.date_std_dev
+        if _std_dev is None:
+            raise ValueError("date_std_dev is not set")
+        return _std_dev
+
+    @property
+    def timedelta_days_min_safe(self):
+        _min = self.timedelta_days_min
+        if _min is None:
+            raise ValueError("timedelta_days_min is not set")
+        return _min
+
+    @property
+    def timedelta_days_max_safe(self):
+        _max = self.timedelta_days_max
+        if _max is None:
+            raise ValueError("timedelta_days_max is not set")
+        return _max
+
+    @property
+    def timedelta_days_mean_safe(self):
+        _mean = self.timedelta_days_mean
+        if _mean is None:
+            raise ValueError("timedelta_days_mean is not set")
+        return _mean
+
+    @property
+    def timedelta_days_std_dev_safe(self):
+        _std_dev = self.timedelta_days_std_dev
+        if _std_dev is None:
+            raise ValueError("timedelta_days_std_dev is not set")
+        return _std_dev
+
     def generate_value(self):
-        if self.mode == 'date':
+        if self.mode == "date":
             return self._generate_date_value()
-        elif self.mode == 'timedelta':
+        elif self.mode == "timedelta":
             return self._generate_timedelta_value()
         else:
             raise ValueError("Unsupported mode")
 
     def _generate_date_value(self):
-        #UNTESTED
-        if self.distribution_type == 'uniform':
-            start_date = self.date_min.toordinal()
-            end_date = self.date_max.toordinal()
+        # UNTESTED
+        if self.distribution_type == "uniform":
+            start_date = self.date_min_safe.toordinal()
+            end_date = self.date_max_safe.toordinal()
             random_ordinal = np.random.randint(start_date, end_date)
             return date.fromordinal(random_ordinal)
-        elif self.distribution_type == 'normal':
-            mean_ordinal = self.date_mean.toordinal()
-            std_dev_days = self.date_std_dev
+        elif self.distribution_type == "normal":
+            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.toordinal(), self.date_max.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, self.timedelta_days_max + 1)
-            
-            
-        elif self.distribution_type == 'normal':
-            random_days = int(np.random.normal(self.timedelta_days_mean, self.timedelta_days_std_dev))
-            random_days = np.clip(random_days, self.timedelta_days_min, self.timedelta_days_max)
-            
+        if self.distribution_type == "uniform":
+            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)
+
         else:
             raise ValueError("Unsupported distribution type")
-        
+
         current_date = date.today()
         generated_date = current_date - timedelta(days=random_days)
-        print(generated_date)
-        return(generated_date)
+
+        return generated_date

endoreg_db/models/other/distribution/multiple_categorical_value_distribution.py

@@ -1,29 +1,45 @@
-from django.db import models
 import numpy as np
+from django.db import models
+
 from .base_value_distribution import BaseValueDistribution
 
+
 class MultipleCategoricalValueDistributionManager(models.Manager):
     def get_by_natural_key(self, name):
         return self.get(name=name)
 
+
 class MultipleCategoricalValueDistribution(BaseValueDistribution):
     """
     Multiple categorical value distribution model.
     Assigns a specific number or varying number of values based on probabilities.
     """
+
     objects = MultipleCategoricalValueDistributionManager()
     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)
 
+    @property
+    def count_mean_safe(self):
+        if self.count_mean is None:
+            raise ValueError("count_mean is not set")
+        return self.count_mean
+
+    @property
+    def count_std_dev_safe(self):
+        if self.count_std_dev is None:
+            raise ValueError("count_std_dev is not set")
+        return self.count_std_dev
+
     def generate_value(self):
-        if self.count_distribution_type == 'uniform':
+        if self.count_distribution_type == "uniform":
             count = np.random.randint(self.min_count, self.max_count + 1)
-        elif self.count_distribution_type == 'normal':
-            count = int(np.random.normal(self.count_mean, self.count_std_dev))
+        elif self.count_distribution_type == "normal":
+            count = int(np.random.normal(self.count_mean_safe, self.count_std_dev_safe))
             count = np.clip(count, self.min_count, self.max_count)
         else:
             raise ValueError("Unsupported count distribution type")