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

endoreg_db/models/administration/product/product_weight.py

@@ -1,19 +1,22 @@
-from django.db import models
-import pandas as pd
 from typing import TYPE_CHECKING
 
+import pandas as pd
+from django.db import models
+
 if TYPE_CHECKING:
-    from .product import Product
     from ...other.unit import Unit
+    from .product import Product
+
 
 class ProductWeightManager(models.Manager):
     def get_by_natural_key(self, product, product_group, weight):
         return self.get(product=product, product_group=product_group, weight=weight)
-    
+
+
 class ProductWeight(models.Model):
     objects = ProductWeightManager()
 
-    name = models.CharField(max_length=255, null = True)
+    name = models.CharField(max_length=255, null=True)
     product = models.ForeignKey("Product", on_delete=models.CASCADE)
     measured = models.FloatField(null=True)
     verified = models.FloatField(null=True)
@@ -21,8 +24,8 @@ class ProductWeight(models.Model):
     unit = models.ForeignKey("Unit", on_delete=models.SET_NULL, null=True)
 
     if TYPE_CHECKING:
-        product: "Product"
-        unit: "Unit"
+        product: models.ForeignKey["Product"]
+        unit: models.ForeignKey["Unit|None"]
 
     def get_weight(self):
         if not pd.isnull(self.verified):
@@ -33,7 +36,7 @@ class ProductWeight(models.Model):
             return self.manufacturer
         else:
             return None
-        
+
     def get_weight_source(self):
         if not pd.isnull(self.verified):
             return "verified"
@@ -43,5 +46,6 @@ class ProductWeight(models.Model):
             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/administration/product/reference_product.py

@@ -1,13 +1,18 @@
-from django.db import models
 from typing import TYPE_CHECKING
+
+from django.db import models
+
 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):
+    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(
@@ -18,51 +23,32 @@ class ReferenceProduct(models.Model):
     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"
+        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"
-    
+        product: models.ForeignKey["Product"]
+        product_group: models.ForeignKey["ProductGroup"]
+        emission_factor_total: models.ForeignKey["EmissionFactor|None"]
+        emission_factor_package: models.ForeignKey["EmissionFactor|None"]
+        emission_factor_product: models.ForeignKey["EmissionFactor|None"]
+
     objects = ReferenceProductManager()
 
     def __str__(self):
         return self.product.name + " (" + self.product_group.name + ")"
-    
+
     def set_emission_factors(self):
         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"
         emission_factor_product_name = f"{self.product_group.name}_{product.name}_product_emission_factor"
 
-        product_emissions = 0
-        package_emissions = 0
-
         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()
@@ -81,38 +67,23 @@ class ReferenceProduct(models.Model):
         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
 
         self.save()
 
-    def get_emission_factor(self, component:str):
+    def get_emission_factor(self, component: str):
         # check if emission_factor_total exists:
         if self.emission_factor_total is None:
             self.set_emission_factors()
@@ -125,6 +96,3 @@ class ReferenceProduct(models.Model):
             return self.emission_factor_product
         else:
             raise Exception("Unknown component: " + component)
-
-
-

endoreg_db/models/administration/qualification/qualification.py

@@ -1,22 +1,26 @@
+from typing import TYPE_CHECKING, cast
+
 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)
@@ -26,7 +30,7 @@ class Qualification(models.Model):
         related_name="qualifications",
     )
     if TYPE_CHECKING:
-        qualification_types: models.QuerySet["QualificationType"]
+        qualification_types = cast(models.manager.RelatedManager["QualificationType"], qualification_types)
 
     objects = QualificationManager()
 

endoreg_db/models/administration/qualification/qualification_type.py

@@ -1,24 +1,28 @@
-from django.db import models
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 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)

endoreg_db/models/administration/shift/scheduled_days.py

@@ -1,29 +1,32 @@
-from django.db import models
-
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 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,

endoreg_db/models/administration/shift/shift.py

@@ -1,31 +1,33 @@
-from django.db import models
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, cast
 
+from django.db import models
 
 if TYPE_CHECKING:
     from endoreg_db.models import (
-        ShiftType,
-        Qualification,
         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)  
