endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

endoreg_db/models/administration/product/product_material.py

@@ -0,0 +1,54 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+from endoreg_db.models.other.unit import Unit
+
+if TYPE_CHECKING:
+    from ...other.emission import EmissionFactor
+    from ...other.unit import Unit
+    from .product import Product
+    from ...other.material import Material
+
+class ProductMaterial(models.Model):
+    component = models.CharField(max_length=255)
+    material = models.ForeignKey(
+        "Material",
+        on_delete=models.CASCADE,
+        related_name="material_product_materials", # Changed related_name
+    )
+    product = models.ForeignKey(
+        "Product",
+        on_delete=models.CASCADE,
+        related_name="product_product_materials" # Changed related_name
+    )
+    unit = models.ForeignKey(
+        "Unit",
+        on_delete=models.CASCADE,
+        related_name="unit_product_materials", # Changed related_name
+    )
+    quantity = models.FloatField()
+
+    if TYPE_CHECKING:
+        product: "Product"
+        material: "Material"
+        unit: "Unit"
+        emission_factor: "EmissionFactor"
+
+    def get_emission(self) -> tuple[float, Unit]:
+        emission_factor = self.material.emission_factor
+        if emission_factor is None:
+            raise Exception("No emission factor for material " + self.material.name + " found.")
+        
+        # make sure product_material.unit is the same as emission_factor.unit
+        if self.unit != emission_factor.unit:
+            raise Exception("Unit mismatch: " + self.unit.name + " != " + emission_factor.unit.name)
+        
+        emmision_value = emission_factor.value * self.quantity
+        emission_unit = emission_factor.unit
+        return emmision_value, emission_unit
+    
+    def __str__(self) -> str:
+        return f"{self.product.name} - {self.material.name} - {self.quantity} {self.unit.name}"
+
+
+

endoreg_db/models/{product → administration/product}/product_weight.py

@@ -1,5 +1,10 @@
 from django.db import models
 import pandas as pd
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .product import Product
+    from ...other.unit import Unit
 
 class ProductWeightManager(models.Manager):
     def get_by_natural_key(self, product, product_group, weight):
@@ -15,6 +20,10 @@ class ProductWeight(models.Model):
     manufacturer = models.FloatField(null=True)
     unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
 
+    if TYPE_CHECKING:
+        product: "Product"
+        unit: "Unit"
+
     def get_weight(self):
         if not pd.isnull(self.verified):
             return self.verified
@@ -24,3 +33,15 @@ class ProductWeight(models.Model):
             return self.manufacturer
         else:
             return None
+        
+    def get_weight_source(self):
+        if not pd.isnull(self.verified):
+            return "verified"
+        elif not pd.isnull(self.measured):
+            return "measured"
+        elif not pd.isnull(self.manufacturer):
+            return "manufacturer"
+        else:
+            return None
+    def __str__(self):
+        return f"{self.product} - {self.get_weight()} {self.unit} (Source: {self.get_weight_source()})"

endoreg_db/models/{product → administration/product}/reference_product.py

@@ -1,17 +1,51 @@
 from django.db import models
-from typing import List
-
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from ...other.emission import EmissionFactor
+    from .product import Product
+    from .product_group import ProductGroup
 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)
 
 class ReferenceProduct(models.Model):
     name = models.CharField(max_length=255)
-    product = models.ForeignKey("Product", on_delete=models.CASCADE)
-    product_group = models.OneToOneField("ProductGroup", on_delete=models.CASCADE, related_name="reference_product")
-    emission_factor_total = models.ForeignKey("EmissionFactor", on_delete=models.SET_NULL, null=True, blank = True)
-    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")
+    product = models.ForeignKey(
+        "Product",
+        on_delete=models.CASCADE,
+        related_name="reference_products",
+    )
+    product_group = models.OneToOneField(
+        "ProductGroup",
+        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"
+    )
+
+    if TYPE_CHECKING:
+        product: "Product"
+        product_group: "ProductGroup"
+        emission_factor_total: "EmissionFactor"
+        emission_factor_package: "EmissionFactor"
+        emission_factor_product: "EmissionFactor"
     
     objects = ReferenceProductManager()
 
