endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/models/administration/shift/shift.py

@@ -0,0 +1,57 @@
+from typing import TYPE_CHECKING, cast
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        CenterShift,
+        Qualification,
+        ShiftType,
+    )
+
+
+class ShiftManager(models.Manager):
+    def get_queryset(self):
+        """
+        Returns a queryset of active shifts.
+
+        Only includes shifts where the 'is_active' field is set to True.
+        """
+        return super().get_queryset().filter(is_active=True)
+
+
+class Shift(models.Model):
+    """
+    Model representing a shift.
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True, null=True)
+    is_active = models.BooleanField(default=True)
+
+    shift_types = models.ManyToManyField(
+        "ShiftType",
+        related_name="shifts",
+    )
+
+    required_qualifications = models.ManyToManyField(
+        "Qualification",
+        related_name="shifts",
+    )
+
+    if TYPE_CHECKING:
+        shift_types = cast(models.QuerySet["ShiftType"], shift_types)
+        required_qualifications = cast(
+            models.QuerySet["Qualification"], required_qualifications
+        )
+
+        @property
+        def center_shifts(self) -> models.QuerySet["CenterShift"]: ...
+
+    objects = ShiftManager()
+
+    def __str__(self):
+        """
+        Returns the string representation of the shift using its name.
+        """
+        return str(self.name)

endoreg_db/models/administration/shift/shift_type.py

@@ -0,0 +1,108 @@
+import logging  # Added import
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import Shift
+
+# Those are defined in our base data
+NAME_REGULAR = "regular"
+NAME_ON_CALL = "on_call"
+NAME_WARD = "ward"
+NAME_OFF_HOURS = "off_hours"
+
+logger = logging.getLogger(__name__)  # Added logger
+
+
+class ShiftTypeManager(models.Manager):
+    def get_queryset(self):
+        """
+        Returns a queryset containing only active shift types.
+        """
+        return super().get_queryset().filter(is_active=True)
+
+
+class ShiftType(models.Model):
+    """
+    Model representing a Shift type.
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True, null=True)
+    is_active = models.BooleanField(default=True)
+
+    objects = ShiftTypeManager()
+
+    if TYPE_CHECKING:
+        shift: models.QuerySet["Shift"]
+
+    def __str__(self):
+        """
+        Returns the name of the shift type as its string representation.
+        """
+        return str(self.name)
+
+    @classmethod
+    def get_type_regular(cls) -> "ShiftType | None":  # Modified return type
+        """
+        Retrieves the 'regular' shift type instance.
+
+        Returns:
+            The ShiftType instance with the name 'regular', or None if it does not exist.
+        """
+        try:
+            return cls.objects.get(name=NAME_REGULAR)
+        except cls.DoesNotExist:
+            logger.error(
+                f"ShiftType with name '{NAME_REGULAR}' does not exist. Base data might be missing."
+            )
+            return None
+
+    @classmethod
+    def get_type_on_call(cls) -> "ShiftType | None":  # Modified return type
+        """
+        Retrieves the ShiftType instance representing the on-call shift type.
+
+        Returns:
+            The ShiftType instance with the on-call name, or None if it does not exist.
+        """
+        try:
+            return cls.objects.get(name=NAME_ON_CALL)
+        except cls.DoesNotExist:
+            logger.error(
+                f"ShiftType with name '{NAME_ON_CALL}' does not exist. Base data might be missing."
+            )
+            return None
+
+    @classmethod
+    def get_type_ward(cls) -> "ShiftType | None":  # Modified return type
+        """
+        Retrieves the ShiftType instance representing a ward shift.
+
+        Returns:
+            The ShiftType instance with the name corresponding to a ward shift, or None if it does not exist.
+        """
+        try:
+            return cls.objects.get(name=NAME_WARD)
+        except cls.DoesNotExist:
+            logger.error(
+                f"ShiftType with name '{NAME_WARD}' does not exist. Base data might be missing."
+            )
+            return None
+
+    @classmethod
+    def get_type_off_hours(cls) -> "ShiftType | None":  # Modified return type
+        """
+        Retrieves the off-hours shift type instance by name.
+
+        Returns:
+            The ShiftType instance for off-hours if it exists, otherwise None.
+        """
+        try:
+            return cls.objects.get(name=NAME_OFF_HOURS)
+        except cls.DoesNotExist:
+            logger.error(
+                f"ShiftType with name '{NAME_OFF_HOURS}' does not exist. Base data might be missing."
+            )
+            return None

