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

endoreg_db/services/pseudonym_service.py

@@ -1,8 +1,9 @@
 """
 Service for generating patient pseudonyms using SensitiveMeta logic.
 """
+
 import logging
-from typing import Tuple, List
+from typing import Tuple
 from django.db import transaction
 
 from endoreg_db.models.administration.person.patient.patient import Patient
@@ -15,28 +16,30 @@ logger = logging.getLogger(__name__)
 def generate_patient_pseudonym(patient: Patient) -> Tuple[str, bool]:
     """
     Generate a pseudonym hash for an existing Patient using SensitiveMeta logic.
-    
+
     Args:
         patient: The Patient instance to generate a pseudonym for
-        
+
     Returns:
         Tuple of (patient_hash, persisted_flag)
-        
+
     Raises:
         ValueError: If required fields are missing for hash calculation
     """
     # Validate required fields for hash calculation
     if not patient.dob:
-        raise ValueError("Patient date of birth (dob) is required for pseudonym generation")
-    
+        raise ValueError(
+            "Patient date of birth (dob) is required for pseudonym generation"
+        )
+
     if not patient.center:
         raise ValueError("Patient center is required for pseudonym generation")
-    
+
     # Use existing patient_hash if it exists and is valid
     if patient.patient_hash and len(patient.patient_hash.strip()) > 0:
         logger.info(f"Patient {patient.id} already has a hash: {patient.patient_hash}")
         return patient.patient_hash, True
-    
+
     # Create a transient SensitiveMeta instance to calculate the hash
     # We don't save this instance, just use it for hash calculation
     sensitive_meta = SensitiveMeta(
@@ -44,22 +47,24 @@ def generate_patient_pseudonym(patient: Patient) -> Tuple[str, bool]:
         patient_last_name=patient.last_name or "",
         patient_dob=patient.dob,
         center=patient.center,
-        patient_gender=patient.gender  # Optional, but include if available
+        patient_gender=patient.gender,  # Optional, but include if available
     )
-    
+
     try:
         # Calculate the hash using the existing logic
-        patient_hash = logic.calculate_patient_hash(sensitive_meta, salt=logic.SECRET_SALT)
-        
+        patient_hash = logic.calculate_patient_hash(
+            sensitive_meta, salt=logic.SECRET_SALT
+        )
+
         # Persist the hash to the Patient model
         with transaction.atomic():
             patient.patient_hash = patient_hash
-            patient.save(update_fields=['patient_hash'])
-        
+            patient.save(update_fields=["patient_hash"])
+
         logger.info(f"Generated and persisted pseudonym for patient {patient.id}")
-        
+
         return patient_hash, True
-        
+
     except Exception as e:
         logger.error(f"Error generating pseudonym for patient {patient.id}: {str(e)}")
         raise ValueError(f"Failed to generate pseudonym: {str(e)}")
@@ -68,22 +73,22 @@ def generate_patient_pseudonym(patient: Patient) -> Tuple[str, bool]:
 def validate_patient_for_pseudonym(patient: Patient) -> list[str]:
     """
     Validate that a patient has all required fields for pseudonym generation.
-    
+
     Args:
         patient: The Patient instance to validate
-        
+
     Returns:
         List of missing required fields (empty if all fields present)
     """
     missing_fields = []
-    
+
     if not patient.dob:
         missing_fields.append("dob")
-    
+
     if not patient.center:
         missing_fields.append("center")
-    
+
     # Note: first_name and last_name can be empty strings according to the logic,
     # so we don't require them to be non-empty
-    
+
     return missing_fields

endoreg_db/services/report_import.py

@@ -1,10 +1,13 @@
 from endoreg_db.import_files.report_import_service import ReportImportService as ris
-from endoreg_db.models import RawPdfFile
-from pathlib import Path
+
 
 class ReportImportService(ris):
-    """
+    __doc__ = (
+        (ris.__doc__ or "")
+        + """
     Wrapper for known import of concurrency safe ReportImportService, 
     here celery will be implemented in the future.
     12.02.2025
     """
+    )
+    pass

endoreg_db/services/segment_sync.py

@@ -15,61 +15,66 @@ from ..models import VideoFile, Label, LabelVideoSegment, InformationSource
 logger = logging.getLogger(__name__)
 
 
-def create_user_segment_from_annotation(annotation: Dict[str, Any], request_user: User) -> Optional[LabelVideoSegment]:
+def create_user_segment_from_annotation(
+    annotation: Dict[str, Any], request_user: User
+) -> Optional[LabelVideoSegment]:
     """
     Create a user-source LabelVideoSegment from a segment annotation.
