endoreg-db 0.8.8.9__py3-none-any.whl → 0.8.9.10__py3-none-any.whl

endoreg_db/models/administration/product/reference_product.py

@@ -10,7 +10,9 @@ if TYPE_CHECKING:
 
 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)
+        return self.get(
+            product__name=product_name, product_group__name=product_group_name
+        )
 
 
 class ReferenceProduct(models.Model):
@@ -25,9 +27,25 @@ class ReferenceProduct(models.Model):
         on_delete=models.CASCADE,
         related_name="reference_product",  # Changed from "reference_products"
     )
-    emission_factor_total = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True, blank=True, related_name="reference_products")
-    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")
+    emission_factor_total = models.ForeignKey(
+        "EmissionFactor",
+        on_delete=models.SET_NULL,
+        null=True,
+        blank=True,
+        related_name="reference_products",
+    )
+    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",
+    )
 
     if TYPE_CHECKING:
         product: models.ForeignKey["Product"]
@@ -45,39 +63,70 @@ class ReferenceProduct(models.Model):
         from ...other.emission import EmissionFactor
 
         product = self.product
-        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"
+        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_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()
+        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"
+        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}
+            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}
+            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}
+            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
 

endoreg_db/models/administration/qualification/qualification.py

@@ -30,7 +30,9 @@ class Qualification(models.Model):
         related_name="qualifications",
     )
     if TYPE_CHECKING:
-        qualification_types = cast(models.manager.RelatedManager["QualificationType"], qualification_types)
+        qualification_types = cast(
+            models.manager.RelatedManager["QualificationType"], qualification_types
+        )
 
     objects = QualificationManager()
 

endoreg_db/models/administration/shift/shift.py

@@ -41,7 +41,9 @@ class Shift(models.Model):
 
     if TYPE_CHECKING:
         shift_types = cast(models.QuerySet["ShiftType"], shift_types)
-        required_qualifications = cast(models.QuerySet["Qualification"], required_qualifications)
+        required_qualifications = cast(
+            models.QuerySet["Qualification"], required_qualifications
+        )
 
         @property
         def center_shifts(self) -> models.QuerySet["CenterShift"]: ...

endoreg_db/models/administration/shift/shift_type.py

@@ -54,7 +54,9 @@ class ShiftType(models.Model):
         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.")
+            logger.error(
+                f"ShiftType with name '{NAME_REGULAR}' does not exist. Base data might be missing."
+            )
             return None
 
     @classmethod
@@ -68,7 +70,9 @@ class ShiftType(models.Model):
         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.")
+            logger.error(
+                f"ShiftType with name '{NAME_ON_CALL}' does not exist. Base data might be missing."
+            )
             return None
 
     @classmethod
@@ -82,7 +86,9 @@ class ShiftType(models.Model):
         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.")
+            logger.error(
+                f"ShiftType with name '{NAME_WARD}' does not exist. Base data might be missing."
+            )
             return None
 
     @classmethod
@@ -96,5 +102,7 @@ class ShiftType(models.Model):
         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.")
+            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

@@ -19,5 +19,5 @@ __all__ = [
     "VideoSegmentationLabelSet",
     "LabelVideoSegment",
     "ImageClassificationAnnotation",
-    "VideoSegmentationAnnotation"
+    "VideoSegmentationAnnotation",
 ]

endoreg_db/models/label/label.py

@@ -27,7 +27,13 @@ class Label(models.Model):
     """
 
     name = models.CharField(max_length=255)
-    label_type = models.ForeignKey("LabelType", on_delete=models.CASCADE, related_name="labels", blank=True, null=True)
+    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()
@@ -66,7 +72,9 @@ class Label(models.Model):
         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
+            raise ValueError(
+                "'low_quality' label does not exist in the database"
+            ) from exc
 
     @classmethod
     def get_or_create_from_name(cls, name: str):

endoreg_db/models/label/label_set.py

@@ -21,7 +21,9 @@ class LabelSetManager(models.Manager):
 
         labelset = queryset.order_by("-version").first()
         if not labelset:
-            raise self.model.DoesNotExist(f"LabelSet with name='{name}' and version='{version}' not found")
+            raise self.model.DoesNotExist(
+                f"LabelSet with name='{name}' and version='{version}' not found"
+            )
         return labelset
 
 

endoreg_db/models/label/label_video_segment/_create_from_video.py

@@ -23,10 +23,14 @@ def _create_from_video(
         raise ValueError("Source must be a VideoFile instance.")
 
     if start_frame_number < 0 or end_frame_number < 0:
-        raise ValueError(f"Frame numbers must be non-negative: start={start_frame_number}, end={end_frame_number}")
+        raise ValueError(
+            f"Frame numbers must be non-negative: start={start_frame_number}, end={end_frame_number}"
+        )
 
     if start_frame_number > end_frame_number:
-        raise ValueError(f"Start frame number ({start_frame_number}) must be less than or equal to end frame number ({end_frame_number})")
+        raise ValueError(
+            f"Start frame number ({start_frame_number}) must be less than or equal to end frame number ({end_frame_number})"
+        )
 
     segment = cls(
         start_frame_number=start_frame_number,