endoreg-db 0.6.4__py3-none-any.whl → 0.8.2__py3-none-any.whl

endoreg_db/models/persons/patient/patient_medication_schedule.py

@@ -1,88 +0,0 @@
-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',
-        blank=True
-    )
-
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-    def __str__(self):
-        return f'{self.patient} - {self.medication.all()}'
-    
-    @classmethod
-    def create_by_patient_and_indication_type(cls, patient, indication_type):
-        from endoreg_db.models import MedicationIndicationType, PatientMedication
-
-        medication_indication = MedicationIndicationType.get_random_indication_by_type(name=indication_type)
-
-        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
-    
-    @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/persons/portal_user_information.py

@@ -1,27 +0,0 @@
-from django.db import models
-
-# models.py in your main app
-from django.contrib.auth.models import User
-
-class ProfessionManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class Profession(models.Model):
-    objects = ProfessionManager()
-    name = models.CharField(max_length=100)
-    name_de = models.CharField(max_length=100, blank=True, null=True)
-    name_en = models.CharField(max_length=100, blank=True, null=True)
-    description = models.TextField(blank=True, null=True)
-
-    def __str__(self):
-        return self.name_de
-
-class PortalUserInfo(models.Model):
-    user = models.OneToOneField(User, on_delete=models.CASCADE)
-    profession = models.ForeignKey('Profession', on_delete=models.CASCADE, blank=True, null=True)
-    works_in_endoscopy = models.BooleanField(blank=True, null=True)
-    # Add other fields as needed
-
-    def __str__(self):
-        return self.user.username

endoreg_db/models/prediction/__init__.py

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

endoreg_db/models/prediction/image_classification.py

@@ -1,51 +0,0 @@
-from django.db import models
-
-
-class ImageClassificationPrediction(models.Model):
-    """
-    A class representing an image classification prediction.
-
-    Attributes:
-        label (Label): The label of the prediction.
-        frame (Frame): The frame of the prediction.
-        confidence (float): The confidence of the prediction.
-        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",
-    )
-    value = models.BooleanField()
-    confidence = models.FloatField()
-    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")
-
-    def get_image_object(self):
-        """
-        Get the image of the prediction.
-        """
-        if self.frame:
-            return self.frame
-        elif self.legacy_frame:
-            return self.legacy_frame
-        elif self.legacy_image:
-            return self.legacy_image
-        else:
-            return None

endoreg_db/models/prediction/video_prediction_meta.py

@@ -1,306 +0,0 @@
-from typing import Union, TYPE_CHECKING
-from django.db import models
-
-from endoreg_db.models.label.label import LabelSet
-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 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")
-
-    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.
-        """
-        if self.is_raw:
-            return self.model_meta.labelset
-
-    def get_video_model(self):
-        if self.is_raw:
-            return RawVideoFile
-
-        return Video
-
-    def get_frame_model(self):
-        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()
-        label_list = labelset.get_labels_in_order()
-        return label_list
-
-    def save_prediction_array(self, prediction_array: np.array):
-        """
-        Save the prediction array to the database.
-        """
-        self.prediction_array = pickle.dumps(prediction_array)
-        self.save()
-
-    def get_prediction_array(self):
-        """
-        Get the prediction array from the database.
-        """
-        if self.prediction_array is None:
-            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"
-
-    def apply_running_mean(self, confidence_array, window_size_in_seconds: int = None):
-        """
-        Apply a running mean filter to the confidence array for smoothing, assuming a padding
-        of 0.5 for the edges.
-
-        Args:
-        self: Object that has video and fps attributes, and to which this function belongs.
-        confidence_array: A 2D numpy array with dimensions (num_frames),
-                        containing confidence scores for each label at each frame.
-        window_size_in_seconds: The window size for the running mean in seconds.
-
-        Returns:
-        running_mean_array: A 2D numpy array with the same dimensions as confidence_array,
-                            containing the smoothed confidence scores.
-        """
-        video = self.video
-        fps = video.fps
-
-        if not window_size_in_seconds:
-            window_size_in_seconds = DEFAULT_WINDOW_SIZE_IN_SECONDS_FOR_RUNNING_MEAN
-
-        # Calculate window size in frames, ensuring at least one frame
-        window_size_in_frames = int(window_size_in_seconds * fps)
-        window_size_in_frames = max(window_size_in_frames, 1)
-
-        # Define the window for the running mean
-        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)
-
-        # 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),
-        )
-
-        # Apply the running mean filter on the padded array
-        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
-
-    # 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
-
-        video = self.video
-        fps = video.fps
-        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()
-
-        prediction_array = self.get_prediction_array()
-
-        for i, label in enumerate(label_list):
-            # get predictions for this label
-            predictions = prediction_array[:, i]
-            # find segments of predictions that are longer than the threshold
-            # segments is a list of tuples (start_frame_number, end_frame_number)
-            segments = find_segments_in_prediction_array(predictions, min_frame_length)
-
-            # create video segments
-            self.create_video_segments_for_label(segments, label)
-
-
-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
-
-        model_meta = self.model_meta
-        label_list = self.get_label_list()
-
-        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
-            )
-            # calculate binary predictions
-            binary_predictions = smooth_confidences > 0.5
-            # add to prediction array
-            prediction_array[:, i] = binary_predictions
-
-        # save prediction array
-        self.save_prediction_array(prediction_array)
-
-
-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 calculate_prediction_array(self, window_size_in_seconds: int = None):
-        """
-        Fetches all predictions for this video, labelset, and model meta.
-        """
-        video: Video = self.video
-
-        model_meta = self.model_meta
-        label_list = self.get_label_list()
-
-        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
-            )
-            # calculate binary predictions
-            binary_predictions = smooth_confidences > 0.5
-            # add to prediction array
-            prediction_array[:, i] = binary_predictions
-
-        # save prediction array
-        self.save_prediction_array(prediction_array)