-    
+
     This function:
     1. Locates the original LabelVideoSegment (if segmentId is present)
-    2. Clones all its DB fields 
+    2. Clones all its DB fields
     3. Overwrites with new data from annotation
     4. Sets information_source = user
     5. Saves via model manager
-    
+
     Args:
         annotation: Annotation data containing segment information
         request_user: The authenticated user making the request
-        
+
     Returns:
         New LabelVideoSegment instance or None if creation failed/skipped
     """
     # Validate this is a segment annotation
-    if annotation.get('type') != 'segment':
+    if annotation.get("type") != "segment":
         logger.debug("Annotation is not a segment type, skipping user segment creation")
         return None
-    
+
     # Get required data from annotation
-    video_id = annotation.get('videoId')
-    start_time = annotation.get('startTime')
-    end_time = annotation.get('endTime')
-    label_text = annotation.get('text', '').strip()
-    metadata = annotation.get('metadata', {})
-    original_segment_id = metadata.get('segmentId')
-    
+    video_id = annotation.get("videoId")
+    start_time = annotation.get("startTime")
+    end_time = annotation.get("endTime")
+    label_text = annotation.get("text", "").strip()
+    metadata = annotation.get("metadata", {})
+    original_segment_id = metadata.get("segmentId")
+
     if not all([video_id, start_time is not None, end_time is not None]):
-        logger.warning("Missing required segment data in annotation, skipping user segment creation")
+        logger.warning(
+            "Missing required segment data in annotation, skipping user segment creation"
+        )
         return None
-    
+
     try:
         # Get the video file
         video_file = VideoFile.objects.get(id=video_id)
-        
+
         # Get video FPS for frame calculation
         fps = video_file.get_fps()
         if not fps or fps <= 0:
-            logger.warning(f"Invalid FPS ({fps}) for video {video_id}, using default 25")
+            logger.warning(
+                f"Invalid FPS ({fps}) for video {video_id}, using default 25"
+            )
             fps = 25.0
-        
+
         # Calculate frame numbers
         start_frame_number = int(start_time * fps)
         end_frame_number = int(end_time * fps)
-        
+
         # Get or create user information source
         user_source, _ = InformationSource.objects.get_or_create(
-            name="user",
-            defaults={'description': 'User-generated annotations'}
+            name="user", defaults={"description": "User-generated annotations"}
         )
-        
+
         # Try to find label by name from annotation text
         label = None
         if label_text:
@@ -77,79 +82,90 @@ def create_user_segment_from_annotation(annotation: Dict[str, Any], request_user
                 label = Label.objects.filter(name__iexact=label_text).first()
                 if not label:
                     # Try to extract label from tags
-                    tags = annotation.get('tags', [])
+                    tags = annotation.get("tags", [])
                     for tag in tags:
                         label = Label.objects.filter(name__iexact=tag).first()
                         if label:
                             break
             except Exception as e:
                 logger.warning(f"Error finding label '{label_text}': {e}")
-        
+
         # Start with default segment data
         segment_data = {
-            'video_file': video_file,
-            'start_frame_number': start_frame_number,
-            'end_frame_number': end_frame_number,
-            'source': user_source,
-            'label': label,
-            'prediction_meta': None,  # User segments don't have prediction meta
+            "video_file": video_file,
+            "start_frame_number": start_frame_number,
+            "end_frame_number": end_frame_number,
+            "source": user_source,
+            "label": label,
+            "prediction_meta": None,  # User segments don't have prediction meta
         }
-        
+
         # If original segment ID is provided, try to clone from original
         if original_segment_id:
             try:
                 original_segment = LabelVideoSegment.objects.get(id=original_segment_id)
-                
+
                 # Check if timing or label actually changed
                 original_start_time = original_segment.start_frame_number / fps
                 original_end_time = original_segment.end_frame_number / fps
-                
+
                 timing_changed = (
-                    abs(original_start_time - start_time) > 0.1 or  # Allow small floating point differences
-                    abs(original_end_time - end_time) > 0.1
+                    abs(original_start_time - start_time)
+                    > 0.1  # Allow small floating point differences
+                    or abs(original_end_time - end_time) > 0.1
                 )
-                
-                label_changed = (
-                    (label and original_segment.label != label) or
-                    (not label and original_segment.label is not None)
+
+                label_changed = (label and original_segment.label != label) or (
+                    not label and original_segment.label is not None
                 )
-                
+
                 # Only create new segment if something actually changed
                 if not timing_changed and not label_changed:
-                    logger.debug(f"No changes detected in segment {original_segment_id}, skipping user segment creation")
+                    logger.debug(
+                        f"No changes detected in segment {original_segment_id}, skipping user segment creation"
+                    )
                     return None
-                
+
                 # Clone relevant fields from original segment
-                segment_data.update({
-                    'prediction_meta': original_segment.prediction_meta,
-                    'label': label or original_segment.label,  # Use new label if provided, otherwise keep original
-                })
-                
-                logger.info(f"Cloning segment {original_segment_id} with user modifications")
-                
+                segment_data.update(
+                    {
+                        "prediction_meta": original_segment.prediction_meta,
+                        "label": label
+                        or original_segment.label,  # Use new label if provided, otherwise keep original
+                    }
+                )
+
+                logger.info(
+                    f"Cloning segment {original_segment_id} with user modifications"
+                )
+
             except LabelVideoSegment.DoesNotExist:
-                logger.warning(f"Original segment {original_segment_id} not found, creating new user segment")
-        
+                logger.warning(
+                    f"Original segment {original_segment_id} not found, creating new user segment"
+                )
+
         # Create the new user segment using the manager
         with transaction.atomic():
             new_segment = LabelVideoSegment.create_from_video(
                 source=video_file,
-                prediction_meta=segment_data.get('prediction_meta'),
-                label=segment_data['label'],
+                prediction_meta=segment_data.get("prediction_meta"),
+                label=segment_data["label"],
                 start_frame_number=start_frame_number,
                 end_frame_number=end_frame_number,
             )
-            
+
             # Set the user information source
             new_segment.source = user_source
             new_segment.save()
-            
-            logger.info(f"Created user segment {new_segment.id} for video {video_id} by user {request_user.username}")
+
+            logger.info(
+                f"Created user segment {new_segment.id} for video {video_id} by user {request_user.username}"
+            )
             return new_segment
-            
+
     except VideoFile.DoesNotExist:
         logger.error(f"Video {video_id} not found, cannot create user segment")
         return None
     except Exception as e:
         logger.error(f"Error creating user segment from annotation: {e}")
-        return None
+        return None

endoreg_db/services/video_import.py

@@ -1,10 +1,9 @@
 from endoreg_db.import_files.video_import_service import VideoImportService as vis
-from endoreg_db.models import VideoFile
-from pathlib import Path
+
 
 class VideoImportService(vis):
-    """
-    Wrapper for service import of concurrency safe VideoImportService, 
-    here celery will be implemented in the future.
-    12.02.2025
-    """
+    __doc__ = (vis.__doc__ or "") + (
+        "Wrapper for service import of concurrency safe VideoImportService.\n"
+        "Implemented for future Celery integration (12.02.2025).\n\n"
+    )
+    pass

endoreg_db/urls/__init__.py

@@ -47,8 +47,8 @@ router.register(r"patient-examinations", PatientExaminationViewSet)
 # Export raw API urlpatterns (no prefix). The project-level endoreg_db/urls.py mounts these under /api/.
 urlpatterns = [
     path("auth/bootstrap", auth_bootstrap, name="auth-bootstrap"),
-    path('', include(router.urls)),  
-    path('', include(api_urls)),
+    path("", include(router.urls)),
+    path("", include(api_urls)),
 ]
 
 if settings.DEBUG:

endoreg_db/urls/ai.py

@@ -1,32 +1,14 @@
 from django.urls import path
-from endoreg_db.views.ai import (label_list, add_label, delete_label, update_label)
+from endoreg_db.views.video.ai import label_list, add_label, delete_label, update_label
 
-url_patterns=[
+url_patterns = [
     # Label interface
     # GET, Returns list of labels
-    path(   
-        "ai/label-list",
-        label_list,
-        name="label-list"
-        ),
+    path("ai/label-list", label_list, name="label-list"),
     # POST, updates label by deleting old one and adding new one
-    path(
-        "ai/label-update",
-        update_label,
-        name="label-update"
-    ),
+    path("ai/label-update", update_label, name="label-update"),
     # DELETE, deletes a label
-    path(
-        "ai/label-delete",
-        delete_label,
-        name="label-delete"
-    ),
+    path("ai/label-delete", delete_label, name="label-delete"),
     # POST, allows adding a new label
-    path(
-        "ai/label-add",
-        add_label,
-        name="label-add"
-    )  
-    
-
-]
+    path("ai/label-add", add_label, name="label-add"),
+]

endoreg_db/urls/anonymization.py

@@ -13,20 +13,66 @@ from endoreg_db.views.anonymization import media_management
 
 url_patterns = [
     # URL patterns for anonymization overview
-    path('anonymization/items/overview/', AnonymizationOverviewView.as_view(), name='anonymization_items_overview'),
-    path('anonymization/<int:file_id>/current/', anonymization_current, name='set_current_for_validation'),
-    path('anonymization/<int:file_id>/start/', start_anonymization, name='start_anonymization'),
-    path('anonymization/<int:file_id>/status/', anonymization_status, name='get_anonymization_status'),
-    path('anonymization/<int:file_id>/validate/', AnonymizationValidateView.as_view(), name='validate_anonymization'),
-        # Polling Coordination API (new endpoints)
-    path('anonymization/polling-info/', polling_coordinator_info, name='polling_coordinator_info'),
-    path('anonymization/clear-locks/', clear_processing_locks, name='clear_processing_locks'),
-    path('anonymization/<int:file_id>/has-raw/', has_raw_video_file, name='has_raw_video_file'),
-
-    
+    path(
+        "anonymization/items/overview/",
+        AnonymizationOverviewView.as_view(),
+        name="anonymization_items_overview",
+    ),
+    path(
+        "anonymization/<int:file_id>/current/",
+        anonymization_current,
+        name="set_current_for_validation",
+    ),
+    path(
+        "anonymization/<int:file_id>/start/",
+        start_anonymization,
+        name="start_anonymization",
+    ),
+    path(
+        "anonymization/<int:file_id>/status/",
+        anonymization_status,
+        name="get_anonymization_status",
+    ),
+    path(
+        "anonymization/<int:file_id>/validate/",
+        AnonymizationValidateView.as_view(),
+        name="validate_anonymization",
+    ),
+    # Polling Coordination API (new endpoints)
+    path(
+        "anonymization/polling-info/",
+        polling_coordinator_info,
+        name="polling_coordinator_info",
+    ),
+    path(
+        "anonymization/clear-locks/",
+        clear_processing_locks,
+        name="clear_processing_locks",
+    ),
+    path(
+        "anonymization/<int:file_id>/has-raw/",
+        has_raw_video_file,
+        name="has_raw_video_file",
+    ),
     # Media Management API (new endpoints)
-    path('media-management/status/', media_management.MediaManagementView.as_view(), name='media_management_status'),
-    path('media-management/cleanup/', media_management.MediaManagementView.as_view(), name='media_management_cleanup'),
-    path('media-management/force-remove/<int:file_id>/', media_management.force_remove_media, name='force_remove_media'),
-    path('media-management/reset-status/<int:file_id>/', media_management.reset_processing_status, name='reset_processing_status'),
+    path(
+        "media-management/status/",
+        media_management.MediaManagementView.as_view(),
+        name="media_management_status",
+    ),
+    path(
+        "media-management/cleanup/",
+        media_management.MediaManagementView.as_view(),
+        name="media_management_cleanup",
+    ),
+    path(
+        "media-management/force-remove/<int:file_id>/",
+        media_management.force_remove_media,
+        name="force_remove_media",
+    ),
+    path(
+        "media-management/reset-status/<int:file_id>/",
+        media_management.reset_processing_status,
+        name="reset_processing_status",
+    ),
 ]

endoreg_db/urls/auth.py

@@ -9,8 +9,8 @@ from endoreg_db.views import (
 
 urlpatterns = [
     # Authentication endpoints
-    path('endoreg_db/', public_home, name='public_home'),
-    path('login/', keycloak_login, name='keycloak_login'),
-    path('login/callback/', keycloak_callback, name='keycloak_callback'),
-    path('conf/', csrf_token_view, name='csrf_token'),
+    path("endoreg_db/", public_home, name="public_home"),
+    path("login/", keycloak_login, name="keycloak_login"),
+    path("login/callback/", keycloak_callback, name="keycloak_callback"),
+    path("conf/", csrf_token_view, name="csrf_token"),
 ]

endoreg_db/urls/classification.py

@@ -1,4 +1,4 @@
-'''
+"""
 ---------------------------------------------------------------------------------------
 CLASSIFICATION API ENDPOINTS
 
