endoreg-db 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

endoreg_db/models/prediction/image_classification.py

@@ -1,37 +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")
-    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")
-    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,244 +0,0 @@
-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 .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
-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
-
-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)
-
-    class Meta:
-        abstract = True
-        unique_together = ('model_meta', 'video')
-
-    def __str__(self):
-        return f"Video {self.video.id} - {self.model_meta.name}"
-    
-    def get_labelset(self):
-        """
-        Get the labelset of the predictions.
-        """
-        return self.model_meta.labelset
-    
-    def get_video_model(self):
-        assert 1 == 2, "This method should be overridden in derived classes"
-
-    def get_frame_model(self):
-        assert 1 == 2, "This method should be overridden in derived classes"
-
-    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 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):
-        """
-        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
-    
-
-    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)
-
-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):
-        """
-        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 LegacyVideoPredictionMeta(AbstractVideoPredictionMeta):
-    video = models.OneToOneField("LegacyVideo", on_delete=models.CASCADE, related_name="video_prediction_meta")
-
-    def get_video_model(self):
-        return LegacyVideo
-
-    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):
-        """
-        Fetches all predictions for this video, labelset, and model meta.
-        """
-        video:LegacyVideo = 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, 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)
-            # 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/__init__.py

@@ -1,5 +0,0 @@
-from .product import Product
-from .product_material import ProductMaterial
-from .product_group import ProductGroup
-from .reference_product import ReferenceProduct
-from .product_weight import ProductWeight

endoreg_db/models/product/product.py

@@ -1,97 +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):
-        return self.name
-    
-    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,19 +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
-    

endoreg_db/models/product/product_material.py

@@ -1,24 +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
-        
-

endoreg_db/models/product/product_weight.py

@@ -1,26 +0,0 @@
-from django.db import models
-import pandas as pd
-
-class ProductWeightManager(models.Manager):
-    def get_by_natural_key(self, product, product_group, weight):
-        return self.get(product=product, product_group=product_group, weight=weight)
-    
-class ProductWeight(models.Model):
-    objects = ProductWeightManager()
-
-    name = models.CharField(max_length=255, null = True)
-    product = models.ForeignKey("Product", on_delete=models.CASCADE)
-    measured = models.FloatField(null=True)
-    verified = models.FloatField(null=True)
-    manufacturer = models.FloatField(null=True)
-    unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
-
-    def get_weight(self):
-        if not pd.isnull(self.verified):
-            return self.verified
-        elif not pd.isnull(self.measured):
-            return self.measured
-        elif not pd.isnull(self.manufacturer):
-            return self.manufacturer
-        else:
-            return None

endoreg_db/models/product/reference_product.py

@@ -1,99 +0,0 @@
-from django.db import models
-from typing import List
-
-class ReferenceProductManager(models.Manager):
-    def get_by_natural_key(self, product_name:str, product_group_name:str):
-        return self.get(product__name=product_name, product_group__name=product_group_name)
-
-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")
-    
-    objects = ReferenceProductManager()
-
-    def __str__(self):
-        return self.product.name + " (" + self.product_group.name + ")"
-    
-    def set_emission_factors(self):
-        from .product import Product
-        from .product_material import ProductMaterial
-        from ..emission import EmissionFactor
-
-        product:Product = self.product
-        materials = product.product_materials.all()
-        emission_factor_name = f"{self.product_group.name}_{product.name}_total_emission_factor"
-        emission_factor_package_name = f"{self.product_group.name}_{product.name}_package_emission_factor"
-        emission_factor_product_name = f"{self.product_group.name}_{product.name}_product_emission_factor"
-
-        product_emissions = 0
-        package_emissions = 0
-
-        product_weight, product_weight_unit = product.get_product_material_weight()
-        package_weight, package_weight_unit = product.get_package_material_weight()
-        product_emission, product_emission_unit = product.get_product_material_emission()
-        package_emission, package_emission_unit = product.get_package_material_emission()
-
-        total_weight = product_weight + package_weight
-        total_emission = product_emission + package_emission
-
-        reference_unit = product_weight_unit
-        assert reference_unit == package_weight_unit, "Package weight units do not match"
-        assert reference_unit == product_emission_unit, "Product emission units do not match"
-        assert reference_unit == package_emission_unit, "Package emission units do not match"
-
-        product_emission_factor_value = product_emission / product_weight
-        package_emission_factor_value = package_emission / package_weight
-        total_emission_factor_value = total_emission / total_weight
-
-        emission_factor, created = EmissionFactor.objects.get_or_create(
-            name=emission_factor_name,
-            defaults={
-                "name": emission_factor_name,
-                "value": total_emission_factor_value,
-                "unit": reference_unit
-            }
-        )
-        self.emission_factor_total = emission_factor
-
-        emission_factor_package, created = EmissionFactor.objects.get_or_create(
-            name=emission_factor_package_name,
-            defaults={
-                "name": emission_factor_package_name,
-                "value": package_emission_factor_value,
-                "unit": reference_unit
-            }
-        )
-        self.emission_factor_package = emission_factor_package
-
-        emission_factor_product, created = EmissionFactor.objects.get_or_create(
-            name=emission_factor_product_name,
-            defaults={
-                "name": emission_factor_product_name,
-                "value": product_emission_factor_value,
-                "unit": reference_unit
-            }
-        )
-        self.emission_factor_product = emission_factor_product
-
-        self.save()
-
-    def get_emission_factor(self, component:str):
-        # check if emission_factor_total exists:
-        if self.emission_factor_total is None:
-            self.set_emission_factors()
-
-        if component == "total":
-            return self.emission_factor_total
-        elif component == "package":
-            return self.emission_factor_package
-        elif component == "product":
-            return self.emission_factor_product
-        else:
-            raise Exception("Unknown component: " + component)
-        
-
-

