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

endoreg_db/tasks/upload_tasks.py

@@ -1,12 +1,12 @@
-import os
 import logging
+import os
 from typing import Optional
-from celery_app import shared_task
+
 from django.core.files.storage import default_storage
 
-from endoreg_db.models.upload_job import UploadJob
+from celery_app import shared_task
 from endoreg_db.models import SensitiveMeta, VideoFile
-
+from endoreg_db.models.upload_job import UploadJob
 
 logger = logging.getLogger(__name__)
 
@@ -14,8 +14,8 @@ logger = logging.getLogger(__name__)
 @shared_task(bind=True)
 def process_upload_job(self, job_id: str) -> dict:
     """
-    Process an uploaded file (PDF or video) asynchronously.
-    
+    Process an uploaded file (report or video) asynchronously.
+
     This task:
     1. Updates job status to 'processing'
     2. Determines file type and routes to appropriate processor
@@ -23,10 +23,10 @@ def process_upload_job(self, job_id: str) -> dict:
     4. For videos: Uses VideoFile.create_from_file_initialized() and processing pipeline
     5. Links the created SensitiveMeta to the job and marks as 'anonymized'
     6. On error: marks job as 'error' with details
-    
+
     Args:
         job_id: UUID string of the UploadJob to process
-        
+
     Returns:
         dict: Processing result with status and details
     """
@@ -37,69 +37,71 @@ def process_upload_job(self, job_id: str) -> dict:
         except UploadJob.DoesNotExist:
             error_msg = f"UploadJob with id {job_id} not found"
             logger.error(error_msg)
-            return {'status': 'error', 'error': error_msg}
-        
+            return {"status": "error", "error": error_msg}
+
         # Mark as processing
         upload_job.mark_processing()
         logger.info(f"Started processing upload job {job_id}")
-        
+
         # Get file path
         file_path = upload_job.file.path
         if not os.path.exists(file_path):
             error_msg = f"Uploaded file not found at {file_path}"
             upload_job.mark_error(error_msg)
             logger.error(error_msg)
-            return {'status': 'error', 'error': error_msg}
-        
+            return {"status": "error", "error": error_msg}
+
         # Route to appropriate processor based on content type
         sensitive_meta = None
-        
-        if upload_job.content_type == 'application/pdf':
+
+        if upload_job.content_type == "application/pdf":
             sensitive_meta = _process_pdf_file(upload_job, file_path)
-        elif upload_job.content_type.startswith('video/'):
+        elif upload_job.content_type.startswith("video/"):
             sensitive_meta = _process_video_file(upload_job, file_path)
         else:
             error_msg = f"Unsupported content type: {upload_job.content_type}"
             upload_job.mark_error(error_msg)
             logger.error(error_msg)
-            return {'status': 'error', 'error': error_msg}
-        
+            return {"status": "error", "error": error_msg}
+
         if sensitive_meta:
             # Mark job as completed with the created SensitiveMeta
             upload_job.mark_completed(sensitive_meta)
-            logger.info(f"Successfully processed upload job {job_id}, created SensitiveMeta {sensitive_meta.id}")
+            logger.info(
+                f"Successfully processed upload job {job_id}, created SensitiveMeta {sensitive_meta.id}"
+            )
             return {
-                'status': 'anonymized',
-                'sensitive_meta_id': sensitive_meta.id,
-                'job_id': job_id
+                "status": "anonymized",
+                "sensitive_meta_id": sensitive_meta.id,
+                "job_id": job_id,
             }
         else:
             error_msg = "Processing completed but no SensitiveMeta was created"
             upload_job.mark_error(error_msg)
             logger.error(f"Upload job {job_id}: {error_msg}")
-            return {'status': 'error', 'error': error_msg}
-            
+            return {"status": "error", "error": error_msg}
+
     except Exception as e:
         error_msg = f"Unexpected error processing upload job {job_id}: {str(e)}"
         logger.exception(error_msg)
-        
+
         try:
             upload_job = UploadJob.objects.get(id=job_id)
             upload_job.mark_error(error_msg)
         except Exception as inner_e:
             logger.error(f"Failed to update job status after error: {inner_e}")
-        
-        return {'status': 'error', 'error': error_msg}
+
+        return {"status": "error", "error": error_msg}
 
 
 def _process_pdf_file(upload_job: UploadJob, file_path: str) -> Optional[SensitiveMeta]:
     """
-    Process a PDF file using ReportReader.
-    
+    Process a report file using ReportReader.
+
     Args:
         upload_job: The UploadJob instance
-        file_path: Path to the uploaded PDF file
-        
+        file_path: Path to the uploaded report file
+
     Returns:
         SensitiveMeta instance if successful, None otherwise
     """