endoreg_db/models/aidataset/__init__.py

@@ -0,0 +1,5 @@
+from .aidataset import AIDataSet
+
+__all__ = [
+    "AIDataSet",
+]

endoreg_db/models/aidataset/aidataset.py

@@ -0,0 +1,193 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from endoreg_db.models import ImageClassificationAnnotation
+    # later:
+    # from endoreg_db.models import VideoSegmentationAnnotation
+    # from endoreg_db.models import TextAnnotation  # example name
+
+
+class AIDataSet(models.Model):
+    """
+    AIDataSet stores the definition of a training dataset for an AI model.
+
+    It does NOT store annotation vectors directly.
+
+    Instead, it stores:
+    - which AI model family it is for         (ai_model_type)
+    - which type of data it is based on       (dataset_type)
+    - which annotations belong to it          (image/video/text *_annotations)
+
+    For now:
+        dataset_type == "image"
+            -> image_annotations contains ImageClassificationAnnotation rows
+               (each with frame_id and label_id)
+
+    Later:
+        dataset_type == "video"
+            -> video_annotations will contain video-level annotation rows
+
+        dataset_type == "text"
+            -> text_annotations will contain text-level annotation rows
+    """
+
+    # ------------------------------------------------------------------
+    # CHOICES
+    # ------------------------------------------------------------------
+    DATASET_TYPE_IMAGE = "image"
+    DATASET_TYPE_VIDEO = "video"
+    DATASET_TYPE_TEXT = "text"
+
+    DATASET_TYPE_CHOICES = [
+        (DATASET_TYPE_IMAGE, "Image"),
+        # later, when implemented:
+        # (DATASET_TYPE_VIDEO, "Video"),
+        # (DATASET_TYPE_TEXT, "Text"),
+    ]
+
+    AI_MODEL_TYPE_IMAGE_MULTILABEL = "image_multilabel_classification"
+    # later: add more ai_model_type values as needed, e.g.
+    # AI_MODEL_TYPE_VIDEO_SEGMENTATION = "video_segmentation"
+    # AI_MODEL_TYPE_TEXT_CLASSIFICATION = "text_classification"
+
+    # ------------------------------------------------------------------
+    # BASIC FIELDS
+    # ------------------------------------------------------------------
+
+    name = models.CharField(
+        max_length=255,
+        blank=True,
+        null=True,
+        help_text='Human-readable identifier, e.g. "Legacy multilabel dataset v1".',
+    )
+
+    description = models.TextField(
+        blank=True,
+        null=True,
+        help_text="Optional notes / explanation about this dataset.",
+    )
+
+    ai_model_type = models.CharField(
+        max_length=255,
+        default=AI_MODEL_TYPE_IMAGE_MULTILABEL,
+        help_text=(
+            "AI model family this dataset is for, e.g. "
+            '"image_multilabel_classification". '
+            "Used to pick the correct architecture and output dimension logic."
+        ),
+    )
+
+    dataset_type = models.CharField(
+        max_length=32,
+        choices=DATASET_TYPE_CHOICES,
+        default=DATASET_TYPE_IMAGE,
+        help_text=(
+            "Controls which annotation table will be used. "
+            'Currently only "image" is implemented; later "video", "text", etc.'
+        ),
+    )
+
+    # ------------------------------------------------------------------
+    # TYPE-SPECIFIC ANNOTATION RELATIONS (Option A)
+    # ------------------------------------------------------------------
+    # For each dataset_type, we provide a separate M2M field.
+    # Only one of them is actually *used* per dataset instance.
+    # The others simply remain empty.
+
+    # IMAGE DATASETS:
+    # For dataset_type == "image":
+    #   - image_annotations defines which ImageClassificationAnnotation rows
+    #     belong to this dataset.
+    image_annotations = models.ManyToManyField(
+        "ImageClassificationAnnotation",
+        related_name="image_ai_datasets",
+        blank=True,
+        help_text=(
+            "For dataset_type='image', this is the set of ImageClassificationAnnotation "
+            "rows that define this AIDataSet. Each annotation has frame_id and label_id."
+        ),
+    )
+
+    # VIDEO DATASETS (FUTURE):
+    # For dataset_type == "video", you will later add something like:
+    #
+    # video_annotations = models.ManyToManyField(
+    #     "VideoSegmentationAnnotation",    # or whatever your video annotation model is
+    #     related_name="video_ai_datasets",
+    #     blank=True,
+    #     help_text=(
+    #         "For dataset_type='video', this will be the set of video-level "
+    #         "annotation rows that define this AIDataSet."
+    #     ),
+    # )
+    #
+    # TEXT DATASETS (FUTURE):
+    # For dataset_type == "text", you could add:
+    #
+    # text_annotations = models.ManyToManyField(
+    #     "TextAnnotation",                 # placeholder name
+    #     related_name="text_ai_datasets",
+    #     blank=True,
+    #     help_text=(
+    #         "For dataset_type='text', this will be the set of text-level "
+    #         "annotation rows that define this AIDataSet."
+    #     ),
+    # )
+
+    # ------------------------------------------------------------------
+    # META FIELDS
+    # ------------------------------------------------------------------
+    created_at = models.DateTimeField(
+        auto_now_add=True,
+        help_text="When this AIDataSet was created.",
+    )
+
+    updated_at = models.DateTimeField(
+        auto_now=True,
+        help_text="When this AIDataSet was last modified.",
+    )
+
+    is_active = models.BooleanField(
+        default=True,
+        help_text="Soft toggle to enable/disable this dataset for training.",
+    )
+
+    if TYPE_CHECKING:
+        # for static type checkers only
+        image_annotations: models.ManyToManyField["ImageClassificationAnnotation"]
+        # video_annotations: models.ManyToManyField["VideoSegmentationAnnotation"]
+        # text_annotations: models.ManyToManyField["TextAnnotation"]
+
+    # ------------------------------------------------------------------
+    # UNIFIED ACCESS HELPERS (USE THESE IN YOUR TRAINING CODE)
+    # ------------------------------------------------------------------
+
+    def get_annotations_queryset(self):
+        """
+        Return the *active* annotation relation for this dataset, based on dataset_type.
+
+        - For dataset_type='image' -> returns self.image_annotations
+        - For dataset_type='video' -> later: return self.video_annotations
+        - For dataset_type='text'  -> later: return self.text_annotations
+
+        This is what your data loader / training code should call.
+        """
+        if self.dataset_type == self.DATASET_TYPE_IMAGE:
+            return self.image_annotations
+
+        # TODO (future): implement once video/text annotation models exist
+        # if self.dataset_type == self.DATASET_TYPE_VIDEO:
+        #     return self.video_annotations
+        #
+        # if self.dataset_type == self.DATASET_TYPE_TEXT:
+        #     return self.text_annotations
+
+        # Fallback: empty queryset (nothing to train on)
+        return self.image_annotations.none()
+
+    def __str__(self) -> str:
+        if self.name:
+            return f"AIDataSet(id={self.id}, name={self.name})"
+        return f"AIDataSet(id={self.id})"

