endoreg-db 0.6.3__py3-none-any.whl → 0.6.4__py3-none-any.whl

endoreg_db/models/requirement/requirement_evaluation/requirement_type_parser.py

@@ -0,0 +1,102 @@
+# Currently those strings MUST match the ones
+# in the requirement_type data definitions
+from collections import namedtuple
+from endoreg_db.models import (
+    Requirement,
+    RequirementType,
+    PatientExamination,
+    PatientFindingIntervention,
+    Examination,
+    ExaminationIndication,
+    Disease,
+    DiseaseClassificationChoice,
+    PatientEvent,
+    PatientFinding,
+    PatientFindingMorphology,
+)
+from typing import List
+from icecream import ic
+# Requirement has RequirementTypes
+# Requirement has RequirementOperators
+# For each Operator/Type pair, there must be a custom function
+# for evaluation
+
+OperatorTypeTuple = namedtuple("OperatorTypeTuple", ["operator", "requirement_type"])
+
+
+data_model_dict = {
+    "patient_examination": PatientExamination,
+    "finding_intervention": PatientFindingIntervention,
+    "finding_interventions": List[PatientFindingIntervention],
+    "examination": Examination,
+    "examination_indication": ExaminationIndication,
+    "disease": Disease,
+    "disease_classification_choice": DiseaseClassificationChoice,
+    "event": PatientEvent,
+    "finding": PatientFinding,
+    "finding_morphology": PatientFindingMorphology,
+    # Add more mappings as needed
+}
+
+
+def evaluate_operator_type_tuple(
+    operator_type_tuple: OperatorTypeTuple, data: object, **kwargs
+):
+    """
+    Evaluates the requirement type and operator tuple against the provided data.
+
+    Args:
+        operator_type_tuple (OperatorTypeTuple): Tuple containing requirement type and operator.
+        data (object): The data to evaluate.
+        **kwargs: Additional keyword arguments.
+
+    Returns:
+        bool: True if the evaluation is successful, False otherwise.
+    """
+    # data = kwargs.get(name, None)
+
+    # # make sure data type matches the model for the req_type name
+    # if data is None:
+    #     raise ValueError(f"No data found for requirement type: {name}")
+    # if name not in data_model_dict:
+    #     raise ValueError(f"Unknown requirement type: {name}")
+
+    # model = data_model_dict[name]
+    # if not isinstance(data, model):
+    #     raise TypeError(
+    #         f"Data type mismatch for {name}: expected {model}, got {type(data)}"
+    #     )
+
+    requirement_type = operator_type_tuple.requirement_type
+    operator = operator_type_tuple.operator
+
+    # Call the appropriate function based on the requirement type and operator
+    # This is a placeholder; actual implementation will depend on your logic
+    return True  # Replace with actual evaluation logic
+
+
+def evaluate_requirement(requirement: Requirement, **kwargs):
+    requirement_types = requirement.requirement_types.all()
+    requirement_operators = requirement.operators.all()
+    operator_return_values = {}
+    operator_evaluation_results = {}
+
+    for requirement_operator in requirement_operators:
+        # Create tuples
+        requirement_type_operator_tuples = [
+            OperatorTypeTuple(requirement_operator, rt) for ro in requirement_types
+        ]
+
+        eval_result = [
+            evaluate_operator_type_tuple(t, **kwargs)
+            for t in requirement_type_operator_tuples
+        ]
+
+        operator_evaluation_results[requirement_operator.name] = eval_result
+
+        # TODO FIX
+        operator_return_values[requirement_operator.name] = (
+            requirement_operator.evaluate_return_values()
+        )
+
+    return operator_evaluation_results, operator_return_values

endoreg_db/models/requirement/requirement_operator.py

@@ -0,0 +1,58 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+
+class RequirementOperatorManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieve a RequirementOperator instance by its natural key.
+        
+        Args:
+            name (str): The unique name representing the natural key.
+        
+        Returns:
+            RequirementOperator: The model instance matching the provided name.
+        """
+        return self.get(name=name)
+
+
+class RequirementOperator(models.Model):
+    """
+    A class representing a requirement operator.
+
+    Attributes:
+        name (str): The name of the requirement operator.
+        name_de (str): The German name of the requirement operator.
+        name_en (str): The English name of the requirement operator.
+        description (str): A description of the requirement operator.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = RequirementOperatorManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.requirement.requirement import Requirement
+
+        requirements: models.QuerySet[Requirement]
+
+    def natural_key(self):
+        """
+        Return the natural key for the requirement operator.
+        
+        This method returns a tuple containing the operator's name, which serves as its
+        natural key for serialization and unique identification within the system.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return the string representation of the requirement operator.
+        
+        Returns:
+            str: The name attribute of the operator.
+        """
+        return str(self.name)

