endoreg-db 0.3.5__py3-none-any.whl → 0.3.6__py3-none-any.whl

endoreg_db/queries/annotations/legacy.py

@@ -1,159 +1,159 @@
-from ...models import LabelSet, ImageClassificationAnnotation
-from django.db.models import Q, F
-from django.db import models
-from icecream import ic
-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
+from ...models import LabelSet, ImageClassificationAnnotation
+from django.db.models import Q, F
+from django.db import models
+from icecream import ic
+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 +1,6 @@
-from .annotation import *
-from .center import *
-from .model import *
-from .patient import *
-from .patient_examination import *
+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 +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)
+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 +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]
+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 +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)
-
+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 +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)
+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 +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)
-
-
+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 +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)
+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)