endoreg-db 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

endoreg_db/models/persons/patient/patient_medication_schedule.py

@@ -3,7 +3,9 @@ from django.db import models
 class PatientMedicationSchedule(models.Model):
     patient = models.ForeignKey("Patient", on_delete= models.CASCADE)
     medication = models.ManyToManyField(
-        'PatientMedication', related_name='patient_medication_schedules'
+        'PatientMedication', 
+        related_name='patient_medication_schedules',
+        blank=True
     )
 
     created_at = models.DateTimeField(auto_now_add=True)
@@ -25,4 +27,62 @@ class PatientMedicationSchedule(models.Model):
         patient_medication_schedule.medication.add(patient_medication)
         patient_medication_schedule.save()
 
-        return patient_medication_schedule
+        return patient_medication_schedule
+    
+    @classmethod
+    def create_by_patient_and_indication(cls, patient, medication_indication):
+        from endoreg_db.models import (
+            MedicationIndication, PatientMedication,
+            Patient
+        )
+
+        assert isinstance(medication_indication, MedicationIndication)
+        assert isinstance(patient, Patient)
+        patient_medication_schedule = cls.objects.create(patient=patient)
+        patient_medication_schedule.save()
+
+        patient_medication = PatientMedication.create_by_patient_and_indication(patient, medication_indication)
+        patient_medication_schedule.medication.add(patient_medication)
+        patient_medication_schedule.save()
+
+        return patient_medication_schedule
+    
+    def create_patient_medication_from_medication_schedule(
+            self,
+            medication_schedule,
+            medication_indication=None,
+            start_date=None,
+        ):
+        
+        from endoreg_db.models import MedicationSchedule, PatientMedication
+        from datetime import datetime as dt
+
+        assert isinstance(medication_schedule, MedicationSchedule)
+
+        if not start_date:
+            start_date = dt.now()
+
+        drug = medication_schedule.medication
+        unit = medication_schedule.unit
+        dosage = medication_schedule.dose
+        intake_times = medication_schedule.get_intake_times()
+
+        patient_medication = PatientMedication.objects.create(
+            patient=self.patient,
+            medication=drug,
+            medication_indication=medication_indication,
+            unit=unit,
+            dosage=dosage
+        )
+
+        patient_medication.intake_times.set(intake_times)
+        patient_medication.save()
+
+        self.medication.add(patient_medication)
+        self.save()  
+
+        return patient_medication
+    
+    
+    def get_patient_medication(self):
+        return self.medication.all()

endoreg_db/models/prediction/__init__.py

@@ -1,2 +1,8 @@
 from .image_classification import ImageClassificationPrediction
-from .video_prediction_meta import LegacyVideoPredictionMeta, VideoPredictionMeta
+from .video_prediction_meta import RawVideoPredictionMeta, VideoPredictionMeta
+
+__all__ = [
+    "ImageClassificationPrediction",
+    "RawVideoPredictionMeta",
+    "VideoPredictionMeta",
+]

endoreg_db/models/prediction/image_classification.py

@@ -1,5 +1,6 @@
 from django.db import models
 
+
 class ImageClassificationPrediction(models.Model):
     """
     A class representing an image classification prediction.
@@ -11,17 +12,30 @@ class ImageClassificationPrediction(models.Model):
         date_created (datetime): The date the prediction was created.
 
     """
-    label = models.ForeignKey("Label", on_delete=models.CASCADE, related_name="image_classification_predictions")
-    frame = models.ForeignKey("Frame", on_delete=models.CASCADE, blank=True, null=True, related_name="image_classification_predictions")
-    legacy_frame = models.ForeignKey("LegacyFrame", on_delete=models.CASCADE, blank=True, null=True, related_name="image_classification_predictions")
-    legacy_image = models.ForeignKey("LegacyImage", on_delete=models.CASCADE, blank=True, null=True, related_name="image_classification_predictions")
+
+    label = models.ForeignKey(
+        "Label",
+        on_delete=models.CASCADE,
+        related_name="image_classification_predictions",
+    )
+    frame = models.ForeignKey(
+        "Frame",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        related_name="image_classification_predictions",
+    )
     value = models.BooleanField()
     confidence = models.FloatField()