@@ -19,11 +53,8 @@ class ReferenceProduct(models.Model):
         return self.product.name + " (" + self.product_group.name + ")"
     
     def set_emission_factors(self):
-        from .product import Product
-        from .product_material import ProductMaterial
-        from ..emission import EmissionFactor
-
-        product:Product = self.product
+        from ...other.emission import EmissionFactor
+        product = self.product
         materials = product.product_materials.all()
         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"
@@ -94,6 +125,6 @@ class ReferenceProduct(models.Model):
             return self.emission_factor_product
         else:
             raise Exception("Unknown component: " + component)
-        
+
 
 

endoreg_db/models/administration/qualification/__init__.py

@@ -0,0 +1,7 @@
+from .qualification import Qualification
+from .qualification_type import QualificationType
+
+__all__ = [
+    "Qualification",
+    "QualificationType",
+]

endoreg_db/models/administration/qualification/qualification.py

@@ -0,0 +1,37 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        QualificationType,
+    )
+
+class QualificationManager(models.Manager):
+    def get_queryset(self):
+        """
+        Returns a queryset of qualifications filtered to include only active entries.
+        """
+        return super().get_queryset().filter(is_active=True)
+    
+class Qualification(models.Model):
+    """
+    Model representing a qualification.
+    """
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True, null=True)
+    is_active = models.BooleanField(default=True)
+
+    qualification_types = models.ManyToManyField(
+        "QualificationType",
+        related_name="qualifications",
+    )
+    if TYPE_CHECKING:
+        qualification_types: models.QuerySet["QualificationType"]
+
+    objects = QualificationManager()
+
+    def __str__(self):
+        """
+        Returns the string representation of the qualification's name.
+        """
+        return str(self.name)

endoreg_db/models/administration/qualification/qualification_type.py

@@ -0,0 +1,35 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        Qualification,
+    )
+
+class QualificationTypeManager(models.Manager):
+    def get_queryset(self):
+        """
+        Returns a queryset of active qualification types.
+        
+        Only includes records where the `is_active` field is set to True.
+        """
+        return super().get_queryset().filter(is_active=True)
+    
+class QualificationType(models.Model):
+    """
+    Model representing a qualification type.
+    """
+    name = models.CharField(max_length=255, unique=True)
+    description = models.TextField(blank=True, null=True)
+    is_active = models.BooleanField(default=True)
+
+    objects = QualificationTypeManager()
+
+    if TYPE_CHECKING:
+        qualification: models.QuerySet["Qualification"]
+
+    def __str__(self):
+        """
+        Returns the string representation of the qualification type's name.
+        """
+        return str(self.name)

endoreg_db/models/administration/shift/__init__.py

@@ -0,0 +1,9 @@
+from .shift import Shift
+from .shift_type import ShiftType
+from .scheduled_days import ScheduledDays
+
+__all__ = [
+    "Shift",
+    "ShiftType",
+    "ScheduledDays",
+]

endoreg_db/models/administration/shift/scheduled_days.py

