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

endoreg_db/queries/annotations/legacy.py

@@ -0,0 +1,158 @@
+from ...models import LabelSet, ImageClassificationAnnotation
+from django.db.models import Q, F
+from django.db import models
+from tqdm import tqdm
+from collections import defaultdict
+
+# def get_legacy_annotations_for_labelset(labelset_name, version=None):
+#     """
+#     Retrieve annotations for a given label set for training.
+
+#     Args:
+#     - labelset_name (str): The name of the label set.
+#     - version (int, optional): The version of the label set. If not specified, the latest version is fetched.
+
+#     Returns:
+#     - list[dict]: A list of dictionaries. Each dictionary represents an image and its annotations.
+#                   Format: [{"frame": <frame_object>, "annotations": [{"label": <label_name>, "value": <value>}, ...]}, ...]
+
+#     Example:
+#         annotations_for_training = get_annotations_for_labelset("YourLabelSetName", version=2)
+
+#     """
+
+#     # Fetch the label set based on the name and optionally the version
+#     if version:
+#         labelset = LabelSet.objects.get(name=labelset_name, version=version)
+#     else:
+#         labelset = LabelSet.objects.filter(name=labelset_name).order_by('-version').first()
+#         if not labelset:
+#             raise ValueError(f"No label set found with the name: {labelset_name}")
+
+#     # Retrieve all labels in the label set
+#     labels_in_set = labelset.labels.all()
+
+#     # Get the most recent annotations for each frame/label combination
+#     annotations = ImageClassificationAnnotation.objects.filter(label__in=labels_in_set)
+#     annotations = annotations.annotate(
+#         latest_annotation=models.Window(
+#             expression=models.functions.RowNumber(),
+#             partition_by=[F('legacy_image'), F('label')],
+#             order_by=F('date_modified').desc()
+#         )
+#     ).filter(latest_annotation=1)
+
+#     # Organize the annotations by image/frame
+#     organized_annotations = []
+
+#     for annotation in tqdm(annotations):
+#         # ic(annotation)
+#         # Check if the frame is already in the organized list
+#         existing_entry = next((entry for entry in organized_annotations if entry['legacy_image'] == annotation.legacy_frame), None)
+
+#         if existing_entry:
+#             # Add this annotation to the existing frame's annotations
+#             existing_entry['annotations'].append({
+#                 "label": annotation.label.name,
+#                 "value": annotation.value
+#             })
+#         else:
+#             # Create a new entry for this frame
+#             organized_annotations.append({
+#                 "legacy_image": annotation.legacy_image,
+#                 "annotations": [{
+#                     "label": annotation.label.name,
+#                     "value": annotation.value
+#                 }]
+#             })
+
+#     return organized_annotations
+
+
+
+def get_legacy_annotations_for_labelset(labelset_name, version=None):
+    """
+    ... [rest of your docstring]
+    """
+
+    # Fetch the label set based on the name and optionally the version
+    if version:
+        labelset = LabelSet.objects.get(name=labelset_name, version=version)
+    else:
+        labelset = LabelSet.objects.filter(name=labelset_name).order_by('-version').first()
+        if not labelset:
+            raise ValueError(f"No label set found with the name: {labelset_name}")
+
+    # Retrieve all labels in the label set
+    labels_in_set = labelset.labels.all()
+
+    # Get the most recent annotations for each frame/label combination
+    annotations = (ImageClassificationAnnotation.objects
+                   .filter(label__in=labels_in_set)
+                   .select_related('legacy_image', 'label')  # Reduce number of queries
+                   .annotate(
+                        latest_annotation=models.Window(
+                            expression=models.functions.RowNumber(),
+                            partition_by=[F('legacy_image'), F('label')],
+                            order_by=F('date_modified').desc()
+                        )
+                    ).filter(latest_annotation=1))
+
+    # Organize the annotations by image/frame using a defaultdict
+    organized_annotations_dict = defaultdict(lambda: {
+        "legacy_image": None,
+        "annotations": []
+    })
+
+    for annotation in tqdm(annotations):
+        organized_entry = organized_annotations_dict[annotation.legacy_image.id]
+        organized_entry["legacy_image"] = annotation.legacy_image
+        organized_entry["annotations"].append({
+            "label": annotation.label.name,
+            "value": annotation.value
+        })
+
+    # Convert organized_annotations_dict to a list
+    organized_annotations = list(organized_annotations_dict.values())
+
+    return organized_annotations
+
+def generate_legacy_dataset_output(labelset_name, version=None):
+    """
+    Generate an output suitable for creating PyTorch datasets.
+
+    Args:
+    - labelset_name (str): The name of the label set.
+    - version (int, optional): The version of the label set. If not specified, the latest version is fetched.
+
+    Returns:
+    - list[dict]: A list of dictionaries, where each dictionary contains the file path and the labels.
+                  Format: [{"path": <file_path>, "labels": [<label_1_value>, <label_2_value>, ...]}, ...]
+    - labelset[LabelSet]: The label set that was used to generate the output.
+    """
+
+    # First, retrieve the organized annotations using the previously defined function
+    organized_annotations = get_legacy_annotations_for_labelset(labelset_name, version)
+
+    # Fetch all labels from the labelset for consistent ordering
+    labelset = LabelSet.objects.get(name=labelset_name, version=version)
+    all_labels = labelset.get_labels_in_order()
+
+    dataset_output = []
+
+    for entry in organized_annotations:
+        # Prepare a dictionary for each frame
+        frame_data = {
+            "path": entry['legacy_image'].image.path,  # Assuming 'image' field stores the file path
+            "labels": [-1] * len(all_labels)  # Initialize with -1 for all labels
+        }
+
+        # Update the labels based on the annotations
+        for annotation in entry['annotations']:
+            index = next((i for i, label in enumerate(all_labels) if label.name == annotation['label']), None)
+            if index is not None:
+                frame_data['labels'][index] = int(annotation['value'])
+
+        dataset_output.append(frame_data)
+
+    return dataset_output, labelset