endoreg_db/models/requirement/requirement_set.py

@@ -0,0 +1,127 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+
+class RequirementSetTypeManager(models.Manager):
+    """
+    Manager for RequirementSetType with custom query methods.
+    """
+
+    def get_by_natural_key(self, name: str) -> "RequirementSetType":
+        """
+        Retrieves a RequirementSetType instance using its natural key.
+        
+        Args:
+            name (str): The unique name that serves as the natural key.
+        
+        Returns:
+            RequirementSetType: The matching RequirementSetType instance.
+        """
+        return self.get(name=name)
+
+
+class RequirementSetType(models.Model):
+    """
+    A class representing a type of requirement set.
+
+    Attributes:
+        name (str): The name of the requirement set type.
+        name_de (str): The German name of the requirement set type.
+        name_en (str): The English name of the requirement set type.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = RequirementSetTypeManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.requirement import RequirementType
+
+        requirement_types: models.QuerySet[RequirementType]
+
+    def natural_key(self):
+        """
+        Return the natural key tuple for the instance.
+        
+        Returns:
+            tuple: A one-element tuple containing the instance's name, used as its natural key.
+        """
+        return (self.name,)
+
+
+class RequirementSetManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieves a model instance by its natural key.
+        
+        Args:
+            name: The natural key value, typically corresponding to the model's unique name.
+        
+        Returns:
+            The model instance whose name matches the provided natural key.
+        """
+        return self.get(name=name)
+
+
+class RequirementSet(models.Model):
+    """
+    A class representing a set of requirements.
+
+    Attributes:
+        name (str): The name of the requirement set.
+        name_de (str): The German name of the requirement set.
+        name_en (str): The English name of the requirement set.
+        description (str): A description of the requirement set.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+    requirements = models.ManyToManyField(
+        "Requirement",
+        blank=True,
+        related_name="requirement_sets",
+    )
+    links_to_sets = models.ManyToManyField(
+        "RequirementSet",
+        blank=True,
+        related_name="links_from_sets",
+    )
+    requirement_set_type = models.ForeignKey(
+        "RequirementSetType",
+        on_delete=models.CASCADE,
+        related_name="requirement_sets",
+        blank=True,
+        null=True,
+    )
+    information_sources = models.ManyToManyField(
+        "InformationSource",
+        related_name="requirement_sets",
+        blank=True,
+    )
+    objects = RequirementSetManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models import Requirement, InformationSource
+
+        requirements: models.QuerySet[Requirement]
+        information_source: InformationSource
+        requirement_set_type: RequirementSetType
+        linked_sets: models.QuerySet["RequirementSet"]
+
+    def natural_key(self):
+        """Return the natural key as a tuple containing the instance's name."""
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return the string representation of the requirement set.
+        
+        Returns:
+            str: The name of the requirement set.
+        """
+        return str(self.name)

endoreg_db/models/risk/__init__.py

@@ -0,0 +1,7 @@
+from .risk import Risk
+from .risk_type import RiskType
+
+__all__ = [
+    "Risk",
+    "RiskType",
+]

endoreg_db/models/risk/risk.py

@@ -0,0 +1,72 @@
+from django.db import models
+from typing import List, TYPE_CHECKING
+
+
+class RiskManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieve a risk instance using its natural key.
+        
+        Args:
+            name: The unique name identifying the risk instance.
+        
+        Returns:
+            The risk instance with the matching name.
+        """
+        return self.get(name=name)
+
+
+class Risk(models.Model):
+    """
+    A class representing a risk.
+
+    Attributes:
+        name (str): The name of the risk.
+        name_de (str): The German name of the risk.
+        name_en (str): The English name of the risk.
+        description (str): A description of the risk.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    risk_value = models.FloatField(
+        blank=True,
+        null=True,
+        help_text="Risk value for the risk. If not set, the risk is not used in calculations.",
+    )
+
+    risk_type = models.ForeignKey(
+        "RiskType",
+        on_delete=models.CASCADE,
+        related_name="risks",
+        blank=True,
+        null=True,
+    )
+
+    objects = RiskManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.risk.risk_type import RiskType
+
+        risk_types: RiskType
+
+    def natural_key(self):
+        """
+        Return a tuple containing the natural key of the risk instance.
+        
+        The tuple consists of the unique 'name' attribute, which enables natural key lookups
+        and serialization within Django.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return the string representation of the risk.
+        
+        Returns:
+            str: The risk's name.
+        """
+        return str(self.name)

endoreg_db/models/risk/risk_type.py

@@ -0,0 +1,55 @@
+from django.db import models
+from typing import TYPE_CHECKING
+
+
+class RiskTypeManager(models.Manager):
+    def get_by_natural_key(self, name):
+        """
+        Retrieves a RiskType instance using its natural key.
+        
+        Args:
+            name (str): The unique name identifying the RiskType instance.
+        
+        Returns:
+            RiskType: The matching instance with the provided name.
+        """
+        return self.get(name=name)
+
+
+class RiskType(models.Model):
+    """
+    A class representing a risk type.
+
+    Attributes:
+        name (str): The name of the risk type.
+        name_de (str): The German name of the risk type.
+        name_en (str): The English name of the risk type.
+        description (str): A description of the risk type.
+    """
+
+    name = models.CharField(max_length=100, unique=True)
+    name_de = models.CharField(max_length=100, blank=True, null=True)
+    name_en = models.CharField(max_length=100, blank=True, null=True)
+    description = models.TextField(blank=True, null=True)
+
+    objects = RiskTypeManager()
+
+    if TYPE_CHECKING:
+        from endoreg_db.models.risk.risk import Risk
+
+        risks: models.QuerySet[Risk]
+
+    def natural_key(self):
+        """
+        Return the natural key for this risk type.
+        
+        This method returns a tuple containing only the risk type's unique name, which is used
+        to identify the instance naturally.
+        """
+        return (self.name,)
+
+    def __str__(self):
+        """
+        Return the risk type's name as its string representation.
+        """
+        return str(self.name)

endoreg_db/serializers/video_segmentation.py

@@ -112,14 +112,12 @@ class VideoFileSerializer(serializers.ModelSerializer):
             obj.file.name
         ).strip()  #  Only return the file path, no URL,#obj.file returning a FieldFile object instead of a string
 
-    """The error "muxer does not support non-seekable output" 
-    happens because MP4 format requires seeking, but FFmpeg does not support writing MP4 directly to a non-seekable stream (like STDOUT)."""
-
     def get_full_video_path(self, obj):
         """
         Constructs the absolute file path dynamically.
         - Uses the actual storage directory (`/home/admin/test-data/`)
         """
+        from ..utils import STORAGE_DIR
         if not obj.file:
             return {"error": "No video file associated with this entry"}
 
@@ -129,16 +127,7 @@ class VideoFileSerializer(serializers.ModelSerializer):
                 "error": "Video file path is empty or invalid"
             }  #  none might cause, 500 error, Handle edge case where the file name is empty
 
-        print("-----------------------------------------")
-        # pseudo_dir = settings.PSEUDO_DIR
-        # print(f"Using pseudo directory: {pseudo_dir}")
-
-        #   full path using the actual storage directory~
-        # actual_storage_dir = Path("~/test-data")  # need to change
-        actual_storage_dir = Path("/home/admin/test-data")  # need to change
-        # actual_storage_dir = pseudo_dir
-        full_path = actual_storage_dir / video_relative_path
-        # full_path = Path("/home/admin/test-data/video/lux-gastro-video.mp4")
+        full_path = STORAGE_DIR / video_relative_path
 
         return (
             str(full_path)
@@ -354,14 +343,16 @@ class LabelSegmentUpdateSerializer(serializers.Serializer):
 
     def save(self):
         """