@@ -9,9 +9,7 @@ Diese Endpunkte führen automatische Polyp-Klassifikationen durch:
 Diese APIs sind für Backend-Verarbeitung gedacht und werden typischerweise
 nach dem Import eines Videos automatisch aufgerufen.
 ---------------------------------------------------------------------------------------
-'''
-
-from django.urls import path
+"""
 
 url_patterns = [
     # NICE Classification API
@@ -19,21 +17,18 @@ url_patterns = [
     # Body: {"video_ids": [1, 2, 3]} oder leerer Body für alle Videos
     # Führt NICE-Klassifikation für spezifizierte Videos durch
     # path('classifications/nice/', ForNiceClassificationView.as_view(), name='nice_classification'),
-    
-    # PARIS Classification API  
+    # PARIS Classification API
     # POST /api/classifications/paris/
     # Body: {"video_ids": [1, 2, 3]} oder leerer Body für alle Videos
     # Führt PARIS-Klassifikation für spezifizierte Videos durch
     # path('classifications/paris/', ForParisClassificationView.as_view(), name='paris_classification'),
-    
     # Batch Classification API (beide Typen)
     # POST /api/classifications/batch/
     # Body: {"video_ids": [1, 2, 3], "types": ["nice", "paris"]}
     # Führt beide Klassifikationstypen für spezifizierte Videos durch
     # path('classifications/batch/', BatchClassificationView.as_view(), name='batch_classification'),
-    
     # Classification Status API
     # GET /api/classifications/status/<video_id>/
     # Gibt den Status der Klassifikationen für ein Video zurück
     # path('classifications/status/<int:video_id>/', ClassificationStatusView.as_view(), name='classification_status'),
-]
+]

endoreg_db/urls/examination.py

@@ -9,21 +9,21 @@ from endoreg_db.views import (
     PatientExaminationListView,
 )
 
-urlpatterns = [# URL patterns for ExaminationForm.vue API calls
+urlpatterns = [  # URL patterns for ExaminationForm.vue API calls
     path(
-        'examinations/<int:examination_id>/findings/',
+        "examinations/<int:examination_id>/findings/",
         get_findings_for_examination,
-        name='get_findings_for_examination'
+        name="get_findings_for_examination",
     ),
     path(
-        'findings/<int:finding_id>/classifications/',
+        "findings/<int:finding_id>/classifications/",
         get_classifications_for_finding,
-        name='get_classifications_for_finding'
+        name="get_classifications_for_finding",
     ),
     path(
-        'classifications/<int:classification_id>/choices/',
+        "classifications/<int:classification_id>/choices/",
         get_classification_choices,
-        name='get_choices_for_classification'
+        name="get_choices_for_classification",
     ),
     # NEW: Examination CRUD endpoints for SimpleExaminationForm
     # POST /api/examinations/create/ - Create new examination
@@ -34,21 +34,30 @@ urlpatterns = [# URL patterns for ExaminationForm.vue API calls
     # The views below handle PatientExamination instances, which represent a specific examination performed on a patient.
     # The URL names are updated to reflect this, using the 'patient_examination_*' prefix for clarity.
     # TODO: Clearly Distinguish between Examination and PatientExamination by using 'patient-examination' prefix for clarity
-    path('patient-examinations/create/', ExaminationCreateView.as_view(), name='patient_examination_create'),
-    path('patient-examinations/<int:pk>/',     PatientExaminationDetailView.as_view(), name='patient_examination_detail'),
-    path('patient-examinations/list/', PatientExaminationListView.as_view(), name='patient_examination_list'),
-
+    path(
+        "patient-examinations/create/",
+        ExaminationCreateView.as_view(),
+        name="patient_examination_create",
+    ),
+    path(
+        "patient-examinations/<int:pk>/",
+        PatientExaminationDetailView.as_view(),
+        name="patient_examination_detail",
+    ),
+    path(
+        "patient-examinations/list/",
+        PatientExaminationListView.as_view(),
+        name="patient_examination_list",
+    ),
     # NEW ENDPOINTS FOR RESTRUCTURED FRONTEND
     path(
-        'patient-examinations/<int:exam_id>/classifications/',
+        "patient-examinations/<int:exam_id>/classifications/",
         get_classifications_for_examination,
-        name='get_classifications_for_examination'
+        name="get_classifications_for_examination",
     ),
-    
     path(
-        'patient-examinations/<int:examination_id>/findings/',
+        "patient-examinations/<int:examination_id>/findings/",
         get_findings_for_examination,
-        name='get_patient_examination_findings'
+        name="get_patient_examination_findings",
     ),
-
-]
+]