endoreg_db/queries/get/__init__.py

@@ -0,0 +1,6 @@
+from .annotation import *
+from .center import *
+from .model import *
+from .patient import *
+from .patient_examination import *
+from .video import *

endoreg_db/queries/get/center.py

@@ -0,0 +1,42 @@
+from endoreg_db.models import Center
+from typing import Optional
+
+def get_centers() -> Center:
+    """
+    Returns all Center objects from the database.
+    """
+    return Center.objects.all()
+
+def get_center_by_name(name) -> Optional[Center]:
+    """Retrieve a Center object by its name.
+
+    Args:
+        name (str): The name of the center to retrieve.
+
+    Returns:
+        Optional[Center]: The Center object with the given name, or None if it does not exist.
+    """
+    return Center.objects.get(name=name)
+
+def get_center_by_id(id) -> Optional[Center]:
+    """Retrieve a Center object by its id.
+
+    Args:
+        id (int): The id of the center to retrieve.
+
+    Returns:
+        Optional[Center]: The Center object with the given id, or None if it does not exist.
+    """
+    return Center.objects.get(id=id)
+
+def get_center_by_natural_key(name: str) -> Optional[Center]:
+    """
+    Retrieve a Center object by its natural key.
+
+    Args:
+        name: The name of the center to retrieve.
+
+    Returns:
+        The Center object with the given name, or None if it does not exist.
+    """
+    return Center.objects.get_by_natural_key(name=name)

endoreg_db/queries/get/model.py

@@ -0,0 +1,13 @@
+from endoreg_db.models import (
+    ModelMeta,
+)
+
+def get_latest_model_by_name(model_name):
+    """
+    Expects model name. Fetches models by name from database, sorts by version and returns latest version.
+    """
+    models = ModelMeta.objects.filter(name=model_name).order_by('-version')
+    if len(models) == 0:
+        return None
+    else:
+        return models[0]

endoreg_db/queries/get/patient.py

@@ -0,0 +1,14 @@
+from endoreg_db.models import Patient
+
+def get_patients() -> Patient:
+    """
+    Returns all Patient objects from the database.
+    """
+    return Patient.objects.all()
+
+def get_patients_without_dob() -> Patient:
+    """
+    Returns all Patient objects from the database without a date of birth.
+    """
+    return Patient.objects.filter(dob__isnull=True)
+

endoreg_db/queries/get/patient_examination.py