-    model_meta = models.ForeignKey("ModelMeta", on_delete=models.CASCADE, related_name="image_classification_predictions")
+    model_meta = models.ForeignKey(
+        "ModelMeta",
+        on_delete=models.CASCADE,
+        related_name="image_classification_predictions",
+    )
     date_created = models.DateTimeField(auto_now_add=True)
 
     class Meta:
-        unique_together = ('label', 'frame', 'model_meta')
+        unique_together = ("label", "frame", "model_meta")
 
     def get_image_object(self):
         """

endoreg_db/models/prediction/video_prediction_meta.py

@@ -1,55 +1,88 @@
+from typing import Union, TYPE_CHECKING
 from django.db import models
 
 from endoreg_db.models.label.label import LabelSet
-from ..data_file.video import LegacyVideo, Video
-from ..data_file.frame import LegacyFrame, Frame
+from ..data_file.video import Video
+from ..data_file.import_classes import RawVideoFile
+from ..data_file.frame import Frame
 from .image_classification import ImageClassificationPrediction
-from ..data_file.video_segment import LegacyLabelVideoSegment, LabelVideoSegment, find_segments_in_prediction_array
-from ..information_source import get_prediction_information_source
+from ..data_file import (
+    LabelVideoSegment,
+    find_segments_in_prediction_array,
+)
+
+# from ..information_source import get_prediction_information_source
 import numpy as np
 import pickle
 
 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
+
+
 class AbstractVideoPredictionMeta(models.Model):
     model_meta = models.ForeignKey("ModelMeta", on_delete=models.CASCADE)
     date_created = models.DateTimeField(auto_now_add=True)
     date_modified = models.DateTimeField(auto_now=True)
     video = None  # Placeholder for the video field, to be defined in derived classes
     prediction_array = models.BinaryField(blank=True, null=True)
+    is_raw = models.BooleanField(default=False)
+
+    if TYPE_CHECKING:
+        model_meta: "ModelMeta"
+        video: Union["Video", "RawVideoFile"]
 
     class Meta:
         abstract = True
-        unique_together = ('model_meta', 'video')
+        unique_together = ("model_meta", "video")
+
+    def is_raw_video_prediction_meta(self):
+        if isinstance(self, RawVideoPredictionMeta):
+            return True
+        return False
 
     def __str__(self):
         return f"Video {self.video.id} - {self.model_meta.name}"
-    
+
+    # override save method to set is_raw field
+    def save(self, *args, **kwargs):
+        self.is_raw = self.is_raw_video_prediction_meta()
+        super().save(*args, **kwargs)
+
     def get_labelset(self):
         """
         Get the labelset of the predictions.
         """
-        return self.model_meta.labelset
-    
+        if self.is_raw:
+            return self.model_meta.labelset
+
     def get_video_model(self):
-        assert 1 == 2, "This method should be overridden in derived classes"
+        if self.is_raw:
+            return RawVideoFile
+
+        return Video
 
     def get_frame_model(self):
-        assert 1 == 2, "This method should be overridden in derived classes"
+        return Frame
+
+    def get_video_segment_model(self):
+        from endoreg_db.models import LabelRawVideoSegment
+
+        if self.is_raw:
+            return LabelRawVideoSegment
+        return LabelVideoSegment
 
     def get_label_list(self):
         """
         Get the label list of the predictions.
         """
-        labelset:LabelSet = self.get_labelset()
+        labelset: LabelSet = self.get_labelset()
         label_list = labelset.get_labels_in_order()
         return label_list
-    
-    def get_video_segment_model(self):
-        assert 1 == 2, "This method should be overridden in derived classes"
-    
-    def save_prediction_array(self, prediction_array:np.array):
+
+    def save_prediction_array(self, prediction_array: np.array):
         """
         Save the prediction array to the database.
         """
@@ -64,7 +97,7 @@ class AbstractVideoPredictionMeta(models.Model):
             return None
         else:
             return pickle.loads(self.prediction_array)
-        
+
     def calculate_prediction_array(self):
         assert 1 == 2, "This method should be overridden in derived classes"
 
@@ -97,47 +130,52 @@ class AbstractVideoPredictionMeta(models.Model):
         window = np.ones(window_size_in_frames) / window_size_in_frames
 
         # Create running mean array with the same shape as the confidence array
-        running_mean_array = np.zeros(confidence_array.shape)
+        _running_mean_array = np.zeros(confidence_array.shape)
 
         # Calculate the padding size
         pad_size = window_size_in_frames // 2
 
         # Pad the array with 0.5 on both sides
-        padded_confidences = np.pad(confidence_array, (pad_size, pad_size), 'constant', constant_values=(0.5, 0.5))
-        
+        padded_confidences = np.pad(
+            confidence_array,
+            (pad_size, pad_size),
+            "constant",
+            constant_values=(0.5, 0.5),
+        )
+
         # Apply the running mean filter on the padded array
-        running_mean = np.convolve(padded_confidences, window, mode='same')
-        
+        running_mean = np.convolve(padded_confidences, window, mode="same")
+
         # Remove the padding from the result to match the original shape
         running_mean = running_mean[pad_size:-pad_size]
 
         return running_mean
-    
 
-    def create_video_segments_for_label(self, segments, label):
-        """
-        Creates video segments for the given label and segments.
-        Segments is a list of tuples (start_frame_number, end_frame_number).
-        Labels is a Label object.
-        """
-        video = self.video
-        video_segment_model = self.get_video_segment_model()
-        information_source = get_prediction_information_source()
-
-        for segment in segments:
-            start_frame_number, end_frame_number = segment
-
-            video_segment = video_segment_model(
-                video=video,
-                prediction_meta=self,
-                start_frame_number=start_frame_number,
-                end_frame_number=end_frame_number,
-                source=information_source,
-                label=label,
-            )
-            video_segment.save()
-
-    def create_video_segments(self, segment_length_threshold_in_s:float=None):
+    # FIXME
+    # def create_video_segments_for_label(self, segments, label):
+    #     """
+    #     Creates video segments for the given label and segments.
+    #     Segments is a list of tuples (start_frame_number, end_frame_number).
+    #     Labels is a Label object.
+    #     """
+    #     video = self.video
+    #     video_segment_model = self.get_video_segment_model()
+    #     information_source = get_prediction_information_source()
+
+    #     for segment in segments:
+    #         start_frame_number, end_frame_number = segment
+
+    #         video_segment = video_segment_model(
+    #             video=video,
+    #             prediction_meta=self,
+    #             start_frame_number=start_frame_number,
+    #             end_frame_number=end_frame_number,
+    #             source=information_source,
+    #             label=label,
+    #         )
+    #         video_segment.save()
+
+    def create_video_segments(self, segment_length_threshold_in_s: float = None):
         if not segment_length_threshold_in_s:
             segment_length_threshold_in_s = DEFAULT_VIDEO_SEGMENT_LENGTH_THRESHOLD_IN_S
 