endoreg_db/models/product/product.py

@@ -1,110 +0,0 @@
-from django.db import models
-
-class ProductManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-def sum_weights(product_materials):
-    # sum up the weights
-    weight = 0
-    reference_unit = None
-    for product_material in product_materials:
-        if not reference_unit:
-            reference_unit = product_material.unit
-        else:
-            assert reference_unit == product_material.unit, "ProductMaterial units do not match"
-        weight += product_material.quantity
-
-    return weight, reference_unit
-
-def sum_emissions(product_materials):
-    # sum up the emissions
-    emission = 0
-    reference_unit = None
-    for product_material in product_materials:
-        if not reference_unit:
-            reference_unit = product_material.unit
-        else:
-            assert reference_unit == product_material.unit, "ProductMaterial units do not match"
-        emission, emission_unit = product_material.get_emission()
-        assert reference_unit == emission_unit, "ProductMaterial units do not match"
-        emission += emission
-
-    return emission, reference_unit
-
-class Product(models.Model):
-    objects = ProductManager()
-
-    name = models.CharField(max_length=255)
-    name_de = models.CharField(max_length=255, null=True)
-    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
-    )
-
-    def natural_key(self):
-        return (self.name,)
-    
-    def __str__(self):
-        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
-        from .product_material import ProductMaterial
-        product_materials = ProductMaterial.objects.filter(product=self, component="product")
-        if product_materials:
-            return self.get_product_material_weight()
-        
-        # check if there is a product weight
-        #TODO
-
-    def get_package_weight(self):
-        # check if there is a package material weight
-        from .product_material import ProductMaterial
-        product_materials = ProductMaterial.objects.filter(product=self, component="package")
-        if product_materials:
-            return self.get_package_material_weight()
-        
-        # check if there is a package weight
-        #TODO
-
-    def get_product_material_weight(self):
-        # get all materials with component == "product"
-        from .product_material import ProductMaterial
-        product_materials = ProductMaterial.objects.filter(product=self, component="product")
-
-        return sum_weights(product_materials)
-    
-    def get_package_material_weight(self):
-        # get all materials with component == "package"
-        from .product_material import ProductMaterial
-        product_materials = ProductMaterial.objects.filter(product=self, component="package")
-
-        return sum_weights(product_materials)
-
-    def get_product_material_emission(self):
-        # get all materials with component == "product"
-        from .product_material import ProductMaterial
-        product_materials = ProductMaterial.objects.filter(product=self, component="product")
-
-        return sum_emissions(product_materials)
-
-    def get_package_material_emission(self):
-        # get all materials with component == "package"
-        from .product_material import ProductMaterial
-        product_materials = ProductMaterial.objects.filter(product=self, component="package")
-
-        return sum_emissions(product_materials)

endoreg_db/models/product/product_group.py

@@ -1,27 +0,0 @@
-from django.db import models
-
-class ProductGroupManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-    
-class ProductGroup(models.Model):
-    objects = ProductGroupManager()
-
-    name = models.CharField(max_length=255)
-    name_de = models.CharField(max_length=255, null=True)
-    name_en = models.CharField(max_length=255, null=True)
-    
-    def natural_key(self):
-        return (self.name,)
-    
-    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

@@ -1,28 +0,0 @@
-from django.db import models
-
-class ProductMaterial(models.Model):
-    component = models.CharField(max_length=255)
-    material = models.ForeignKey("Material", on_delete=models.CASCADE)
-    product = models.ForeignKey("Product", on_delete=models.CASCADE, related_name="product_materials")
-    unit = models.ForeignKey("Unit", on_delete=models.CASCADE)
-    quantity = models.FloatField()
-
-    def get_emission(self):
-        from ..emission import EmissionFactor
-        emission_factor:EmissionFactor = self.material.emission_factor
-        if emission_factor is None:
-            raise Exception("No emission factor for material " + self.material.name + " found.")
-        
-        # make sure product_material.unit is the same as emission_factor.unit
-        if self.unit != emission_factor.unit:
-            raise Exception("Unit mismatch: " + self.unit.name + " != " + emission_factor.unit.name)
-        
-        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}"
-    
-        
-