-        Updates, inserts, and deletes label segments to ensure database consistency.
-
-        Steps:
-        1. Fetch all existing segments for the given `video_id` and `label_id`.
-        2. Compare existing segments with the new ones from the frontend.
-        3. Update segments where `start_frame_number` exists but `end_frame_number` has changed.
-        4. Insert new segments that are not already in the database.
-        5. Delete segments that exist in the database but are missing from the frontend data.
+        Synchronizes label segments with updated frontend data.
+        
+        This method compares the incoming segments with the current database entries for a given video and label.
+        It updates segments with modified end frame numbers, inserts new segments, and deletes existing segments
+        that are not present in the provided data. All operations are performed within a transaction to ensure
+        database consistency. A validation error is raised if no prediction metadata is found for the video.
+        
+        Returns:
+            dict: A dictionary containing serialized updated segments, serialized new segments, and the count
+                  of deleted segments.
         """
 
         video_id = self.validated_data["video_id"]
@@ -391,10 +382,6 @@ class LabelSegmentUpdateSerializer(serializers.Serializer):
             (float(seg.start_frame_number), float(seg.end_frame_number)): seg
             for seg in existing_segments
         }
-        existing_segments_dict = {
-            (float(seg.start_frame_number), float(seg.end_frame_number)): seg
-            for seg in existing_segments
-        }
 
         # Prepare lists for batch processing
         updated_segments = []  # Stores segments that need to be updated

endoreg_db/urls.py

@@ -7,7 +7,13 @@ from .views.patient_views import (
     get_morphology_choices, 
 )
 from .views.csrf import csrf_token_view
-#from .views.feature_selection_view import FetchSingleFramePredictionView // its implemented in ando-ai other project need to add here
+# endoreg_db_production/endoreg_db/urls.py
+from endoreg_db.views.views import (
+    VideoView,
+    keycloak_login,
+    keycloak_callback,
+    public_home,
+)#from .views.feature_selection_view import FetchSingleFramePredictionView // its implemented in ando-ai other project need to add here
 from .views.video_segmentation_views import VideoView, VideoLabelView,UpdateLabelSegmentsView
 from .views.views_for_timeline import video_timeline_view
 from .views.raw_video_meta_validation_views import VideoFileForMetaView, VideoFileForMetaView
@@ -34,7 +40,7 @@ urlpatterns = [
         # will be displayed on the frontend using route(api/video/<int:video_id>/).
         # once label is selected from the dropdown,using its name, details can be fetched from rawvideofile using route("api/video/<int:video_id>/label/<str:label_name>/) 
         #If editing is required, a form will be available for each label. This form dynamically updates when the selected label changes. It will display all segments associated with the selected label, each with a delete option. Below these segments, there may be a button for adding more segments.
-        #If any values in the form are modified, the updated data will be saved in the database table.
+        #If any values in the form are modified, the updated data will be saved in the dafrom .views import VideoView, keycloak_login, keycloak_callbacktabase table.
     
     
     
@@ -45,7 +51,15 @@ urlpatterns = [
     # Example request: GET /api/videos/
     # Response: Returns a JSON list of videos (id, file path, video_url, sequences, label_names).
     # it also fetch the label from teh label table
-    path("api/videos/", VideoView.as_view(), name="video_list"),
+
+    # for kaycloak:-
+    # /api/videos/ , protected API
+    # /login/ , sends user to Keycloak login page
+    # /login/callback/ , where Keycloak sends the user after login
+    path('', public_home, name='public_home'),
+    path('api/videos/', VideoView.as_view(), name='video_list'),
+    path('login/', keycloak_login, name='keycloak_login'),
+    path('login/callback/', keycloak_callback, name='keycloak_callback'),
     
     #need to change this route
     #path('api/prediction/', FetchSingleFramePredictionView.as_view(), name='fetch-single-frame-prediction'),#.as_view() converts the class-based view into a function that Django can use for routing.

endoreg_db/utils/__init__.py

@@ -11,6 +11,7 @@ from .hashs import (
     get_examiner_hash,
     get_video_hash,
     get_patient_examination_hash,
+    DJANGO_NAME_SALT
 )
 from .names import (
     create_mock_patient_name,
@@ -18,6 +19,28 @@ from .names import (
     guess_name_gender,
 )
 
+from .paths import (
+    STORAGE_DIR,
+    FRAME_DIR,
+    VIDEO_DIR,
+    RAW_VIDEO_DIR,
+    RAW_FRAME_DIR,
+    TEST_RUN,
+    TEST_RUN_FRAME_NUMBER,
+    FRAME_PROCESSING_BATCH_SIZE,
+    WEIGHTS_DIR,
+    WEIGHTS_DIR_NAME,
+    FRAME_DIR_NAME,
+    VIDEO_DIR_NAME,
+    STORAGE_DIR_NAME,
+    RAW_FRAME_DIR_NAME,
+    RAW_VIDEO_DIR_NAME,
+    PDF_DIR_NAME,
+    PDF_DIR,
+    RAW_PDF_DIR,
+    RAW_PDF_DIR_NAME,
+)
+
 __all__ = [
     "load_model_data_from_yaml",
     "collect_center_names",
@@ -33,4 +56,24 @@ __all__ = [
     "get_pdf_hash",
     "get_video_hash",
     "get_patient_examination_hash",
+    "STORAGE_DIR",
+    "FRAME_DIR",
+    "VIDEO_DIR",
+    "RAW_VIDEO_DIR",
+    "RAW_FRAME_DIR",
+    "TEST_RUN",
+    "TEST_RUN_FRAME_NUMBER",
+    "FRAME_PROCESSING_BATCH_SIZE",
+    "DJANGO_NAME_SALT",
+    "WEIGHTS_DIR",
+    "WEIGHTS_DIR_NAME",
+    "FRAME_DIR_NAME",
+    "VIDEO_DIR_NAME",
+    "STORAGE_DIR_NAME",
+    "RAW_FRAME_DIR_NAME",
+    "RAW_VIDEO_DIR_NAME",
+    "RAW_PDF_DIR_NAME",
+    "PDF_DIR_NAME",
+    "PDF_DIR",
+    "RAW_PDF_DIR",
 ]

endoreg_db/utils/dataloader.py

@@ -38,15 +38,22 @@ def load_data_with_foreign_keys(
     command, model, yaml_data, foreign_keys, foreign_key_models, verbose
 ):
     """