endoreg_db/models/label/__init__.py

@@ -0,0 +1,23 @@
+from .annotation import (
+    ImageClassificationAnnotation,
+)
+from .label import Label
+from .label_set import LabelSet
+from .label_type import LabelType
+from .label_video_segment import (
+    LabelVideoSegment,
+)
+from .video_segmentation_label import VideoSegmentationLabel
+from .video_segmentation_labelset import VideoSegmentationLabelSet
+from .annotation import VideoSegmentationAnnotation
+
+__all__ = [
+    "Label",
+    "LabelSet",
+    "LabelType",
+    "VideoSegmentationLabel",
+    "VideoSegmentationLabelSet",
+    "LabelVideoSegment",
+    "ImageClassificationAnnotation",
+    "VideoSegmentationAnnotation",
+]

endoreg_db/models/label/annotation/__init__.py

@@ -0,0 +1,12 @@
+"""Module for annotation models"""
+
+from .image_classification import ImageClassificationAnnotation
+
+from .video_segmentation_annotation import (
+    VideoSegmentationAnnotation,
+)
+
+__all__ = [
+    "ImageClassificationAnnotation",
+    "VideoSegmentationAnnotation",
+]

endoreg_db/models/label/annotation/image_classification.py

@@ -0,0 +1,85 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from ...media.frame import Frame
+    from ...metadata import ModelMeta
+    from ...other.information_source import InformationSource
+    from ..label import Label
+
+
+class ImageClassificationAnnotation(models.Model):
+    """
+    Represents an image classification annotation, linking a label to a specific frame.
+
+    An annotation is associated with a single `Frame` instance, which itself
+    links to either a `Video` or `RawVideoFile`.
+
+    Attributes:
+        frame (ForeignKey): The frame associated with the annotation.
+        label (ForeignKey): The label assigned to the annotation.
+        value (bool): Indicates if the classification is true/positive.
+        float_value (FloatField): Optional float value associated with the classification (e.g., confidence score).
+        annotator (str): Identifier for the user or process that created the annotation.
+        model_meta (ForeignKey): Optional link to the model metadata if generated by a model.
+        date_created (datetime): The creation timestamp of the annotation.
+        date_modified (datetime): The last modification timestamp of the annotation.
+        information_source (ForeignKey): Optional link to the source of this information.
+    """
+
+    # Single ForeignKey to the unified Frame model
+    frame = models.ForeignKey(
+        "Frame",  # Points to the unified Frame model
+        on_delete=models.CASCADE,
+        related_name="image_classification_annotations",
+        blank=False,
+        null=False,
+    )
+
+    label = models.ForeignKey(
+        "Label",
+        on_delete=models.CASCADE,
+        related_name="image_classification_annotations",
+    )
+    value = models.BooleanField()
+    float_value = models.FloatField(blank=True, null=True)
+    annotator = models.CharField(max_length=255, blank=True, null=True)
+    model_meta = models.ForeignKey(
+        "ModelMeta",
+        on_delete=models.SET_NULL,
+        related_name="image_classification_annotations",
+        default=None,
+        null=True,
+        blank=True,
+    )
+    date_created = models.DateTimeField(auto_now_add=True)
+    date_modified = models.DateTimeField(auto_now=True)
+    information_source = models.ForeignKey(
+        "InformationSource",
+        on_delete=models.SET_NULL,
+        related_name="image_classification_annotations",
+        default=None,
+        null=True,
+        blank=True,
+    )
+
+    if TYPE_CHECKING:
+        frame: models.ForeignKey["Frame"]
+        label: models.ForeignKey["Label"]
+        information_source: models.ForeignKey["InformationSource|None"]
+        model_meta: models.ForeignKey["ModelMeta|None"]
+
+    class Meta:
+        indexes = [
+            models.Index(fields=["frame", "label"]),
+            models.Index(fields=["frame"]),
+        ]
+
+    def __str__(self) -> str:
+        """
+        String representation of the annotation.
+        """
+        frame_str = str(self.frame) if self.frame else "No Frame"
+        label_name = self.label.name if self.label else "No Label"
+        return f"{frame_str} - {label_name} - {self.value}"

