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

endoreg_db/models/metadata/video_meta.py

@@ -1,10 +1,10 @@
-from django.db import models
 import logging
 from pathlib import Path
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 # import endoreg_center_id from django settings
 from django.conf import settings
+from django.db import models
 
 # check if endoreg_center_id is set
 if not hasattr(settings, "ENDOREG_CENTER_ID"):
@@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
     from ..administration import Center
-    from ..medical.hardware import EndoscopyProcessor, Endoscope
+    from ..medical.hardware import Endoscope, EndoscopyProcessor
 
 
 # VideoMeta
@@ -29,19 +29,40 @@ class VideoMeta(models.Model):
 
     Links to hardware (processor, endoscope), center, import details, and FFmpeg technical specs.
     """
-    processor = models.ForeignKey(
-        "EndoscopyProcessor", on_delete=models.CASCADE, blank=True, null=True
-    )
-    endoscope = models.ForeignKey(
-        "Endoscope", on_delete=models.CASCADE, blank=True, null=True
-    )
+
+    processor = models.ForeignKey("EndoscopyProcessor", on_delete=models.CASCADE, blank=True, null=True)
+    endoscope = models.ForeignKey("Endoscope", on_delete=models.CASCADE, blank=True, null=True)
     center = models.ForeignKey("Center", on_delete=models.CASCADE)
-    import_meta = models.OneToOneField(
-        "VideoImportMeta", on_delete=models.CASCADE, blank=True, null=True
-    )
-    ffmpeg_meta = models.OneToOneField(
-        "FFMpegMeta", on_delete=models.CASCADE, blank=True, null=True
-    )
+    import_meta = models.OneToOneField("VideoImportMeta", on_delete=models.CASCADE, blank=True, null=True)
+    ffmpeg_meta = models.OneToOneField("FFMpegMeta", on_delete=models.CASCADE, blank=True, null=True)
+
+    if TYPE_CHECKING:
+        processor: models.ForeignKey["EndoscopyProcessor|None"]
+        endoscope: models.ForeignKey["Endoscope|None"]
+        center: models.ForeignKey["Center|None"]
+        import_meta: models.OneToOneField["VideoImportMeta|None"]
+        ffmpeg_meta: models.OneToOneField["FFMpegMeta|None"]
+
+    @property
+    def center_safe(self) -> "Center":
+        center = self.center
+        if not center:
+            raise Center.DoesNotExist("Center does not exist for this VideoMeta instance.")
+        return center
+
+    @property
+    def processor_safe(self) -> "EndoscopyProcessor":
+        processor = self.processor
+        if not processor:
+            raise EndoscopyProcessor.DoesNotExist("EndoscopyProcessor does not exist for this VideoMeta instance.")
+        return processor
+
+    @property
+    def ffmpeg_meta_safe(self) -> "FFMpegMeta":
+        ffmpeg_meta = self.ffmpeg_meta
+        if not ffmpeg_meta:
+            raise FFMpegMeta.DoesNotExist("FFMpegMeta does not exist for this VideoMeta instance.")
+        return ffmpeg_meta
 
     @classmethod
     def create_from_file(
@@ -71,7 +92,7 @@ class VideoMeta(models.Model):
             raise RuntimeError(f"Failed to initialize FFMpeg metadata for {video_path.name}") from e
 
         if save_instance:
-            meta.save() # This ensures VideoImportMeta is created too
+            meta.save()  # This ensures VideoImportMeta is created too
             logger.info("Created and saved VideoMeta instance PK %s from %s", meta.pk, video_path.name)
         else:
             logger.info("Instantiated VideoMeta from %s (not saved yet)", video_path.name)
@@ -120,8 +141,8 @@ class VideoMeta(models.Model):
             # If the VideoMeta instance is already saved, save the link immediately.
             # Otherwise, the link will be saved when VideoMeta itself is saved.
             if self.pk:
-                self.save(update_fields=['ffmpeg_meta'])
-            logger.info("Successfully created and linked FFMpegMeta PK %s", self.ffmpeg_meta.pk)
+                self.save(update_fields=["ffmpeg_meta"])
+            logger.info("Successfully created and linked FFMpegMeta PK %s", self.ffmpeg_meta_safe.pk)
 
         except Exception as e:
             # Log the error and re-raise it
@@ -140,8 +161,8 @@ class VideoMeta(models.Model):
             logger.debug("Deleting existing FFMpegMeta PK %s before update.", existing_ffmpeg_pk)
             # Nullify the relation first before deleting the related object
             self.ffmpeg_meta = None
-            self.save(update_fields=['ffmpeg_meta']) # Save the null relation
-            FFMpegMeta.objects.filter(pk=existing_ffmpeg_pk).delete() # Delete the old object
+            self.save(update_fields=["ffmpeg_meta"])  # Save the null relation
+            FFMpegMeta.objects.filter(pk=existing_ffmpeg_pk).delete()  # Delete the old object
 
         # initialize_ffmpeg_meta handles creation, linking, saving the link, and raises exceptions
         self.initialize_ffmpeg_meta(video_path)
@@ -150,7 +171,7 @@ class VideoMeta(models.Model):
         """Retrieves the endoscope region of interest (ROI) from the associated processor."""
         from ..medical.hardware import EndoscopyProcessor
 
-        processor: EndoscopyProcessor = self.processor
+        processor: EndoscopyProcessor = self.processor_safe
         endo_roi = processor.get_roi_endoscope_image()
         return endo_roi
 
@@ -189,6 +210,7 @@ class FFMpegMeta(models.Model):
     """
     Stores technical video stream information extracted using FFmpeg (ffprobe).
     """
+
     width = models.IntegerField(null=True, blank=True)
     height = models.IntegerField(null=True, blank=True)
     duration = models.FloatField(null=True, blank=True)  # Duration in seconds
@@ -219,7 +241,6 @@ class FFMpegMeta(models.Model):
             logger.error("ffprobe execution failed for %s: %s", file_path, probe_err, exc_info=True)
             raise RuntimeError(f"ffprobe execution failed for {file_path}") from probe_err
 
-
         if not probe_data or "streams" not in probe_data:
             logger.error("Failed to get valid stream info from ffprobe for %s", file_path)
             # Raise exception instead of returning None
@@ -237,8 +258,8 @@ class FFMpegMeta(models.Model):
         height = video_stream.get("height")
         duration_str = video_stream.get("duration")
         # --- FIX: Handle potential format key ---
-        if duration_str is None and 'format' in probe_data and 'duration' in probe_data['format']:
-            duration_str = probe_data['format']['duration']
+        if duration_str is None and "format" in probe_data and "duration" in probe_data["format"]:
+            duration_str = probe_data["format"]["duration"]
             logger.debug("Using duration from format block: %s", duration_str)
         # --- End Fix ---
         duration = float(duration_str) if duration_str else None
@@ -253,10 +274,10 @@ class FFMpegMeta(models.Model):
         frame_rate_num, frame_rate_den = None, None
         if frame_rate_str and "/" in frame_rate_str:
             try:
-                num_str, den_str = frame_rate_str.split('/')
+                num_str, den_str = frame_rate_str.split("/")
                 frame_rate_num = int(num_str)
                 frame_rate_den = int(den_str)
-                if frame_rate_den == 0: # Avoid division by zero
+                if frame_rate_den == 0:  # Avoid division by zero
                     logger.warning("Invalid frame rate denominator (0) for %s", file_path)
                     frame_rate_num, frame_rate_den = None, None
             except ValueError:
@@ -267,8 +288,8 @@ class FFMpegMeta(models.Model):
         pixel_format = video_stream.get("pix_fmt")
         bit_rate_str = video_stream.get("bit_rate")
         # --- FIX: Handle potential format key for bit_rate ---
-        if bit_rate_str is None and 'format' in probe_data and 'bit_rate' in probe_data['format']:
-            bit_rate_str = probe_data['format']['bit_rate']
+        if bit_rate_str is None and "format" in probe_data and "bit_rate" in probe_data["format"]:
+            bit_rate_str = probe_data["format"]["bit_rate"]
             logger.debug("Using bit_rate from format block: %s", bit_rate_str)
         # --- End Fix ---
         bit_rate = int(bit_rate_str) if bit_rate_str else None
@@ -311,6 +332,7 @@ class VideoImportMeta(models.Model):
     """
     Stores metadata related to the import and processing status of a video.
     """
+
     file_name = models.CharField(max_length=255, blank=True, null=True)
     video_anonymized = models.BooleanField(default=False)
     video_patient_data_detected = models.BooleanField(default=False)
@@ -323,9 +345,7 @@ class VideoImportMeta(models.Model):
         result_html = ""
 
         result_html += f"Video anonymized: {self.video_anonymized}\n"
-        result_html += (
-            f"Video patient data detected: {self.video_patient_data_detected}\n"
-        )
+        result_html += f"Video patient data detected: {self.video_patient_data_detected}\n"
         result_html += f"Outside detected: {self.outside_detected}\n"
         result_html += f"Patient data removed: {self.patient_data_removed}\n"
         result_html += f"Outside removed: {self.outside_removed}\n"

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")