endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/models/__init__.py

@@ -0,0 +1,322 @@
+####### Administration ########
+from .administration import (
+    ActiveModel,
+    AiModel,
+    Case,
+    Center,
+    CenterProduct,
+    CenterResource,
+    CenterShift,
+    CenterWaste,
+    Employee,
+    EmployeeQualification,
+    EmployeeType,
+    Examiner,
+    FirstName,
+    LastName,
+    ModelType,
+    Patient,
+    PatientExternalID,
+    Person,
+    PortalUserInfo,
+    Product,
+    ProductGroup,
+    ProductMaterial,
+    ProductWeight,
+    Profession,
+    Qualification,
+    QualificationType,
+    ReferenceProduct,
+    ScheduledDays,
+    Shift,
+    ShiftType,
+)
+
+####### Label ########
+from .label import (
+    ImageClassificationAnnotation,
+    Label,
+    LabelSet,
+    LabelType,
+    LabelVideoSegment,
+    VideoSegmentationAnnotation,
+    VideoSegmentationLabel,
+    VideoSegmentationLabelSet,
+)
+
+####### Media ########
+from .media import (
+    AnonymExaminationReport,
+    AnonymHistologyReport,
+    DocumentType,
+    Frame,
+    RawPdfFile,
+    ReportReaderConfig,
+    ReportReaderFlag,
+    VideoFile,
+    VideoMetadata,
+    VideoProcessingHistory,
+)
+
+######## Medical ########
+from .medical import (
+    Contraindication,
+    Disease,
+    DiseaseClassification,
+    DiseaseClassificationChoice,
+    Endoscope,
+    EndoscopeType,
+    EndoscopyProcessor,
+    Event,
+    EventClassification,
+    EventClassificationChoice,
+    Examination,
+    ExaminationIndication,
+    ExaminationIndicationClassification,
+    ExaminationIndicationClassificationChoice,
+    ExaminationRequirementSet,
+    ExaminationTime,
+    ExaminationTimeType,
+    ExaminationType,
+    Finding,
+    FindingClassification,
+    FindingClassificationChoice,
+    FindingClassificationType,
+    FindingIntervention,
+    FindingInterventionType,
+    FindingType,
+    LabValue,
+    Medication,
+    MedicationIndication,
+    MedicationIndicationType,
+    MedicationIntakeTime,
+    MedicationSchedule,
+    Organ,
+    PatientDisease,
+    PatientEvent,
+    PatientExamination,
+    PatientExaminationIndication,
+    PatientFinding,
+    PatientFindingClassification,
+    PatientFindingIntervention,
+    PatientLabSample,
+    PatientLabSampleType,
+    PatientLabValue,
+    PatientMedication,
+    PatientMedicationSchedule,
+    Risk,
+    RiskType,
+)
+
+####### Metadata ########
+from .metadata import (
+    FFMpegMeta,
+    ModelMeta,
+    PdfMeta,
+    PdfType,
+    SensitiveMeta,
+    VideoImportMeta,
+    VideoMeta,
+    VideoPredictionMeta,
+)
+from .other import (
+    BaseValueDistribution,
+    DateValueDistribution,
+    EmissionFactor,
+    Gender,
+    InformationSource,
+    InformationSourceType,
+    Material,
+    MultipleCategoricalValueDistribution,
+    NumericValueDistribution,
+    Resource,
+    SingleCategoricalValueDistribution,
+    Tag,
+    TransportRoute,
+    Unit,
+    Waste,
+)
+from .requirement import (
+    Requirement,
+    RequirementOperator,
+    RequirementSet,
+    RequirementSetType,
+    RequirementType,
+)
+from .state import (
+    AnonymizationState,
+    LabelVideoSegmentState,
+    RawPdfState,
+    SensitiveMetaState,
+    VideoState,
+)
+
+# AI dataset model
+from .aidataset import (
+    AIDataSet,
+)
+
+
+__all__ = [
+    ####### Administration ########
+    # AI
+    "AiModel",
+    "ActiveModel",
+    "ModelType",
+    # Case
+    "Case",
+    # Center
+    "Center",
+    "CenterProduct",
+    "CenterResource",
+    "CenterWaste",
+    "CenterShift",
+    # Person
+    "Person",
+    "Patient",
+    "PatientExternalID",
+    "Examiner",
+    "PortalUserInfo",
+    "FirstName",
+    "LastName",
+    "Profession",
+    "Employee",
+    "EmployeeType",
+    "EmployeeQualification",
+    # Product
+    "Product",
+    "ProductMaterial",
+    "ProductGroup",
+    "ReferenceProduct",
+    "ProductWeight",
+    # Qualification
+    "Qualification",
+    "QualificationType",
+    # Shift
+    "Shift",
+    "ShiftType",
+    "ScheduledDays",
+    ####### Label ########
+    "Label",
+    "LabelSet",
+    "LabelType",
+    "VideoSegmentationLabel",
+    "VideoSegmentationLabelSet",
+    "LabelVideoSegment",
+    "ImageClassificationAnnotation",
+    "VideoSegmentationAnnotation",
+    ####### Media ########
+    "VideoFile",
+    "Frame",
+    "RawPdfFile",
+    "DocumentType",
+    "AnonymExaminationReport",
+    "AnonymHistologyReport",
+    "ReportReaderConfig",
+    "ReportReaderFlag",
+    "VideoMetadata",
+    "VideoProcessingHistory",
+    ######## Medical ########
+    # Disease
+    "Disease",
+    "DiseaseClassification",
+    "DiseaseClassificationChoice",
+    # Event
+    "Event",
+    "EventClassification",
+    "EventClassificationChoice",
+    # Contraindication
+    "Contraindication",
+    # Examination
+    "Examination",
+    "ExaminationRequirementSet",
+    "ExaminationType",
+    "ExaminationIndication",
+    "ExaminationIndicationClassificationChoice",
+    "ExaminationIndicationClassification",
+    "ExaminationTime",
+    "ExaminationTimeType",
+    # Finding
+    "Finding",
+    "FindingClassificationType",
+    "FindingClassification",
+    "FindingClassificationChoice",
+    "FindingType",
+    "FindingIntervention",
+    "FindingInterventionType",
+    # Patient
+    ## Disease
+    "PatientDisease",
+    ## Event
+    "PatientEvent",
+    ## Examination
+    "PatientExaminationIndication",
+    "PatientExamination",
+    ## Finding
+    "PatientFinding",
+    "PatientFindingIntervention",
+    "PatientFindingClassification",
+    ## Laboratory
+    "PatientLabSample",
+    "PatientLabSampleType",
+    "PatientLabValue",
+    ## Medication
+    "PatientMedication",
+    "PatientMedicationSchedule",
+    # Organ
+    "Organ",
+    # Risk
+    "Risk",
+    "RiskType",
+    # Medication
+    "Medication",
+    "MedicationSchedule",
+    "MedicationIntakeTime",
+    "MedicationIndicationType",
+    "MedicationIndication",
+    # Hardware
+    "Endoscope",
+    "EndoscopeType",
+    "EndoscopyProcessor",
+    # Laboratory
+    "LabValue",
+    ####### Metadata ########
+    "SensitiveMeta",
+    "PdfMeta",
+    "PdfType",
+    "VideoMeta",
+    "FFMpegMeta",
+    "VideoImportMeta",
+    "ModelMeta",
+    "VideoPredictionMeta",
+    ####### Other #######
+    "Material",
+    "Resource",
+    "TransportRoute",
+    "Waste",
+    "BaseValueDistribution",
+    "NumericValueDistribution",
+    "SingleCategoricalValueDistribution",
+    "MultipleCategoricalValueDistribution",
+    "DateValueDistribution",
+    "Gender",
+    "InformationSource",
+    "InformationSourceType",
+    "Unit",
+    "EmissionFactor",
+    "Tag",
+    ###### Requirement ######
+    "Requirement",
+    "RequirementType",
+    "RequirementOperator",
+    "RequirementSet",
+    "RequirementSetType",
+    ####### State ########
+    "SensitiveMetaState",
+    "VideoState",
+    "LabelVideoSegmentState",
+    "AnonymizationState",
+    "RawPdfState",
+    ###### AIDATASET ######
+    "AIDataSet",
+]