endoreg_db/models/questionnaires/__init__.py

@@ -1,114 +0,0 @@
-from django.db import models
-
-YES_NO_CHOICES = (
-    ('yes', 'Ja'),
-    ('no', 'Nein'),
-)
-
-class TtoQuestionnaire(models.Model):
-
-    # Patient Information
-    patient_name = models.CharField(max_length=255, verbose_name="Identifikation des Patienten (Name)")
-    birth_date = models.DateField(verbose_name="Geburtsdatum")
-
-    # Base documentation
-    emergency_patient = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Notfallpatient/kürzlich untersuchter Patient (Verzicht auf Team-Time-Out möglich)")
-    consent_signed = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Einverständniserklärung unterschrieben (Arzt, Patient)")
-    documents_present = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Alle Dokumente liegen vor (Labor, Befunde, etc.)")
-    communication_possible = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Kommunikation mit Patient möglich")
-    work_incapacity_certificate = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Arbeitsunfähigkeitsbescheinigung")
-
-    # priority items
-    pregnancy = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Schwangerschaft")
-    asa_classification_checked = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="ASA-Klassifikation/Komorbidität geprüft")
-    previous_anesthesia_complications = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Komplikationen bei bisherigen Narkosen?")
-    last_meal_over_6_hours_ago = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Zeitpunkt letzte Mahlzeit > 6 Stunden")
-    allergies = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Allergien, welche?")
-    outpatient_accompaniment_post_sedation = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Nur bei ambulanter Vorstellung: Begleitung nach Sedierung?")
-    
-    # Possessions
-    dental_prosthesis = models.BooleanField(default=False, verbose_name="Zahnprothese")
-    glasses = models.BooleanField(default=False, verbose_name="Brille")
-    implants = models.BooleanField(default=False, verbose_name="Implantate")
-    hearing_aids = models.BooleanField(default=False, verbose_name="Hörgeräte")
-    
-
-    # Medical History
-    anticoagulants_ass = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Antikoagulation, ASS")
-    blood_pressure_medication = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Blutdruckmedikamente")
-    glaucoma = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Glaukom")
-
-    metal_implants = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Metallimplantate")
-    pacemaker_icd = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Herzschrittmacher/ICD")
-    
-    copd = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="COPD")
-    liver_cirrhosis = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Leberzirrhose")
-    
-    ibd = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="CED (Chronisch entzündliche Darmerkrankungen)")
-    radiation = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Bestrahlung")
-    surgeries = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="OP´s")
-
-    # preflight
-    team_introduction = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Teamvorstellung mit Name und Aufgabe")
-    instruments_available = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Notwendige Instrumente vorhanden?")
-    monitoring_medications_equipment_checked = models.CharField(max_length=3, choices=YES_NO_CHOICES, verbose_name="Monitoring, Medikamente, Equipment zum Atemwegsmanagement zur Verfügung und überprüft?")
-    complete_documentation_inclusive_care_notes = models.TextField(verbose_name="Vollständige Dokumentation inklusive Hinweise für Nachsorge")
-    
-    # notes
-    notes = models.TextField(verbose_name="Bemerkungen", default = "Keine Bemerkungen")
-    
-    # postflight  
-    specimens_secured = models.BooleanField(default=False, verbose_name="Histologische Proben gesichert")
-    patient_condition_documented = models.TextField(verbose_name="Patientenzustand dokumentiert (je nach Ausgangszustand)")
-
-    
-
-    def __str__(self):
-        return f"Endoscopy Questionnaire for {self.patient_name} on {self.birth_date}"
-    
-    def get_id_attributes(self):
-        _ = [self.patient_name, self.birth_date]
-        return _
-    
-    def get_base_documentation_attributes(self):
-        _ = [self.emergency_patient, self.consent_signed, self.documents_present, self.communication_possible, self.work_incapacity_certificate]
-        return _
-    
-    def get_priority_items_attributes(self):
-        _ = [self.pregnancy, self.asa_classification_checked, self.previous_anesthesia_complications, self.last_meal_over_6_hours_ago, self.allergies, self.outpatient_accompaniment_post_sedation]
-        return _
-    
-    def get_possessions_attributes(self):
-        _ = [self.dental_prosthesis, self.glasses, self.implants, self.hearing_aids]
-        return _
-    
-    def get_medical_history_attributes(self): 
-        _ = [
-            self.anticoagulants_ass,
-            self.blood_pressure_medication,
-            self.glaucoma,
-            self.metal_implants,
-            self.pacemaker_icd,
-            self.copd,
-            self.liver_cirrhosis,
-            self.ibd,
-            self.radiation,
-            self.surgeries,
-        ]
-
-    def get_preflight_attributes(self):
-        _ = [
-            self.team_introduction,
-            self.instruments_available,
-            self.monitoring_medications_equipment_checked,
-        ]
-
-    def get_note_attributes(self):
-        _ = [self.notes]
-
-    def get_postflight_attributes(self):
-        _ = [
-            self.specimens_secured,
-            self.patient_condition_documented
-        ]
-

endoreg_db/models/quiz/__init__.py

@@ -1,2 +0,0 @@
-from .quiz_answer import QuizAnswer, QuizAnswerType
-from .quiz_question import QuizQuestion, QuizQuestionType