@@ -146,7 +184,7 @@ class AbstractVideoPredictionMeta(models.Model):
         min_frame_length = int(segment_length_threshold_in_s * fps)
 
         label_list = self.get_label_list()
-        
+
         # if prediction array doesnt exist, create it
         if self.prediction_array is None:
             self.calculate_prediction_array()
@@ -163,24 +201,21 @@ class AbstractVideoPredictionMeta(models.Model):
             # create video segments
             self.create_video_segments_for_label(segments, label)
 
-import numpy as np
-class VideoPredictionMeta(AbstractVideoPredictionMeta):
-    video = models.OneToOneField("Video", on_delete=models.CASCADE, related_name="video_prediction_meta")
 
-    def get_video_model(self):
-        return Video
-    
-    def get_frame_model(self):
-        return Frame
-    
-    def get_video_segment_model(self):
-        return LabelVideoSegment
-    
-    def calculate_prediction_array(self, window_size_in_seconds:int=None):
+class RawVideoPredictionMeta(AbstractVideoPredictionMeta):
+    """
+    Model for storing video predictions for a specific model and video.
+    """
+
+    video = models.ForeignKey(
+        "RawVideoFile", on_delete=models.CASCADE, related_name="video_prediction_meta"
+    )
+
+    def calculate_prediction_array(self, window_size_in_seconds: int = None):
         """
         Fetches all predictions for this video, labelset, and model meta.
         """