endoreg_db/models/administration/__init__.py

@@ -0,0 +1,95 @@
+# AI
+from .ai import (
+    ActiveModel,
+    AiModel,
+    ModelType,
+)
+
+# Case
+from .case import (
+    Case,
+)
+
+# Center
+from .center import (
+    Center,
+    CenterProduct,
+    CenterResource,
+    CenterShift,
+    CenterWaste,
+)
+
+# TODO Review module
+# from .permissions import ()
+# Person
+from .person import (
+    Employee,
+    EmployeeQualification,
+    EmployeeType,
+    Examiner,
+    FirstName,
+    LastName,
+    Patient,
+    PatientExternalID,
+    Person,
+    PortalUserInfo,
+    Profession,
+)
+
+# Product
+from .product import (
+    Product,
+    ProductGroup,
+    ProductMaterial,
+    ProductWeight,
+    ReferenceProduct,
+)
+from .qualification import (
+    Qualification,
+    QualificationType,
+)
+from .shift import (
+    ScheduledDays,
+    Shift,
+    ShiftType,
+)
+
+__all__ = [
+    # AI
+    "AiModel",
+    "ActiveModel",
+    "ModelType",
+    # Case
+    "Case",
+    # Center
+    "Center",
+    "CenterProduct",
+    "CenterResource",
+    "CenterWaste",
+    "CenterShift",
+    # Person
+    "Person",
+    "Patient",
+    "PatientExternalID",
+    "Examiner",
+    "PortalUserInfo",
+    "FirstName",
+    "LastName",
+    "Profession",
+    "Employee",
+    "EmployeeType",
+    "EmployeeQualification",
+    # Product
+    "Product",
+    "ProductMaterial",
+    "ProductGroup",
+    "ReferenceProduct",
+    "ProductWeight",
+    # Qualification
+    "Qualification",
+    "QualificationType",
+    # Shift
+    "Shift",
+    "ShiftType",
+    "ScheduledDays",
+]