@@ -0,0 +1,69 @@
+from django.db import models
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        CenterShift,
+    )
+
+class ScheduledDaysManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieves a ScheduledDays instance by its unique name.
+        
+        Args:
+            name: The unique name of the ScheduledDays instance to retrieve.
+        
+        Returns:
+            The ScheduledDays instance matching the given name.
+        """
+        return self.get(name=name)
+    
+class ScheduledDays(models.Model):
+    """
+    Model representing scheduled days for a shift.
+    """
+    name = models.CharField(
+        max_length=255,
+        unique=True,
+        help_text="Name of the scheduled days.",
+    )
+    working_days = models.BooleanField(
+        null=True,
+        blank=True,
+        default=True,
+    )
+
+    non_working_days = models.BooleanField(
+        null=True,
+        blank=True,
+        default=False,
+    )
+
+    limited_time = models.BooleanField(
+        null=True,
+        blank=True,
+        default=False,
+    )
+
+    start_date = models.DateField(
+        null=True,
+        blank=True,
+    )
+
+    end_date = models.DateField(
+        null=True,
+        blank=True,
+    )
+
+    objects = ScheduledDaysManager()
+
+    if TYPE_CHECKING:
+        center_shifts: models.QuerySet["CenterShift"]
+
+    def __str__(self):
+        """
+        Returns a string representation of the scheduled day, including its name and date range.
+        """
+        return f"{self.name} - {self.start_date} to {self.end_date}"

endoreg_db/models/administration/shift/shift.py

@@ -0,0 +1,51 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+
+if TYPE_CHECKING:
+    from endoreg_db.models import (
+        ShiftType,
+        Qualification,
+        CenterShift,
+    )
+
+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: models.QuerySet["ShiftType"]
+        required_qualifications: models.QuerySet["Qualification"]
+        center_shifts: 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 django.db import models
+from typing import TYPE_CHECKING
+
+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/label/__init__.py

@@ -1 +1,24 @@
-from .label import Label, LabelType, LabelSet
+from .label import Label
+from .label_set import LabelSet
+from .label_type import LabelType
+from .video_segmentation_label import VideoSegmentationLabel
+from .video_segmentation_labelset import VideoSegmentationLabelSet
+from .label_video_segment import (
+    LabelVideoSegment,
+)
+
+from .annotation import (
+    ImageClassificationAnnotation,
+    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,84 @@
+from django.db import models
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..label import Label
+    from ...media.frame import Frame
+    from ...metadata import ModelMeta
+    from ...other.information_source import InformationSource
+
+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: "Frame"  # Updated type hint
+        label: "Label"
+        information_source: "InformationSource"
+        model_meta: "ModelMeta"  # Added for completeness
+
+    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,66 @@
+from typing import TYPE_CHECKING
+from django.db import models
+from django.db.models import Q, CheckConstraint, F
+
+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`.
+
+    Attributes:
+        video_file (ForeignKey): The video file associated with the annotation.
+        label (ForeignKey): The label for the annotation.
+        start_time (float): The start time of the annotation in seconds.
+        stop_time (float): The stop time of the annotation in seconds.
+        is_true (bool): Indicates if the annotation is valid (defaults to True).
+    """
+    # Foreign key to the unified VideoFile model.
+    video_file = models.ForeignKey(
+        "VideoFile",
+        on_delete=models.CASCADE,
+        related_name="video_segmentation_annotations",
+        null=False,
+        blank=False,
+    )
+
+    label = models.ForeignKey("VideoSegmentationLabel", on_delete=models.CASCADE)
+    start_time = models.FloatField()  # in seconds
+    stop_time = models.FloatField()  # in seconds
+    is_true = models.BooleanField(default=True)
+
+    if TYPE_CHECKING:
+        video_file: "VideoFile"
+        label: "VideoSegmentationLabel"
+
+    def __str__(self) -> str:
+        """
+        String representation of the annotation.
+        """
+        video_repr = self.get_video() # Get the actual video object for representation
+        return f"{video_repr} - {self.label.name} - {self.start_time} to {self.stop_time}"
+
+    def get_video(self) -> "VideoFile":
+        """
+        Get the video file associated with this annotation.
+
+        Returns the `VideoFile` instance.
+        """
+        if self.video_file:
+            return self.video_file
+        else:
+            # This state should ideally not be reachable due to null=False, blank=False
+            raise ValueError("Annotation is not linked to a VideoFile.")
+
+    class Meta:
+        constraints = [
+            CheckConstraint(
+                condition=Q(start_time__lt=F("stop_time")),
+                name="start_time_less_than_stop_time",
+            ),
+        ]