@@ -108,100 +110,107 @@ def _process_pdf_file(upload_job: UploadJob, file_path: str) -> Optional[Sensiti
         try:
             from lx_anonymizer.report_reader import ReportReader
         except ImportError as e:
-            raise ImportError(f"Could not import ReportReader: {e}. Make sure lx-anonymizer is available.")
-        
-        logger.info(f"Processing PDF file: {file_path}")
-        
+            raise ImportError(
+                f"Could not import ReportReader: {e}. Make sure lx-anonymizer is available."
+            )
+
+        logger.info(f"Processing report file: {file_path}")
+
         # Create ReportReader instance
-        reader = ReportReader(
-            locale="de_DE",
-            text_date_format="%d.%m.%Y"
-        )
-        
+        reader = ReportReader(locale="de_DE", text_date_format="%d.%m.%Y")
+
         # Process the report
         original_text, anonymized_text, metadata = reader.process_report(
             pdf_path=file_path,
             use_ensemble=False,  # Can be made configurable
             verbose=False,
-            use_llm_extractor=None  # Use default extractor
+            use_llm_extractor=None,  # Use default extractor
         )
-        
+
         if not metadata:
-            raise ValueError("No metadata extracted from PDF")
-        
+            raise ValueError("No metadata extracted from report")
+
         # Create SensitiveMeta from extracted metadata
         sensitive_meta = SensitiveMeta.create_from_dict(metadata)
         sensitive_meta.save()
-        
-        logger.info(f"Created SensitiveMeta {sensitive_meta.id} from PDF processing")
+
+        logger.info(f"Created SensitiveMeta {sensitive_meta.id} from report processing")
         return sensitive_meta
-        
+
     except Exception as e:
-        logger.exception(f"Error processing PDF file {file_path}: {e}")
+        logger.exception(f"Error processing report file {file_path}: {e}")
         raise
 
 
-def _process_video_file(upload_job: UploadJob, file_path: str) -> Optional[SensitiveMeta]:
+def _process_video_file(
+    upload_job: UploadJob, file_path: str
+) -> Optional[SensitiveMeta]:
     """
     Process a video file using VideoFile creation and processing pipeline.
-    
+
     Args:
         upload_job: The UploadJob instance
         file_path: Path to the uploaded video file
-        
+
     Returns:
         SensitiveMeta instance if successful, None otherwise
     """
     try:
         logger.info(f"Processing video file: {file_path}")
-        
+
         # Get the relative path for storage
         relative_path = os.path.relpath(file_path, default_storage.location)
-        
+
         # Create VideoFile instance using the existing method
         video_file = VideoFile.create_from_file_initialized(
             file_path=relative_path,
             skip_frame_extraction=False,  # Extract frames for processing
-            skip_meta_extraction=False,   # Extract metadata
+            skip_meta_extraction=False,  # Extract metadata
         )
-        
+
         if not video_file:
             raise ValueError("Failed to create VideoFile instance")
-        
+
         # Run the video processing pipeline (pipe_1)
         try:
             # Import the processing function
             from endoreg_db.management.commands.import_video import pipe_1
-            
+
             # Run processing pipeline
             pipe_1(
                 video_file=video_file,
                 skip_frame_extraction=False,
                 skip_meta_extraction=False,
-                skip_anonymization=False
+                skip_anonymization=False,
             )
-            
+
         except Exception as e:
-            logger.warning(f"Video processing pipeline failed, but VideoFile was created: {e}")
+            logger.warning(
+                f"Video processing pipeline failed, but VideoFile was created: {e}"
+            )
             # Continue anyway - we might still have usable metadata
-        
+
         # Get the associated SensitiveMeta
-        if hasattr(video_file, 'sensitive_meta') and video_file.sensitive_meta:
+        if hasattr(video_file, "sensitive_meta") and video_file.sensitive_meta:
             sensitive_meta = video_file.sensitive_meta
-            logger.info(f"Found SensitiveMeta {sensitive_meta.id} from video processing")
+            logger.info(
+                f"Found SensitiveMeta {sensitive_meta.id} from video processing"
+            )
             return sensitive_meta
         else:
             # Create a basic SensitiveMeta if none exists
             sensitive_meta = SensitiveMeta.objects.create()
-            
+
             # Link it to the video if possible
-            if hasattr(video_file, 'sensitive_meta'):
+            if hasattr(video_file, "sensitive_meta"):
                 video_file.sensitive_meta = sensitive_meta
-                video_file.save(update_fields=['sensitive_meta'])
-            
-            logger.info(f"Created basic SensitiveMeta {sensitive_meta.id} for video file")
+                video_file.save(update_fields=["sensitive_meta"])
+
+            logger.info(
+                f"Created basic SensitiveMeta {sensitive_meta.id} for video file"
+            )
             return sensitive_meta
-            
+
     except Exception as e:
         logger.exception(f"Error processing video file {file_path}: {e}")
-        raise
+        raise

endoreg_db/tasks/video_ingest.py

@@ -63,15 +63,19 @@ def run_import_video(file_path: str, center_name: Optional[str] = None,
             }
         
         # Use settings defaults if not provided
-        center_name = center_name or getattr(settings, 'DEFAULT_CENTER', 'university_hospital_wuerzburg')
-        processor_name = processor_name or getattr(settings, 'DEFAULT_PROCESSOR', 'olympus_cv_1500')
-        
+        if not isinstance(center_name, str):
+            getattr(settings, 'DEFAULT_CENTER', 'university_hospital_wuerzburg')
+            assert(center_name is str)
+        if not isinstance(processor_name, str):
+            assert(processor_name is str)
+            getattr(settings, 'DEFAULT_PROCESSOR', 'olympus_cv_1500')
+
         logger.info(f"Starting import for video: {file_path}")
         logger.info(f"Using center: {center_name}, processor: {processor_name}")
         
         # Try to use the service first
         try:
-            from endoreg_db.services import video_import
+            from endoreg_db.services.__old import video_import
             
             video_file_obj = video_import.import_and_anonymize(
                 file_path=file_path,

endoreg_db/urls/__init__.py

@@ -3,61 +3,39 @@ from django.conf.urls.static import static
 from django.urls import include, path
 from rest_framework.routers import DefaultRouter
 
+from endoreg_db.authz.views_auth import auth_bootstrap
+
 from endoreg_db.views import (
     ExaminationViewSet,
     FindingClassificationViewSet,
     FindingViewSet,
     PatientExaminationViewSet,
     PatientFindingViewSet,
-    VideoExaminationViewSet,
-    VideoViewSet,
 )
 
 from .anonymization import url_patterns as anonymization_url_patterns
 from .auth import urlpatterns as auth_url_patterns
 from .classification import url_patterns as classification_url_patterns
 from .examination import urlpatterns as examination_url_patterns
-from .files import urlpatterns as files_url_patterns
-from .label_video_segment_validate import (
-    url_patterns as label_video_segment_validate_url_patterns,
-)
-from .label_video_segments import url_patterns as label_video_segments_url_patterns
-
-# Phase 1.2: Media Management URLs ✅ IMPLEMENTED
 from .media import urlpatterns as media_url_patterns
 from .patient import urlpatterns as patient_url_patterns
-
-# TODO Phase 1.2: Implement VideoMediaView and PDFMediaView before enabling
-# from .media import urlpatterns as media_url_patterns
-from .report import url_patterns as report_url_patterns
 from .requirements import urlpatterns as requirements_url_patterns
 from .stats import url_patterns as stats_url_patterns
 from .upload import urlpatterns as upload_url_patterns
-from .video import url_patterns as video_url_patterns
 
 api_urls = []
 api_urls += classification_url_patterns
 api_urls += anonymization_url_patterns
 api_urls += auth_url_patterns
 api_urls += examination_url_patterns
-api_urls += files_url_patterns
-api_urls += label_video_segments_url_patterns
-api_urls += label_video_segment_validate_url_patterns  # Neue Validierungs-Endpunkte
-# Phase 1.2: Enable media_url_patterns ✅ IMPLEMENTED
 api_urls += media_url_patterns
-api_urls += report_url_patterns
 api_urls += upload_url_patterns
-api_urls += video_url_patterns
 api_urls += requirements_url_patterns
 api_urls += patient_url_patterns
 api_urls += stats_url_patterns
 
 router = DefaultRouter()
-router.register(r"videos", VideoViewSet, basename="videos")
 router.register(r"examinations", ExaminationViewSet)
-router.register(
-    r"video-examinations", VideoExaminationViewSet, basename="video-examinations"
-)
 router.register(r"findings", FindingViewSet)
 router.register(r"classifications", FindingClassificationViewSet)
 router.register(r"patient-findings", PatientFindingViewSet)
@@ -65,17 +43,12 @@ router.register(r"patient-examinations", PatientExaminationViewSet)
 
 # Additional custom video examination routes
 # Frontend expects: GET /api/video/{id}/examinations/
-video_examinations_list = VideoExaminationViewSet.as_view({"get": "by_video"})
 
 # Export raw API urlpatterns (no prefix). The project-level endoreg_db/urls.py mounts these under /api/.
 urlpatterns = [
-    path(
-        "video/<int:video_id>/examinations/",
-        video_examinations_list,
-        name="video-examinations-by-video",
-    ),
-    path("", include(api_urls)),  # Specific routes first
-    path("", include(router.urls)),  # Generic router routes second
+    path("auth/bootstrap", auth_bootstrap, name="auth-bootstrap"),
+    path('', include(router.urls)),  
+    path('', include(api_urls)),
 ]
 
 if settings.DEBUG:

endoreg_db/urls/ai.py

@@ -0,0 +1,32 @@
+from django.urls import path
+from endoreg_db.views.ai import (label_list, add_label, delete_label, update_label)
+
+url_patterns=[
+    # Label interface
+    # GET, Returns list of labels
+    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"
+    ),
+    # DELETE, deletes a label
+    path(
+        "ai/label-delete",
+        delete_label,
+        name="label-delete"
+    ),
+    # POST, allows adding a new label
+    path(
+        "ai/label-add",
+        add_label,
+        name="label-add"
+    )  
+    
+
+]