endoreg_db/models/administration/ai/__init__.py

@@ -0,0 +1,9 @@
+from .model_type import ModelType
+from .active_model import ActiveModel
+from .ai_model import AiModel
+
+__all__ = [
+    "ModelType",
+    "ActiveModel",
+    "AiModel",
+]

endoreg_db/models/administration/ai/active_model.py

@@ -0,0 +1,35 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.models.metadata import ModelMeta
+
+
+class ActiveModelManager(models.Manager):
+    def get_by_natural_key(self, name):
+        return self.get(name=name)
+
+
+class ActiveModel(models.Model):
+    """
+    ActiveModel represents an active instance of a model within the application.
+    Attributes:
+        name (str): A unique identifier for the active model.
+        model_meta (ModelMeta, optional): A reference to the metadata of the model. This field acts as a ForeignKey
+                                            to the ModelMeta model and can be null.
+    Notes:
+        - The model_meta attribute is configured with on_delete=models.SET_NULL, meaning that if the related ModelMeta
+          record is deleted, model_meta will be set to null.
+        - Type hints for model_meta are provided under a TYPE_CHECKING conditional import to avoid circular dependencies,
+          importing ModelMeta only when type checking is performed.
+    Managers:
+        objects (ActiveModelManager): Custom manager providing specialized query capabilities for ActiveModel instances.
+    """
+
+    name = models.CharField(max_length=255, unique=True)
+
+    model_meta: models.ForeignKey["ModelMeta|None"] = models.ForeignKey(
+        "ModelMeta", on_delete=models.SET_NULL, blank=True, null=True
+    )
+
+    objects = ActiveModelManager()

endoreg_db/models/administration/ai/ai_model.py