-        video:Video = self.video
+        video: Video = self.video
 
         model_meta = self.model_meta
         label_list = self.get_label_list()
@@ -188,9 +223,15 @@ class VideoPredictionMeta(AbstractVideoPredictionMeta):
         prediction_array = np.zeros((video.get_frame_number, len(label_list)))
         for i, label in enumerate(label_list):
             # fetch all predictions for this label, video, and model meta ordered by ImageClassificationPrediction.frame.frame_number
-            predictions = ImageClassificationPrediction.objects.filter(label=label, frame__video=video, model_meta=model_meta).order_by('frame__frame_number')
-            confidences = np.array([prediction.confidence for prediction in predictions])
-            smooth_confidences = self.apply_running_mean(confidences, window_size_in_seconds)
+            predictions = ImageClassificationPrediction.objects.filter(
+                label=label, frame__video=video, model_meta=model_meta
+            ).order_by("frame__frame_number")
+            confidences = np.array(
+                [prediction.confidence for prediction in predictions]
+            )
+            smooth_confidences = self.apply_running_mean(
+                confidences, window_size_in_seconds
+            )
             # calculate binary predictions
             binary_predictions = smooth_confidences > 0.5
             # add to prediction array
@@ -200,23 +241,46 @@ class VideoPredictionMeta(AbstractVideoPredictionMeta):
         self.save_prediction_array(prediction_array)
 
 
-class LegacyVideoPredictionMeta(AbstractVideoPredictionMeta):
-    video = models.OneToOneField("LegacyVideo", on_delete=models.CASCADE, related_name="video_prediction_meta")
-
-    def get_video_model(self):
-        return LegacyVideo
+class VideoPredictionMeta(AbstractVideoPredictionMeta):
+    """
+    Model for storing video predictions for a specific model and video.
+    """
+
+    video = models.ForeignKey(
+        "Video", on_delete=models.CASCADE, related_name="video_prediction_meta"
+    )
+
+    @classmethod
+    def from_raw(
+        cls, video: "Video", raw_video_prediction_meta: RawVideoPredictionMeta
+    ):
+        """
+        Create a new VideoPrediction from an existing RawVideoPredictionMeta.
+        """
+        cls_dict = {
+            "video": video,
+            "model_meta": raw_video_prediction_meta.model_meta,
+            "date_created": raw_video_prediction_meta.date_created,
+            "date_modified": raw_video_prediction_meta.date_modified,
+            "prediction_array": raw_video_prediction_meta.prediction_array,
+            "is_raw": False,
+        }
+
+        # check if exists
+        if cls.objects.filter(
+            video=video, model_meta=raw_video_prediction_meta.model_meta
+        ).exists():
+            return cls.objects.get(
+                video=video, model_meta=raw_video_prediction_meta.model_meta
+            )
+        else:
+            return cls.objects.create(**cls_dict)
 