@@ -0,0 +1,20 @@
+from endoreg_db.models import PatientExamination
+from typing import Optional
+
+def get_patient_examinations() -> PatientExamination:
+    """
+    Returns all PatientExamination objects from the database.
+    """
+    return PatientExamination.objects.all()
+
+def get_patient_examinations_without_report_file() -> PatientExamination:
+    """
+    Returns all PatientExamination objects from the database without a report_file.
+    """
+    return PatientExamination.objects.filter(report_file__isnull=True)
+
+def get_patient_examinations_without_video() -> PatientExamination:
+    """
+    Returns all PatientExamination objects from the database without a video.
+    """
+    return PatientExamination.objects.filter(video__isnull=True)

endoreg_db/queries/get/report_file.py

@@ -0,0 +1,33 @@
+from endoreg_db.models import ReportFile
+from typing import Optional
+
+def get_report_files() -> ReportFile:
+    """
+    Returns all ReportFile objects from the database.
+    """
+    return ReportFile.objects.all()
+
+def get_report_file_by_id(id) -> Optional[ReportFile]:
+    """Retrieve a ReportFile object by its id.
+
+    Args:
+        id (int): The id of the report_file to retrieve.
+
+    Returns:
+        Optional[ReportFile]: The ReportFile object with the given id, or None if it does not exist.
+    """
+    return ReportFile.objects.get(id=id)
+
+def get_report_files_without_examination() -> ReportFile:
+    """
+    Returns all ReportFile objects from the database without an examination.
+    """
+    return ReportFile.objects.filter(patient_examination__isnull=True)
+
+def get_report_files_without_patient() -> ReportFile:
+    """
+    Returns all ReportFile objects from the database without a patient.
+    """
+    return ReportFile.objects.filter(patient__isnull=True)
+
+

endoreg_db/queries/get/video.py

@@ -0,0 +1,31 @@
+from endoreg_db.models import Video, PatientExamination
+from typing import Optional
+
+def get_videos() -> Video:
+    """
+    Returns all Video objects from the database.
+    """
+    return Video.objects.all()
+
+def get_video_by_id(id) -> Optional[Video]:
+    """Retrieve a Video object by its id.
+
+    Args:
+        id (int): The id of the video to retrieve.
+
+    Returns:
+        Optional[Video]: The Video object with the given id, or None if it does not exist.
+    """
+    return Video.objects.get(id=id)
+
+def get_video_without_examination() -> Video:
+    """
+    Returns all Video objects from the database without an examination.
+    """
+    return Video.objects.filter(patient_examination__isnull=True)
+
+def get_video_without_patient() -> Video:
+    """
+    Returns all Video objects from the database without a patient.
+    """
+    return Video.objects.filter(patient__isnull=True)

endoreg_db/serializers/__init__.py

@@ -0,0 +1,10 @@
+from .ai_model import *
+from .annotation import *
+from .center import *
+from .examination import *
+from .frame import *
+from .hardware import *
+from .label import *
+from .patient import *
+from .report_file import *
+from .video import *

endoreg_db/serializers/ai_model.py

@@ -0,0 +1,19 @@
+from endoreg_db.models import ModelMeta, ModelType, ActiveModel
+from rest_framework import serializers
+
+class ModelMetaSerializer(serializers.ModelSerializer):
+    weights = serializers.FileField(use_url=True)  # use_url=True will provide the file's URI
+
+    class Meta:
+        model = ModelMeta
+        fields = '__all__'
+
+class ModelTypeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ModelType
+        fields = '__all__'
+
+class ActiveModelSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ActiveModel
+        fields = '__all__'

endoreg_db/serializers/annotation.py

@@ -0,0 +1,14 @@
+from rest_framework import serializers
+from endoreg_db.models import  BinaryClassificationAnnotationTask, ImageClassificationAnnotation
+
+
+
+class BinaryClassificationAnnotationTaskSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = BinaryClassificationAnnotationTask
+        fields = '__all__'
+
+class ImageClassificationAnnotationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ImageClassificationAnnotation
+        fields = '__all__'

endoreg_db/serializers/center.py

@@ -0,0 +1,11 @@
+from rest_framework import serializers
+from endoreg_db.models import (
+    Center,
+)
+
+class CenterSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Center
+        fields = '__all__'
+
+

endoreg_db/serializers/examination.py