@@ -0,0 +1,180 @@
+"""
+Django model for AI models.
+"""
+
+from django.db import models
+from icecream import ic
+from typing import TYPE_CHECKING
+from logging import getLogger
+
+logger = getLogger(__name__)
+
+if TYPE_CHECKING:
+    from .model_type import ModelType
+    from ...metadata import ModelMeta
+    from ...label import VideoSegmentationLabelSet
+
+    # Forward reference AiModel for use in type hints within the class itself
+    from typing import ForwardRef
+
+    AiModelRef = ForwardRef("'AiModel'")
+
+
+class AiModelManager(models.Manager):
+    """
+    Manager for AI models with custom query methods.
+    """
+
+    def get_by_natural_key(self, name: str):
+        """
+        Retrieves the AiModel instance with the specified unique name.
+
+        Args:
+            name: The unique identifier of the AiModel to retrieve.
+
+        Returns:
+            The AiModel instance matching the given name.
+
+        Raises:
+            AiModel.DoesNotExist: If no AiModel with the specified name exists.
+        """
+        return self.get(name=name)
+
+
+class AiModel(models.Model):
+    """
+    Represents a generic AI model that encapsulates high-level metadata about the model,
+    including names (default, German, and English), a description, categorization details,
+    and associated label sets and meta information.
+
+        name (str): Unique name of the AI model.
+        description (str): Optional detailed description of the AI model.
+        model_type (str): Optional type/category of the AI model.
+        model_subtype (str): Optional subtype within the broader model type.
+        video_segmentation_labelset (VideoSegmentationLabelSet): Optional associated label set for video segmentation tasks.
+        active_meta (ModelMeta): Optional reference to the currently active ModelMeta instance associated with the model.
+    """
+
+    objects = AiModelManager()
+
+    name = models.CharField(max_length=255, unique=True)
+
+    description = models.TextField(blank=True, null=True)
+    model_type = models.ForeignKey(
+        "ModelType",
+        on_delete=models.CASCADE,
+        related_name="ai_models",
+        blank=True,
+        null=True,
+    )
+    model_subtype = models.CharField(max_length=255, blank=True, null=True)
+    video_segmentation_labelset = models.ForeignKey(
+        "VideoSegmentationLabelSet",
+        on_delete=models.CASCADE,
+        related_name="ai_models",
+        blank=True,
+        null=True,
+    )
+    active_meta = models.ForeignKey(
+        "ModelMeta",
+        on_delete=models.SET_NULL,
+        related_name="active_model",
+        blank=True,
+        null=True,
+    )
+
+    if TYPE_CHECKING:
+        metadata_versions: models.QuerySet["ModelMeta"]
+        model_type: models.ForeignKey["ModelType|None"]
+        active_meta: models.ForeignKey["ModelMeta|None"]
+        video_segmentation_labelset: models.ForeignKey["VideoSegmentationLabelSet|None"]
+
+    def get_version(self, version: int) -> "ModelMeta":
+        """
+        Retrieves the ModelMeta instance for the specified version.
+
+        If the active_meta matches the requested version, it is returned. Otherwise, searches related metadata_versions for a matching version. Raises ValueError if no matching metadata is found.
+
+        Args:
+            version: The version number of the desired ModelMeta.
+
+        Returns:
+            The ModelMeta instance corresponding to the specified version.
+
+        Raises:
+            ValueError: If no ModelMeta with the given version exists.
+        """
+        if self.active_meta is not None and self.active_meta.version == version:
+            return self.active_meta
+
+        # Get the model metadata with the given version
+        model_meta = self.metadata_versions.filter(version=version).first()
+        if model_meta is not None:
+            return model_meta
+
+        raise ValueError(f"No model metadata found for version {version}.")
+
+    def get_latest_version(self) -> "ModelMeta":
+        if self.active_meta is not None:
+            return self.active_meta
+
+        latest_version = self.metadata_versions.order_by("-version").first()
+        if latest_version is not None:
+            return latest_version
+
+        # Only in environments where auto-download is acceptable:
+        try:
+            logger.info(
+                "Locally, no segmentation model was available. We are using colo_segmentation_RegNetX800MF_base."
+            )
+            from endoreg_db.services.model_meta_from_hf import ensure_model_meta_from_hf
+
+            model_meta = ensure_model_meta_from_hf(
+                model_id="wg-lux/colo_segmentation_RegNetX800MF_base",
+                model_name="image_multilabel_classification_colonoscopy_default",
+                labelset_name="multilabel_classification_colonoscopy_default",
+                meta_version="1",
+            )
+            return model_meta
+        except Exception:
+            logger.exception(
+                "Failed to ensure ModelMeta from Hugging Face for AiModel '%s'",
+                self.name,
+            )
+
+        raise ValueError("No model metadata found for this model.")
+
+    @classmethod
+    def set_active_model_meta(cls, model_name: str, meta_name: str, meta_version: int):
+        """
+        Sets the active metadata version for the specified AI model.
+
+        Updates the `active_meta` field of the AiModel identified by `model_name` to the ModelMeta instance matching `meta_name` and `meta_version`.
+        """
+        from ...metadata import ModelMeta
+
+        model = cls.objects.get(name=model_name)
+        assert model is not None, "Model not found"
+
+        ic(f"Getting model meta for {model_name} {meta_name} {meta_version}")
+
+        model_meta = ModelMeta.objects.get(
+            name=meta_name, model=model, version=meta_version
+        )
+        assert model_meta is not None, "ModelMeta not found"
+
+        model.active_meta = model_meta
+        model.save()
+
+        ic(
+            f"Set active model meta for {model_name} to {meta_name} version {meta_version}"
+        )
+
+    def natural_key(self):
+        """
+        Return the natural key for this model.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        return str(self.name)

endoreg_db/models/administration/ai/model_type.py

@@ -0,0 +1,42 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .ai_model import AiModel
+
+
+class ModelTypeManager(models.Manager):
+    """
+    Custom manager for ModelType with additional query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "ModelType":
+        """Get the model type by its natural key"""
+        return self.get(name=name)
+
+
+class ModelType(models.Model):
+    """
+    A class representing a model type.
+
+    Attributes:
+        name (str): The name of the model type.
+        description (str): A description of the model type.
+
+    """
+
+    name = models.CharField(max_length=255)
+    description = models.TextField(blank=True, null=True)
+
+    objects = ModelTypeManager()
+
+    if TYPE_CHECKING:
+        ai_models: models.QuerySet["AiModel"]
+
+    def natural_key(self):
+        """Return the natural key for this model type"""
+        return (self.name,)
+
+    def __str__(self):
+        """Return the name of the model type"""
+        return str(self.name)

endoreg_db/models/administration/case/__init__.py

@@ -0,0 +1,5 @@
+from .case import Case
+
+__all__ = [
+    "Case",
+]