endoreg-db 0.8.4.4__py3-none-any.whl → 0.8.8.0__py3-none-any.whl

endoreg_db/models/administration/permissions/__init__.py

@@ -1,44 +0,0 @@
-# from django.contrib.contenttypes.models import ContentType
-# from django.contrib.auth.models import Permission
-# from endoreg_db.models import *  # Import your models here
-# from django.db import transaction
-
-# # Step 1: Define model to category mappings
-# # Assuming every model class name is unique across your entire Django project
-# model_categories = {
-#     'SensitiveModel1': 'sensitive',
-#     'SensitiveModel2': 'sensitive',
-#     'DevelopmentModel1': 'development',
-#     'DevelopmentModel2': 'development',
-#     # Add all models you have, mapping them to either 'sensitive', 'development', or 'all'
-# }
-
-# # Step 2: Define permissions for each category
-# category_permissions = {
-#     'sensitive': ['view', 'edit', 'delete'],
-#     'development': ['view', 'edit'],
-#     'all': ['view'],
-# }
-
-# @transaction.atomic
-# def create_permissions_for_all_models():
-#     for model_class_name, category in model_categories.items():
-#         model_class = globals().get(model_class_name)
-#         if model_class is None:
-#             print(f"Model {model_class_name} not found.")
-#             continue
-        
-#         content_type = ContentType.objects.get_for_model(model_class)
-#         permissions = category_permissions.get(category, [])
-
-#         for permission_codename in permissions:
-#             permission_name = f"Can {permission_codename} {model_class_name}"
-#             permission, created = Permission.objects.get_or_create(
-#                 codename=f"{permission_codename}_{model_class_name.lower()}",
-#                 defaults={'name': permission_name, 'content_type': content_type},
-#             )
-#             if created:
-#                 print(f"Created permission: {permission_name}")
-
-# # Run the function to create and assign permissions based on categories
-# create_permissions_for_all_models()

endoreg_db/models/rule/__init__.py

@@ -1,13 +0,0 @@
-from .rule_type import RuleType
-from .rule import Rule
-from .ruleset import Ruleset
-from .rule_attribute_dtype import RuleAttributeDType
-from .rule_applicator import RuleApplicator
-
-__all__ = [
-    "RuleType",
-    "Rule",
-    "Ruleset",
-    "RuleAttributeDType",
-    "RuleApplicator",
-]

endoreg_db/models/rule/rule.py