@@ -0,0 +1,33 @@
+from rest_framework import serializers
+from endoreg_db.models import (
+    Examination,
+    ExaminationTimeType,
+    ExaminationTime,
+    ExaminationType,
+    PatientExamination
+)
+
+class ExaminationTimeTypeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ExaminationTimeType
+        fields = '__all__'
+
+class ExaminationTimeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ExaminationTime
+        fields = '__all__'
+
+class ExaminationTypeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ExaminationType
+        fields = '__all__'
+
+class ExaminationSerializer(serializers.ModelSerializer): 
+    class Meta:
+        model = Examination
+        fields = '__all__'
+
+class PatientExaminationSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = PatientExamination
+        fields = '__all__'

endoreg_db/serializers/frame.py

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

endoreg_db/serializers/hardware.py

@@ -0,0 +1,21 @@
+from rest_framework import serializers
+from endoreg_db.models import (
+    Endoscope,
+    EndoscopeType,
+    EndoscopyProcessor,
+)
+
+class EndoscopeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Endoscope
+        fields = '__all__'
+
+class EndoscopyProcessorSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = EndoscopyProcessor
+        fields = '__all__'
+
+class EndoscopeTypeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = EndoscopeType
+        fields = '__all__'

endoreg_db/serializers/label.py

@@ -0,0 +1,22 @@
+from rest_framework import serializers
+from endoreg_db.models import (
+    Label,
+    LabelSet,
+    LabelType,
+)
+
+class LabelTypeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LabelType
+        fields = '__all__'
+
+class LabelSetSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LabelSet
+        fields = '__all__'
+
+class LabelSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Label
+        fields = '__all__'
+        

endoreg_db/serializers/patient.py

@@ -0,0 +1,33 @@
+from rest_framework import serializers
+from endoreg_db.models import Patient, Gender
+
+class PatientSerializer(serializers.ModelSerializer):
+    # Use the slug field "name" so that the gender is represented by its string value
+    gender = serializers.SlugRelatedField(
+        slug_field='name',
+        queryset=Gender.objects.all()
+    )
+
+    class Meta:
+        model = Patient
+        fields = '__all__'
+        read_only_fields = ['id']
+
+    def get_age(self, obj):
+        return obj.age()
+
+    def create(self, validated_data):
+        center = validated_data.pop('center', None)
+        gender = validated_data.pop('gender', None)
+        patient = Patient.objects.create(center=center, gender=gender, **validated_data)
+        return patient
+
+    def update(self, instance, validated_data):
+        center = validated_data.pop('center', None)
+        gender = validated_data.pop('gender', None)
+        instance.center = center if center else instance.center
+        instance.gender = gender if gender else instance.gender
+        for attr, value in validated_data.items():
+            setattr(instance, attr, value)
+        instance.save()
+        return instance

endoreg_db/serializers/prediction.py

@@ -0,0 +1,10 @@
+from rest_framework import serializers
+from endoreg_db.models import (
+    ImageClassificationPrediction,
+)
+
+
+class ImageClassificationPredictionSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ImageClassificationPrediction
+        fields = "__all__"

endoreg_db/serializers/raw_video_meta_validation.py

@@ -0,0 +1,13 @@
+from rest_framework import serializers
+from ..models import RawVideoFile, SensitiveMeta
+
+class VideoFileForMetaSerializer(serializers.ModelSerializer):
+    """
+    Serializer to fetch video metadata along with linked `SensitiveMeta` details.
+    """
+
+    patient_first_name = serializers.CharField(source="sensitive_meta.patient_first_name", read_only=True)
+
+    class Meta:
+        model = RawVideoFile
+        fields = ['id', 'original_file_name', 'file', 'sensitive_meta_id', 'patient_first_name']

endoreg_db/serializers/report_file.py

@@ -0,0 +1,7 @@
+from rest_framework import serializers
+from endoreg_db.models import ReportFile
+
+class ReportFileSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ReportFile
+        fields = '__all__'

endoreg_db/serializers/video.py

@@ -0,0 +1,20 @@
+from rest_framework import serializers
+from endoreg_db.models import Video, VideoImportMeta, LabelVideoSegment
+
+
+class VideoSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Video
+        fields = "__all__"
+
+
+class VideoImportMetaSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = VideoImportMeta
+        fields = "__all__"
+
+
+class LabelVideoSegmentSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LabelVideoSegment
+        fields = "__all__"