-    def get_frame_model(self):
-        return LegacyFrame
-    
-    def get_video_segment_model(self):
-        return LegacyLabelVideoSegment
-    
-    def calculate_prediction_array(self, window_size_in_seconds:int=None):
+    def calculate_prediction_array(self, window_size_in_seconds: int = None):
         """
         Fetches all predictions for this video, labelset, and model meta.
         """
-        video:LegacyVideo = self.video
+        video: Video = self.video
 
         model_meta = self.model_meta
         label_list = self.get_label_list()
@@ -224,9 +288,15 @@ class LegacyVideoPredictionMeta(AbstractVideoPredictionMeta):
         prediction_array = np.zeros((video.get_frame_number, len(label_list)))
         for i, label in enumerate(label_list):
             # fetch all predictions for this label, video, and model meta ordered by ImageClassificationPrediction.frame.frame_number
-            predictions = ImageClassificationPrediction.objects.filter(label=label, legacy_frame__video=video, model_meta=model_meta).order_by('legacy_frame__frame_number')
-            confidences = np.array([prediction.confidence for prediction in predictions])
-            smooth_confidences = self.apply_running_mean(confidences, window_size_in_seconds)
+            predictions = ImageClassificationPrediction.objects.filter(
+                label=label, frame__video=video, model_meta=model_meta
+            ).order_by("frame__frame_number")
+            confidences = np.array(
+                [prediction.confidence for prediction in predictions]
+            )
+            smooth_confidences = self.apply_running_mean(
+                confidences, window_size_in_seconds
+            )
             # calculate binary predictions
             binary_predictions = smooth_confidences > 0.5
             # add to prediction array
@@ -234,11 +304,3 @@ class LegacyVideoPredictionMeta(AbstractVideoPredictionMeta):
 
         # save prediction array
         self.save_prediction_array(prediction_array)
-
-    
-            
-
-
-
-
-

endoreg_db/models/product/__init__.py

@@ -1,5 +1,14 @@
+'''Module for product models'''
 from .product import Product
 from .product_material import ProductMaterial
 from .product_group import ProductGroup
 from .reference_product import ReferenceProduct
-from .product_weight import ProductWeight
+from .product_weight import ProductWeight
+
+__all__ = [
+    'Product',
+    'ProductMaterial',
+    'ProductGroup',
+    'ReferenceProduct',
+    'ProductWeight',
+]

endoreg_db/models/product/product.py

@@ -40,13 +40,26 @@ class Product(models.Model):
     name_en = models.CharField(max_length=255, null=True)
 
     transport_route = models.ForeignKey("TransportRoute", on_delete=models.SET_NULL, null=True)
-    product_group = models.ForeignKey("ProductGroup", on_delete=models.SET_NULL, null=True)
+    product_group = models.ForeignKey(
+        "ProductGroup", on_delete=models.SET_NULL, null=True
+    )
 
     def natural_key(self):
         return (self.name,)
     
     def __str__(self):
-        return self.name
+        result = f"{self.name}"
+        if self.product_group:
+            result += f" ({self.product_group}, "
+        else:
+            result += " (no product group, "
+
+        if self.transport_route:
+            result += f"{self.transport_route})"
+        else:
+            result += "no transport route)"
+        
+        return result
     
     def get_product_weight(self):
         # check if there is a product material weight

endoreg_db/models/product/product_group.py

@@ -17,3 +17,11 @@ class ProductGroup(models.Model):
     def __str__(self):
         return self.name
     
+    def get_products(self):
+        from endoreg_db.models import Product
+        return Product.objects.filter(product_group=self)
+    
+    def get_reference_product(self):
+        from endoreg_db.models import ReferenceProduct
+        return ReferenceProduct.objects.get(product_group=self)
+    

endoreg_db/models/product/product_material.py

@@ -20,5 +20,9 @@ class ProductMaterial(models.Model):
         emmision_value = emission_factor.value * self.quantity
         emission_unit = emission_factor.unit
         return emmision_value, emission_unit