endoreg_db/models/label/annotation/video_segmentation_annotation.py

@@ -0,0 +1,61 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+from django.db.models import CheckConstraint, F, Q
+
+
+if TYPE_CHECKING:
+    from ...media.video.video_file import VideoFile
+    from ..video_segmentation_label import VideoSegmentationLabel
+
+
+class VideoSegmentationAnnotation(models.Model):
+    """
+    Represents a video segmentation annotation, linking a label to a time segment
+    within a specific video file.
+
+    An annotation must be associated with exactly one `VideoFile`.
+    """
+
+    video_file = models.ForeignKey(
+        "VideoFile",
+        on_delete=models.CASCADE,
+        related_name="video_segmentation_annotations",
+    )
+
+    label = models.ForeignKey(
+        "VideoSegmentationLabel",
+        on_delete=models.CASCADE,
+    )
+
+    # times in seconds
+    start_time = models.FloatField()
+    stop_time = models.FloatField()
+
+    is_true = models.BooleanField(default=True)
+
+    if TYPE_CHECKING:
+        video_file: models.ForeignKey["VideoFile"]
+        label: models.ForeignKey["VideoSegmentationLabel"]
+
+    def __str__(self) -> str:
+        return f"{self.video_file.pk} - {self.label.name} - {self.start_time} to {self.stop_time}"
+
+    def get_video(self) -> "VideoFile":
+        """
+        Convenience accessor for the associated VideoFile instance.
+        """
+        if self.video_file.pk is None:
+            # Should not happen due to null=False
+            raise ValueError("Annotation is not linked to a VideoFile.")
+        return self.video_file
+
+    class Meta:
+        constraints = [
+            CheckConstraint(
+                condition=Q(start_time__lt=F("stop_time")),
+                name="start_time_less_than_stop_time",
+            ),
+        ]
+        # optional but usually helpful:
+        # ordering = ("video_file_id", "start_time")