-    Load data handling foreign keys and many-to-many relationships.
-
-    Args:
-        command: Command object for stdout writing.
-        model: The Django model for the data.
-        yaml_data: Data loaded from YAML.
-        foreign_keys: List of foreign keys.
-        foreign_key_models: Corresponding models for the foreign keys.
-        verbose: Boolean indicating whether to print verbose output.
+    Load YAML data into Django model instances with FK and M2M support.
+    
+    Processes each YAML entry to create or update a model instance. For each entry, the
+    function extracts field data and uses the presence of a 'name' field to decide whether
+    to update an existing instance or create a new one. Foreign key fields listed in
+    foreign_keys are handled by retrieving related objects via natural keys. When a field
+    contains a list, it is treated as a many-to-many relationship and the corresponding
+    objects are set after the instance is saved. Missing or unresolved foreign keys trigger
+    warnings if verbose output is enabled.
+    
+    Parameters:
+        model: The Django model class representing the data.
+        yaml_data: A list of dictionaries representing YAML entries.
+        foreign_keys: A list of foreign key field names to process from each entry.
+        foreign_key_models: The corresponding Django model classes for each foreign key.
+        verbose: If True, prints detailed output and warnings during processing.
     """
     for entry in yaml_data:
         fields = entry.get("fields", {})
@@ -56,7 +63,10 @@ def load_data_with_foreign_keys(
 
         # Handle foreign keys and many-to-many relationships
         for fk_field, fk_model in zip(foreign_keys, foreign_key_models):
-            # print(fk_field, fk_model)
+            # Skip fields that are not in the data
+            if fk_field not in fields:
+                continue
+
             target_keys = fields.pop(fk_field, None)
 
             # Ensure the foreign key exists
@@ -73,18 +83,20 @@ def load_data_with_foreign_keys(
             if isinstance(target_keys, list):  # Assume many-to-many relationship
                 related_objects = []
                 for key in target_keys:
-                    obj, created = fk_model.objects.get_or_create(name=key)
-                    if created and verbose:
-                        command.stdout.write(
-                            command.style.SUCCESS(f"Created {fk_model.__name__} {key}")
-                        )
+                    try:
+                        obj = fk_model.objects.get_by_natural_key(key)
+                    except ObjectDoesNotExist:
+                        if verbose:
+                            command.stdout.write(
+                                command.style.WARNING(
+                                    f"{fk_model.__name__} with key {key} not found"
+                                )
+                            )
+                        continue
                     related_objects.append(obj)
                 m2m_relationships[fk_field] = related_objects
             else:  # Single foreign key relationship
                 try:
-                    if model == "endoreg_db.case_template_rule":
-                        # print(fk_model, target_keys)
-                        pass
                     obj = fk_model.objects.get_by_natural_key(target_keys)
                 except ObjectDoesNotExist:
                     if verbose:
@@ -115,4 +127,11 @@ def load_data_with_foreign_keys(
 
         # Set many-to-many relationships
         for field_name, related_objs in m2m_relationships.items():
-            getattr(obj, field_name).set(related_objs)
+            if related_objs:  # Only set if there are objects to set
+                getattr(obj, field_name).set(related_objs)
+                if verbose:
+                    command.stdout.write(
+                        command.style.SUCCESS(
+                            f"Set {len(related_objs)} {field_name} for {model.__name__} {name}"
+                        )
+                    )