-
+    is_active = models.BooleanField(default=True)
 
     shift_types = models.ManyToManyField(
         "ShiftType",
@@ -38,9 +40,11 @@ class Shift(models.Model):
     )
 
     if TYPE_CHECKING:
-        shift_types: models.QuerySet["ShiftType"]
-        required_qualifications: models.QuerySet["Qualification"]
-        center_shifts: models.QuerySet["CenterShift"]
+        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()
 
@@ -48,4 +52,4 @@ class Shift(models.Model):
         """
         Returns the string representation of the shift using its name.
         """
-        return str(self.name)
+        return str(self.name)

endoreg_db/models/administration/shift/shift_type.py

@@ -1,7 +1,8 @@
-import logging # Added import
-from django.db import models
+import logging  # Added import
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 if TYPE_CHECKING:
     from endoreg_db.models import Shift
 
@@ -11,7 +12,8 @@ NAME_ON_CALL = "on_call"
 NAME_WARD = "ward"
 NAME_OFF_HOURS = "off_hours"
 
-logger = logging.getLogger(__name__) # Added logger
+logger = logging.getLogger(__name__)  # Added logger
+
 
 class ShiftTypeManager(models.Manager):
     def get_queryset(self):
@@ -19,11 +21,13 @@ class ShiftTypeManager(models.Manager):
         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)
@@ -40,69 +44,57 @@ class ShiftType(models.Model):
         return str(self.name)
 
     @classmethod
-    def get_type_regular(cls) -> "ShiftType | None": # Modified return type
+    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."
-            )
+            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
+    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."
-            )
+            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
+    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."
-            )
+            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
+    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."
-            )
+            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,16 +1,15 @@
+from .annotation import (
+    ImageClassificationAnnotation,
+)
 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,
-)
+from .video_segmentation_label import VideoSegmentationLabel
+from .video_segmentation_labelset import VideoSegmentationLabelSet
+from .annotation import VideoSegmentationAnnotation
 
 __all__ = [
     "Label",
@@ -20,5 +19,5 @@ __all__ = [
     "VideoSegmentationLabelSet",
     "LabelVideoSegment",
     "ImageClassificationAnnotation",
-    "VideoSegmentationAnnotation",
-]
+    "VideoSegmentationAnnotation"
+]

endoreg_db/models/label/annotation/image_classification.py

@@ -1,12 +1,13 @@
-from django.db import models
-
 from typing import TYPE_CHECKING
 
+from django.db import models
+
 if TYPE_CHECKING:
-    from ..label import Label
     from ...media.frame import Frame
     from ...metadata import ModelMeta
     from ...other.information_source import InformationSource
+    from ..label import Label
+
 
 class ImageClassificationAnnotation(models.Model):
     """
@@ -64,15 +65,15 @@ class ImageClassificationAnnotation(models.Model):
     )
 
     if TYPE_CHECKING:
-        frame: "Frame"  # Updated type hint
-        label: "Label"
-        information_source: "InformationSource"
-        model_meta: "ModelMeta"  # Added for completeness
+        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']),
+            models.Index(fields=["frame", "label"]),
+            models.Index(fields=["frame"]),
         ]
 
     def __str__(self) -> str:

endoreg_db/models/label/annotation/video_segmentation_annotation.py

@@ -1,61 +1,54 @@
 from typing import TYPE_CHECKING
+
 from django.db import models
-from django.db.models import Q, CheckConstraint, F
+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`.
-
-    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
+    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: "VideoFile"
-        label: "VideoSegmentationLabel"
+        video_file: models.ForeignKey["VideoFile"]
+        label: models.ForeignKey["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}"
+        return f"{self.video_file.pk} - {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.
+        Convenience accessor for the associated VideoFile instance.
         """
-        if self.video_file:
-            return self.video_file
-        else:
-            # This state should ideally not be reachable due to null=False, blank=False
+        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 = [
@@ -64,3 +57,5 @@ class VideoSegmentationAnnotation(models.Model):
                 name="start_time_less_than_stop_time",
             ),
         ]
+        # optional but usually helpful:
+        # ordering = ("video_file_id", "start_time")