@@ -1,27 +0,0 @@
-from django.db import models
-
-class RuleManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class Rule(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    description = models.TextField(blank=True, null=True)
-    attribute_key = models.CharField(max_length=255)
-    rule_type = models.ForeignKey("RuleType", on_delete=models.CASCADE)
-    attribute_dtype = models.ForeignKey("RuleAttributeDType", on_delete=models.CASCADE)
-
-    objects = RuleManager()
-
-    class Meta:
-        verbose_name = 'Rule'
-        verbose_name_plural = 'Rules'
-
-    def natural_key(self):
-        """
-        Return a tuple representing the natural key for this Rule instance.
-        
-        Returns:
-            tuple: A one-element tuple containing the Rule's unique name.
-        """
-        return (self.name,)

endoreg_db/models/rule/rule_applicator.py

@@ -1,224 +0,0 @@
-from .rule import Rule
-import random
-from django.core.exceptions import ValidationError
-
-class RuleApplicator:
-    """
-    A class to apply different types of rules to a Django model instance based on the Rule configuration.
-    """
-
-    def get_rule_by_name(self, rule_name):
-        """
-        A helper method to fetch a rule by name. This can be further customized.
-        """
-        # get rule by name which is natural key
-        rule = Rule.objects.get_by_natural_key(rule_name)
-        return rule
-
-
-    def apply(self, obj, rule):
-        """
-        Applies a specified rule to an object based on the rule type and attributes.
-
-        Parameters:
-        obj (Django model instance): The object to which the rule is applied.
-        rule (Rule): The rule instance containing the rule_type and attribute details.
-        """
-        rule_type_method = self.get_rule_type_method(rule.rule_type.name)
-        if rule_type_method:
-            rule_type_method(obj, rule)
-
-        else:
-            raise ValueError(f"Unsupported rule type: {rule.rule_type.name}")
-        
-    def apply_rule_by_name(self, obj, rule_name):
-        """
-        A helper method to apply a rule and get a value. This can be further customized.
-        """
-        rule = self.get_rule_by_name(rule_name)
-        self.apply(obj, rule)
-
-    def apply_rules_by_name(self, obj, rule_names):
-        """
-        A helper method to apply multiple rules and get values. This can be further customized.
-        """
-        rules = [self.get_rule_by_name(rule_name) for rule_name in rule_names]
-        for rule in rules:
-            self.apply(obj, rule)
-            
-
-    def get_rule_type_method(self, rule_type_name):
-        """
-        Maps rule type name to the corresponding method.
-        """
-        return getattr(self, f"handle_{rule_type_name}", None)
-
-    def parse_attribute_path(self, obj, attribute_key):
-        """
-        Parses the attribute path and applies the value to the correct attribute of a nested object.
-        """
-        parts = attribute_key.split('.')
-        model_name = parts[0]
-        if model_name.lower() != obj.__class__.__name__.lower():
-            raise ValidationError(f"Model type mismatch: expected {model_name}, got {obj.__class__.__name__}")
-
-        # Navigate through the nested attributes
-        target = obj
-        for part in parts[1:-1]:
-            target = getattr(target, part)
-
-        return target, parts[-1]
-
-    def set_attribute_value(self, obj, rule):
-        """
-        Generic method to set attribute value considering nested paths.
-        """
-        target, attribute = self.parse_attribute_path(obj, rule.attribute_key)
-        setattr(target, attribute, rule.attribute_dict['value'])
-        target.save()
-
-    #####
-
-    def handle_case_attribute_set_value(self, obj, rule):
-        """
-        Sets a specific attribute to a given value.
-        """
-        self.set_attribute_value(obj, rule.attribute_key, rule.attribute_dict["value"])
-
-    def handle_case_attribute_set_value_range_uniform(self, obj, rule):
-        """
-        Sets an attribute to a value within a specified range, selected uniformly.
-        """
-        if not hasattr(rule, 'attribute_dtype') or rule.attribute_dtype.name not in ['numeric', 'ordered_categorical']:
-            raise ValidationError("Attribute dtype must be numeric or ordered_categorical")
-        min_val = rule.attribute_dict["value_min"]
-        max_val = rule.attribute_dict["value_max"]
-        value = random.uniform(min_val, max_val)
-        self.set_attribute_value(obj, rule.attribute_key, value)
-
-    def handle_case_attribute_set_value_range_norm_dist(self, obj, rule):
-        """
-        Sets an attribute to a value within a specified range, based on a normal distribution.
-        """
-        if rule.attribute_dtype.name in ['float', "integer"]:
-            raise ValidationError("Attribute dtype must be float or integer")
-        mean = rule.attribute_dict["value_mean"]
-        std_dev = rule.attribute_dict["value_sd"]
-        value = random.normalvariate(mean, std_dev)
-        self.set_attribute_value(obj, rule.attribute_key, value)
-        
-
-    def handle_case_attribute_set_from_list_uniform(self, obj, rule):
-        """
-        Selects an attribute value uniformly from a list of choices.
-        """
-        choices = rule.attribute_dict["value_choices"]
-        value = random.choice(choices)
-        self.set_attribute_value(obj, rule.attribute_key, value)
-
-    def handle_case_attribute_set_from_prop_tuple_list(self, obj, rule):
-        """
-        Selects an attribute value based on a list of value-probability tuples.
-        """
-        prop_list = rule.attribute_dict["value_prop_tuple_list"]
-        total = sum(prop for _, prop in prop_list)
-        pick = random.uniform(0, total)
-        current = 0
-        for value, prop in prop_list:
-            current += prop
-            if current > pick:
-                self.set_attribute_value(obj, rule.attribute_key, value)
-                break
-
-
-    #####
-
-    def handle_case_add_patient(self, obj, rule):
-        """Function to add a patient to a case. If the patient already exists, raise an error. Requires the following
-        rules in the rule_dict:
-        - gender_rule
-        - dob_rule
-        - event_rules
-        - disease_rules
-        """
-        from endoreg_db.models import Patient, PatientEvent, PatientDisease, Case
-
-        # Check if the 
-        obj:Case = obj
-        if obj.patient:
-            raise ValueError("Patient already exists in the case")
-        
-        patient = Patient()
-        self.apply_rule_by_name(patient, rule.attribute_dict["patient_gender_rule"])
-        self.apply_rule_by_name(patient, rule.attribute_dict["patient_dob_rule"])
-        self.apply_rules_by_name(patient, rule.attribute_dict["patient_event_rules"])
-        self.apply_rules_by_name(patient, rule.attribute_dict["patient_disease_rules"])
-
-    def handle_case_add_polyp(self, obj, rule):
-        """
-        Adds a polyp to the case, processing various polyp characteristics. Requires Rules for each attribute:
-        - polyp_location_organ_rule (single rule)
-        - polyp_location_organ_part_rule (single rule)
-        - polyp_morphology_classification_shape_choices_rule (list of rules)
-        - polyp_morphology_classification_chromo_choices_rule (list of rules)
-        - polyp_intervention_type_rule (single rule)
-        - polyp_intervention_instrument_rule (single rule)
-        - polyp_size_mm_rule (single rule)
-
-        """
-        # Example: create and add a polyp instance based on the rules
-        from endoreg_db.models import Polyp  # Ensure you have a Polyp model and adjust the import
-        from endoreg_db.models import Location
-        from endoreg_db.models import EndoscopicIntervention
-        from endoreg_db.models import PolypMorphology
-
-        assert obj.examination.type != None, "Examination type is required"
-
-        location = Location()
-        location.organ = self.apply_rule_by_name(location, rule.attribute_dict["polyp_location_organ_rule"])
-        location.organ_part = self.apply_rule_by_name(location, rule.attribute_dict["polyp_location_organ_part_rule"])
-        location.save()
-
-        morphology = PolypMorphology()
-        # M2M to ClassificationChoice (linked to Classification which has name as natural key)
-        morphology.shape_classification_choices = self.apply_rules_by_name(morphology, rule.attribute_dict["polyp_morphology_classification_shape_choices_rules"])
-        # M2M to ClassificationChoice (linked to Classification which has name as natural key)
-        morphology.chromo_classification_choices = self.apply_rules_by_name(morphology, rule.attribute_dict["polyp_morphology_classification_chromo_choices_rules"])
-        morphology.save()
-
-        intervention = EndoscopicIntervention()
-        intervention.type = self.apply_rule_by_name(intervention, rule.attribute_dict["polyp_intervention_type_rule"])
-        intervention.instrument = self.apply_rule_by_name(intervention, rule.attribute_dict["polyp_intervention_instrument_rule"])
-        intervention.save()
-
-        polyp = Polyp()
-        polyp.size_mm = self.apply_rule_by_name(polyp, rule.attribute_dict["polyp_size_mm_rule"])
-        polyp.location = location
-        polyp.morphology = morphology
-        polyp.intervention = intervention
-        
-        polyp.save()
-
-        obj.polyps.add(polyp)
-        obj.save()
-
-
-    # def handle_case_add_esophageal_varices(self, obj, rule):
-    #     """
-    #     Handles adding esophageal varices to a case based on the rule.
-    #     """
-    #     # Similar to the polyp case, create and add esophageal varices based on the attributes
-    #     from endoreg_db.models import EsophagealVarices  # Ensure this model exists
-    #     varices = EsophagealVarices()
-    #     varices.origin = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_origin_rule"])
-    #     varices.classification = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_classification_rule"])
-    #     varices.location_extent = self.apply_rule_by_name(obj, rule.attribute_dict["esophageal_varices_location_extent_rule"])
-    #     varices.save()
-    #     # Assuming a relationship setup
-    #     obj.esophageal_varices.add(varices)
-    #     obj.save()
-
-
-    
-    
-        

endoreg_db/models/rule/rule_attribute_dtype.py

@@ -1,17 +0,0 @@
-from django.db import models
-
-
-class RuleAttributeDtypeManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class RuleAttributeDType(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-
-    objects = RuleAttributeDtypeManager()
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name

endoreg_db/models/rule/rule_type.py

@@ -1,20 +0,0 @@
-from django.db import models
-
-class RuleTypeManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class RuleType(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-
-    objects = RuleTypeManager()
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name
-
-    class Meta:
-        verbose_name = 'Rule Type'
-        verbose_name_plural = 'Rule Types'

endoreg_db/models/rule/ruleset.py

@@ -1,17 +0,0 @@
-from django.db import models
-
-class RulesetManager(models.Manager):
-    def get_by_natural_key(self, name):
-        return self.get(name=name)
-
-class Ruleset(models.Model):
-    name = models.CharField(max_length=255, unique=True)
-    rules = models.ManyToManyField('Rule')
-
-    objects = RulesetManager()
-
-    def natural_key(self):
-        return (self.name,)
-
-    def __str__(self):
-        return self.name

endoreg_db/serializers/video/video_metadata.py

@@ -1,105 +0,0 @@
-"""
-Video Metadata Serializer
-
-Serializes VideoMetadata model for API responses.
-Created as part of Phase 1.1: Video Correction API Endpoints.
-"""
-from rest_framework import serializers
-from endoreg_db.models.media.video import VideoMetadata
-import json
-
-
-class VideoMetadataSerializer(serializers.ModelSerializer):
-    """
-    Serializer for VideoMetadata model.
-    
-    Provides analysis results (sensitive frame count, ratio, frame IDs)
-    for the correction UI.
-    """
-    sensitive_frame_ids_list = serializers.SerializerMethodField()
-    sensitive_percentage = serializers.ReadOnlyField()
-    has_analysis = serializers.ReadOnlyField()
-    
-    class Meta:
-        model = VideoMetadata
-        fields = [
-            'id',
-            'video',
-            'sensitive_frame_count',
-            'sensitive_ratio',
-            'sensitive_frame_ids',
-            'sensitive_frame_ids_list',
-            'sensitive_percentage',
-            'has_analysis',
-            'analyzed_at',
-        ]
-        read_only_fields = ['id', 'analyzed_at']
-    
-    def get_sensitive_frame_ids_list(self, obj) -> list:
-        """
-        Parse sensitive_frame_ids from JSON string to Python list.
-        
-        Returns:
-            list: Frame indices (0-based), or empty list if no analysis
-        """
-        if not obj.sensitive_frame_ids:
-            return []
-        
-        try:
-            return json.loads(obj.sensitive_frame_ids)
-        except (json.JSONDecodeError, TypeError):
-            return []
-    
-    def validate_sensitive_frame_ids(self, value):
-        """
-        Validate that sensitive_frame_ids is a valid JSON array.
-        
-        Args:
-            value: JSON string representing frame IDs
-            
-        Returns:
-            str: Validated JSON string
-            
-        Raises:
-            ValidationError: If value is not valid JSON or not an array
-        """
-        if not value:
-            return value
-        
-        try:
-            parsed = json.loads(value)
-            if not isinstance(parsed, list):
-                raise serializers.ValidationError(
-                    "sensitive_frame_ids must be a JSON array"
-                )
-            
-            # Validate all elements are integers
-            if not all(isinstance(x, int) for x in parsed):
-                raise serializers.ValidationError(
-                    "All frame IDs must be integers"
-                )
-            
-            return value
-        except json.JSONDecodeError:
-            raise serializers.ValidationError(
-                "sensitive_frame_ids must be valid JSON"
-            )
-    
-    def validate_sensitive_ratio(self, value):
-        """
-        Validate that sensitive_ratio is between 0.0 and 1.0.
-        
-        Args:
-            value: Ratio value
-            
-        Returns:
-            float: Validated ratio
-            
-        Raises:
-            ValidationError: If value is outside valid range
-        """
-        if value is not None and (value < 0.0 or value > 1.0):
-            raise serializers.ValidationError(
-                "sensitive_ratio must be between 0.0 and 1.0"
-            )
-        return value

endoreg_db/urls/report.py

@@ -1,48 +0,0 @@
-from django.urls import path
-from endoreg_db.views import (
-    ReportListView,
-    ReportWithSecureUrlView,
-    ReportFileMetadataView,
-)
-
-url_patterns = [        # ---------------------------------------------------------------------------------------
-        # REPORT SERVICE ENDPOINTS
-        #
-        # Neue API-Endpunkte für den Report-Service mit sicheren URLs
-        #
-        # Diese Endpunkte ermöglichen es dem Frontend (UniversalReportViewer), 
-        # Reports mit zeitlich begrenzten, sicheren URLs zu laden und anzuzeigen.
-        #
-        # Verwendung im Frontend:
-        #   - loadReportWithSecureUrl(reportId) 
-        #   - generateSecureUrl(reportId, fileType)
-        #   - validateCurrentUrl()
-        #
-        # ---------------------------------------------------------------------------------------
-
-        # API-Endpunkt für paginierte Report-Listen mit Filterung
-        # GET /api/reports/?page=1&page_size=20&status=pending&file_type=pdf&patient_name=John
-        # Lädt eine paginierte Liste aller Reports mit optionalen Filtern
-        path('reports/', 
-            ReportListView.as_view(), 
-            name='report_list'
-        ),
-
-        # API-Endpunkt für Reports mit automatischer sicherer URL-Generierung
-        # GET /api/reports/{report_id}/with-secure-url/
-        # Lädt Report-Daten inklusive Metadaten und generiert automatisch eine sichere URL
-        path(
-            'reports/<int:report_id>/with-secure-url/', 
-            ReportWithSecureUrlView.as_view(), 
-            name='report_with_secure_url'
-        ),
-
-        # API-Endpunkt für Report-Datei-Metadaten
-        # GET /api/reports/{report_id}/file-metadata/
-        # Gibt Datei-Metadaten zurück (Größe, Typ, Datum, etc.)
-        path(
-            'reports/<int:report_id>/file-metadata/', 
-            ReportFileMetadataView.as_view(), 
-            name='report_file_metadata'
-        ),
-]

endoreg_db/urls/video.py

@@ -1,61 +0,0 @@
-from django.urls import path
-
-from endoreg_db.views import (
-    SensitiveMetaDetailView,
-    VideoLabelView,
-    # Note: VideoStreamView moved to modern media framework. See: endoreg_db/urls/media.py
-    # Note: All Video Correction Views moved to modern media framework. See: endoreg_db/urls/media.py
-)
-
-url_patterns = [
-    # Video Label segments API endpoint
-    # GET /api/videos/<int:video_id>/labels/<str:label_name>/
-    # Retrieves time segments and frame predictions for a specific label on a video
-    path(
-        'videos/<int:video_id>/labels/<str:label_name>/', 
-        VideoLabelView.as_view(), 
-        name='video_label_segments'
-    ),
-    
-    # ---------------------------------------------------------------------------------------
-    # VIDEO STREAMING - MOVED TO MODERN MEDIA FRAMEWORK
-    #
-    # Video streaming endpoint has been migrated to the media framework
-    # as of October 14, 2025. Please use the new endpoints:
-    #
-    # OLD → NEW:
-    # GET /api/videostream/<pk>/              → GET /api/media/videos/<pk>/
-    # GET /api/videostream/<pk>/              → GET /api/media/videos/<pk>/stream/
-    #
-    # See: endoreg_db/urls/media.py for new URL registrations
-    # ---------------------------------------------------------------------------------------
-    
-    # Note: Video Re-import moved to modern media framework
-    # See: endoreg_db/urls/media.py - POST /api/media/videos/<int:pk>/reimport/
-    
-    # Video Sensitive Meta endpoints (for video anonymization)
-    # GET /api/video/sensitivemeta/<int:sensitive_meta_id>/
-    # PATCH /api/video/sensitivemeta/<int:sensitive_meta_id>/
-    path(
-        'video/sensitivemeta/<int:sensitive_meta_id>/', 
-        SensitiveMetaDetailView.as_view(), 
-        name='video_sensitive_meta_detail'
-    ),
-    
-    # ---------------------------------------------------------------------------------------
-    # VIDEO CORRECTION API ENDPOINTS - MOVED TO MODERN MEDIA FRAMEWORK
-    #
-    # All video correction endpoints have been migrated to the modern media framework
-    # as of October 14, 2025. Please use the new endpoints:
-    #
-    # OLD → NEW:
-    # GET  /api/video-metadata/<id>/              → GET  /api/media/videos/<pk>/metadata/
-    # GET  /api/video-processing-history/<id>/    → GET  /api/media/videos/<pk>/processing-history/
-    # POST /api/video-analyze/<id>/               → POST /api/media/videos/<pk>/analyze/
-    # POST /api/video-apply-mask/<id>/            → POST /api/media/videos/<pk>/apply-mask/
-    # POST /api/video-remove-frames/<id>/         → POST /api/media/videos/<pk>/remove-frames/
-    # POST /api/video-reprocess/<id>/             → POST /api/media/videos/<pk>/reprocess/
-    #
-    # See: endoreg_db/urls/media.py for new URL registrations
-    # ---------------------------------------------------------------------------------------
-]