endoreg_db/models/label/label.py

@@ -0,0 +1,91 @@
+from typing import TYPE_CHECKING
+
+from django.db import models
+
+if TYPE_CHECKING:
+    from .label_set import LabelSet
+    from .label_type import LabelType
+
+
+class LabelManager(models.Manager):
+    """Manager class for handling Label model operations."""
+
+    def get_by_natural_key(self, name):
+        """Retrieves a Label instance by its natural key (name)."""
+        return self.get(name=name)
+
+
+class Label(models.Model):
+    """
+    A class representing a label.
+
+    Attributes:
+        name (str): The name of the label.
+        label_type (LabelType): The type of the label.
+        description (str): A description of the label.
+
+    """
+
+    name = models.CharField(max_length=255)
+    label_type = models.ForeignKey(
+        "LabelType",
+        on_delete=models.CASCADE,
+        related_name="labels",
+        blank=True,
+        null=True,
+    )
+    description = models.TextField(blank=True, null=True)
+
+    objects = LabelManager()
+
+    if TYPE_CHECKING:
+        label_type: models.ForeignKey["LabelType|None"]
+
+        @property
+        def label_sets(self) -> models.QuerySet["LabelSet"]: ...
+
+    def natural_key(self):
+        """Return the natural key of this label"""
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)
+
+    @classmethod
+    def get_outside_label(cls):
+        """
+        Returns the label instance for 'outside'.
+        """
+        try:
+            return cls.objects.get(name="outside")
+        except Exception as exc:
+            raise ValueError("'outside' label does not exist in the database") from exc
+
+    @classmethod
+    def get_low_quality_label(cls):
+        """
+        Retrieve the label instance with the name 'low_quality'.
+
+        Raises:
+            ValueError: If a label with the name 'low_quality' does not exist.
+        """
+        try:
+            return cls.objects.get(name="low_quality")
+        except Exception as exc:
+            raise ValueError(
+                "'low_quality' label does not exist in the database"
+            ) from exc
+
+    @classmethod
+    def get_or_create_from_name(cls, name: str):
+        """
+        Retrieve or create a Label instance with the specified name.
+
+        Parameters:
+            name (str): The name of the label to retrieve or create.
+
+        Returns:
+            tuple: A tuple containing the Label instance and a boolean indicating whether the instance was created (True) or retrieved (False).
+        """
+        label, _created = cls.objects.get_or_create(name=name)
+        return label, _created