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

endoreg_db/queries/annotations/legacy.py

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

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

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

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

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

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

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

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

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

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

@@ -1,17 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import LegacyBinaryClassificationAnnotationTask, BinaryClassificationAnnotationTask, ImageClassificationAnnotation
-
-class LegacyBinaryClassificationAnnotationTaskSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyBinaryClassificationAnnotationTask
-        fields = '__all__'
-
-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

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

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

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

endoreg_db/serializers/hardware.py

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

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

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

endoreg_db/serializers/prediction.py

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

endoreg_db/serializers/report_file.py

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

@@ -1,27 +0,0 @@
-from rest_framework import serializers
-from endoreg_db.models import Video, LegacyVideo, VideoImportMeta, LegacyLabelVideoSegment, LabelVideoSegment
-
-class VideoSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = Video
-        fields = '__all__'
-
-class LegacyVideoSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyVideo
-        fields = '__all__'
-
-class VideoImportMetaSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = VideoImportMeta
-        fields = '__all__'
-
-class LabelVideoSegmentSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LabelVideoSegment
-        fields = '__all__'
-
-class LegacyLabelVideoSegmentSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = LegacyLabelVideoSegment
-        fields = '__all__'

endoreg_db/utils/__init__.py

@@ -1 +0,0 @@
-from .dataloader import load_model_data_from_yaml

endoreg_db/utils/cropping.py

@@ -1,29 +0,0 @@
-from PIL import Image
-
-def crop_and_insert(image:Image, x, y, h, w, bg_color=(255, 255, 255)):
-    """
-    Crops a region from an inverted grayscale image and inserts it into a white image of the same size as the original.
-    
-    Parameters:
-    - fp: File path or a file object of the original image.
-    - x, y: The top-left coordinates of the rectangle to be cropped.
-    - h, w: The height and width of the rectangle to be cropped.
-    
-    Returns:
-    A PIL Image object containing the original image with the specified region replaced.
-    """
-    # Load the original image
-    original_image = image
-    
-    # Crop the specified region from the inverted image
-    crop_rectangle = (x, y, x + w, y + h)
-    cropped_content = original_image.crop(crop_rectangle)
-    
-    # Create a new white image of the same size as the original image
-    white_background = Image.new('RGB', original_image.size, bg_color)
-    
-    # Paste the cropped content onto the white image at the specified location
-    white_background.paste(cropped_content, (x, y))
-    
-    # The final image can be displayed or saved as needed
-    return white_background