+    
+    def __str__(self):
+        return f"{self.product.name} - {self.material.name} - {self.quantity} {self.unit.name}"
+    
         
 

endoreg_db/models/product/product_weight.py

@@ -24,3 +24,15 @@ class ProductWeight(models.Model):
             return self.manufacturer
         else:
             return None
+        
+    def get_weight_source(self):
+        if not pd.isnull(self.verified):
+            return "verified"
+        elif not pd.isnull(self.measured):
+            return "measured"
+        elif not pd.isnull(self.manufacturer):
+            return "manufacturer"
+        else:
+            return None
+    def __str__(self):
+        return f"{self.product} - {self.get_weight()} {self.unit} (Source: {self.get_weight_source()})"

endoreg_db/models/product/reference_product.py

@@ -9,9 +9,25 @@ class ReferenceProduct(models.Model):
     name = models.CharField(max_length=255)
     product = models.ForeignKey("Product", on_delete=models.CASCADE)
     product_group = models.OneToOneField("ProductGroup", on_delete=models.CASCADE, related_name="reference_product")
-    emission_factor_total = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True, blank = True)
-    emission_factor_package = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True, related_name="reference_product_package")
-    emission_factor_product = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True, related_name="reference_product_product")
+    emission_factor_total = models.ForeignKey(
+        "EmissionFactor", 
+        on_delete=models.SET_NULL, 
+        null=True, 
+        blank = True,
+        # related_name="reference_product_total"
+        )
+    emission_factor_package = models.ForeignKey(
+        "EmissionFactor", 
+        on_delete=models.SET_NULL, 
+        null=True, 
+        related_name="reference_product_package"
+    )
+    emission_factor_product = models.ForeignKey(
+        "EmissionFactor", 
+        on_delete=models.SET_NULL, 
+        null=True, 
+        related_name="reference_product_product"
+    )
     
     objects = ReferenceProductManager()
 

endoreg_db/models/quiz/__init__.py

@@ -1,2 +1,9 @@
 from .quiz_answer import QuizAnswer, QuizAnswerType
-from .quiz_question import QuizQuestion, QuizQuestionType
+from .quiz_question import QuizQuestion, QuizQuestionType
+
+__all__ = [
+    "QuizAnswer",
+    "QuizAnswerType",
+    "QuizQuestion",
+    "QuizQuestionType",
+] 

endoreg_db/models/report_reader/__init__.py

@@ -1,2 +1,7 @@
 from .report_reader_config import ReportReaderConfig
-from .report_reader_flag import ReportReaderFlag
+from .report_reader_flag import ReportReaderFlag
+
+__all__ = [
+    'ReportReaderConfig',
+    'ReportReaderFlag',
+]

endoreg_db/serializers/__init__.py

@@ -7,4 +7,4 @@ from .hardware import *
 from .label import *
 from .patient import *
 from .report_file import *
-from .video import *
+from .video import *

endoreg_db/serializers/annotation.py

@@ -1,10 +1,7 @@
 from rest_framework import serializers
-from endoreg_db.models import LegacyBinaryClassificationAnnotationTask, BinaryClassificationAnnotationTask, ImageClassificationAnnotation
+from endoreg_db.models import  BinaryClassificationAnnotationTask, ImageClassificationAnnotation
+
 
-class LegacyBinaryClassificationAnnotationTaskSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyBinaryClassificationAnnotationTask
-        fields = '__all__'
 
 class BinaryClassificationAnnotationTaskSerializer(serializers.ModelSerializer):
     class Meta:

endoreg_db/serializers/frame.py

@@ -1,13 +1,9 @@
 from rest_framework import serializers
-from endoreg_db.models import Frame, LegacyFrame
+from endoreg_db.models import Frame
 
 class FrameSerializer(serializers.ModelSerializer):
     class Meta:
         model = Frame
         fields = '__all__'
 
-class LegacyFrameSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyFrame
-        fields = '__all__'