endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

endoreg_db/tasks/upload_tasks.py

@@ -0,0 +1,207 @@
+import os
+import logging
+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 endoreg_db.models import SensitiveMeta, VideoFile
+
+
+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.
+    
+    This task:
+    1. Updates job status to 'processing'
+    2. Determines file type and routes to appropriate processor
+    3. For PDFs: Uses ReportReader to extract metadata and create SensitiveMeta
+    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
+    """
+    try:
+        # Get the upload job
+        try:
+            upload_job = UploadJob.objects.get(id=job_id)
+        except UploadJob.DoesNotExist:
+            error_msg = f"UploadJob with id {job_id} not found"
+            logger.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}
+        
+        # Route to appropriate processor based on content type
+        sensitive_meta = None
+        
+        if upload_job.content_type == 'application/pdf':
+            sensitive_meta = _process_pdf_file(upload_job, file_path)
+        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}
+        
+        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}")
+            return {
+                '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}
+            
+    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}
+
+
+def _process_pdf_file(upload_job: UploadJob, file_path: str) -> Optional[SensitiveMeta]:
+    """
+    Process a PDF file using ReportReader.
+    
+    Args:
+        upload_job: The UploadJob instance
+        file_path: Path to the uploaded PDF file
+        
+    Returns:
+        SensitiveMeta instance if successful, None otherwise
+    """
+    try:
+        # Import ReportReader (lazy import to avoid startup issues)
+        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}")
+        
+        # Create ReportReader instance
+        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
+        )
+        
+        if not metadata:
+            raise ValueError("No metadata extracted from PDF")
+        
+        # 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")
+        return sensitive_meta
+        
+    except Exception as e:
+        logger.exception(f"Error processing PDF file {file_path}: {e}")
+        raise
+
+
+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
+        )
+        
+        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
+            )
+            
+        except Exception as 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:
+            sensitive_meta = video_file.sensitive_meta
+            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'):
+                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")
+            return sensitive_meta
+            
+    except Exception as e:
+        logger.exception(f"Error processing video file {file_path}: {e}")
+        raise

endoreg_db/tasks/video_ingest.py

@@ -0,0 +1,157 @@
+"""
+Video ingestion tasks using RQ (Redis Queue).
+
+This module provides background task processing for video file imports,
+allowing asynchronous processing of video files dropped into the inbox directory.
+"""
+
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+import rq
+import django
+from django.conf import settings
+from django.core.management import call_command
+from redis import Redis
+
+logger = logging.getLogger(__name__)
+
+# Redis connection configuration
+REDIS_URL = os.getenv('RQ_REDIS_URL', 'redis://localhost:6379/0')
+
+def get_redis_connection():
+    """Get Redis connection for RQ."""
+    try:
+        return Redis.from_url(REDIS_URL)
+    except Exception as e:
+        logger.error(f"Failed to connect to Redis at {REDIS_URL}: {e}")
+        raise
+
+def get_queue():
+    """Get the 'anonymize' RQ queue."""
+    redis_conn = get_redis_connection()
+    return rq.Queue('anonymize', connection=redis_conn)
+
+def run_import_video(file_path: str, center_name: Optional[str] = None, 
+                    processor_name: Optional[str] = None) -> dict:
+    """
+    RQ task to import a video file using the video import service.
+    
+    Args:
+        file_path: Path to the video file to import
+        center_name: Optional center name (defaults to settings.DEFAULT_CENTER)
+        processor_name: Optional processor name (defaults to settings.DEFAULT_PROCESSOR)
+        
+    Returns:
+        Dict containing task result status and metadata
+    """
+    try:
+        # Ensure Django is properly set up
+        if not django.apps.apps.ready:
+            django.setup()
+        
+        file_path = Path(file_path)
+        if not file_path.exists():
+            error_msg = f"Video file not found: {file_path}"
+            logger.error(error_msg)
+            return {
+                'status': 'error',
+                'message': error_msg,
+                'file_path': str(file_path)
+            }
+        
+        # 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')
+        
+        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
+            
+            video_file_obj = video_import.import_and_anonymize(
+                file_path=file_path,
+                center_name=center_name,
+                processor_name=processor_name,
+                save_video=True,
+                delete_source=True
+            )
+            
+            success_msg = f"Successfully imported video: {file_path.name} (UUID: {video_file_obj.uuid})"
+            logger.info(success_msg)
+            
+            return {
+                'status': 'success',
+                'message': success_msg,
+                'file_path': str(file_path),
+                'video_uuid': str(video_file_obj.uuid),
+                'center_name': center_name,
+                'processor_name': processor_name
+            }
+            
+        except Exception as service_error:
+            logger.warning(f"Service import failed: {service_error}, falling back to management command")
+            
+            # Fallback to Django management command
+            call_command(
+                "import_video", 
+                str(file_path),
+                "--center_name", center_name,
+                "--processor_name", processor_name,
+                "--save_video_file",
+                "--delete_source"
+            )
+            
+            success_msg = f"Successfully imported video via fallback: {file_path.name}"
+            logger.info(success_msg)
+            
+            return {
+                'status': 'success',
+                'message': success_msg,
+                'file_path': str(file_path),
+                'center_name': center_name,
+                'processor_name': processor_name,
+                'method': 'fallback_command'
+            }
+        
+    except Exception as e:
+        error_msg = f"Failed to import video {file_path}: {str(e)}"
+        logger.error(error_msg, exc_info=True)
+        
+        return {
+            'status': 'error',
+            'message': error_msg,
+            'file_path': str(file_path),
+            'exception': str(e)
+        }
+
+def enqueue_video_import(file_path: str, center_name: Optional[str] = None,
+                        processor_name: Optional[str] = None) -> rq.Job:
+    """
+    Enqueue a video import task.
+    
+    Args:
+        file_path: Path to the video file to import
+        center_name: Optional center name
+        processor_name: Optional processor name
+        
+    Returns:
+        RQ Job instance
+    """
+    queue = get_queue()
+    
+    job = queue.enqueue(
+        run_import_video,
+        file_path,
+        center_name,
+        processor_name,
+        job_timeout='30m',  # 30 minute timeout for video processing
+        result_ttl=86400    # Keep results for 24 hours
+    )
+    
+    logger.info(f"Enqueued video import job {job.id} for file: {file_path}")
+    return job

endoreg_db/tasks/video_processing_tasks.py

@@ -0,0 +1,327 @@
+"""
+Video processing tasks for Celery-based asynchronous video processing.
+
+This module provides Celery tasks for:
+- Video masking with streaming FFmpeg processing
+- Frame removal with streaming optimization
+- Video reprocessing workflows
+- Progress tracking and status updates
+"""
+
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+from celery import shared_task
+from celery.utils.log import get_task_logger
+from django.shortcuts import get_object_or_404
+
+logger = get_task_logger(__name__)
+
+@shared_task(bind=True)
+def apply_video_mask_task(self, video_id: int, mask_type: str = 'device_default', 
+                         device_name: str = 'olympus_cv_1500', use_streaming: bool = True,
+                         custom_mask: Optional[Dict[str, Any]] = None):
+    """
+    Apply mask to video using streaming processing.
+    
+    Args:
+        video_id: ID of the VideoFile to process
+        mask_type: Type of mask to apply ('device_default', 'roi_based', 'custom')
+        device_name: Device name for default mask
+        use_streaming: Whether to use streaming processing (recommended)
+        custom_mask: Custom mask configuration (if mask_type='custom')
+    """
+    try:
+        # Update task progress
+        self.update_state(state='PROGRESS', meta={'progress': 0, 'message': 'Initializing mask application...'})
+        
+        # Import models here to avoid circular imports
+        from endoreg_db.models import VideoFile
+        from lx_anonymizer.frame_cleaner import FrameCleaner
+        
+        # Get video file
+        video = get_object_or_404(VideoFile, pk=video_id)
+        video_path = Path(video.file.path)
+        
+        if not video_path.exists():
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+        
+        # Create output path
+        output_dir = video_path.parent / "processed"
+        output_dir.mkdir(exist_ok=True)
+        output_path = output_dir / f"{video_path.stem}_masked{video_path.suffix}"
+        
+        self.update_state(state='PROGRESS', meta={'progress': 10, 'message': 'Setting up FrameCleaner...'})
+        
+        # Initialize FrameCleaner
+        cleaner = FrameCleaner()
+        
+        # Determine mask configuration
+        if mask_type == 'custom' and custom_mask:
+            mask_config = custom_mask
+        elif mask_type == 'roi_based':
+            # Would need ROI data from video metadata
+            mask_config = cleaner._load_mask(device_name)  # Fallback for now
+        else:  # device_default
+            mask_config = cleaner._load_mask(device_name)
+        
+        self.update_state(state='PROGRESS', meta={'progress': 20, 'message': f'Applying {mask_type} mask...'})
+        
+        # Apply mask using streaming
+        if use_streaming:
+            success = cleaner._mask_video_streaming(
+                video_path, mask_config, output_path, use_named_pipe=True
+            )
+        else:
+            success = cleaner._mask_video(video_path, mask_config, output_path)
+        
+        if not success:
+            raise RuntimeError("Video masking failed")
+        
+        self.update_state(state='PROGRESS', meta={'progress': 90, 'message': 'Finalizing...'})
+        
+        # Verify output
+        if not output_path.exists() or output_path.stat().st_size == 0:
+            raise RuntimeError("Output video is empty or missing")
+        
+        result = {
+            'status': 'completed',
+            'output_path': str(output_path),
+            'mask_type': mask_type,
+            'device_name': device_name,
+            'use_streaming': use_streaming,
+            'output_size': output_path.stat().st_size,
+            'message': 'Video masking completed successfully'
+        }
+        
+        logger.info(f"Video masking completed for video {video_id}: {output_path}")
+        return result
+        
+    except Exception as e:
+        logger.error(f"Video masking failed for video {video_id}: {e}")
+        self.update_state(
+            state='FAILURE',
+            meta={'error': str(e), 'message': f'Video masking failed: {e}'}
+        )
+        raise
+
+
+def _setup_frame_removal(video_id: int, detection_engine: str):
+    from endoreg_db.models import VideoFile
+    from lx_anonymizer.frame_cleaner import FrameCleaner
+    from django.shortcuts import get_object_or_404
+    video = get_object_or_404(VideoFile, pk=video_id)
+    video_path = Path(video.raw_file.path)
+    if not video_path.exists():
+        raise FileNotFoundError(f"Video file not found: {video_path}")
+    output_dir = video_path.parent / "processed"
+    output_dir.mkdir(exist_ok=True)
+    output_path = output_dir / f"{video_path.stem}_cleaned{video_path.suffix}"
+    use_minicpm = detection_engine == 'minicpm'
+    cleaner = FrameCleaner()
+    return video, video_path, output_path, cleaner
+
+def _detect_sensitive_frames(self, cleaner, video_path, selection_method, manual_frames, total_frames):
+    frames_to_remove = []
+    if selection_method == 'manual' and manual_frames:
+        frames_to_remove = manual_frames
+        self.update_state(state='PROGRESS', meta={'progress': 50, 'message': f'Using manual frame selection: {len(frames_to_remove)} frames'})
+    elif selection_method == 'automatic':
+        self.update_state(state='PROGRESS', meta={'progress': 20, 'message': 'Detecting sensitive frames...'})
+        if total_frames > 10000:
+            self.update_state(state='PROGRESS', meta={'progress': 30, 'message': 'Using statistical sampling for large video...'})
+            sensitive_frames, estimated_ratio, early_stopped = cleaner._sample_frames_coroutine(
+                video_path, total_frames, max_samples=500
+            )
+            frames_to_remove = sensitive_frames
+        else:
+            self.update_state(state='PROGRESS', meta={'progress': 30, 'message': 'Analyzing all frames...'})
+            for abs_i, gray_frame, skip in cleaner._iter_video(video_path, total_frames):
+                progress = 30 + (abs_i / total_frames) * 40  # 30-70% for detection
+                if abs_i % 100 == 0:
+                    self.update_state(state='PROGRESS', meta={
+                        'progress': int(progress),
+                        'message': f'Analyzing frame {abs_i}/{total_frames}...'
+                    })
+                ocr_text, avg_conf, _ = cleaner.frame_ocr.extract_text_from_frame(
+                    gray_frame, roi=None, high_quality=True
+                )
+                if ocr_text:
+                    frame_metadata = cleaner.extract_metadata_deepseek(ocr_text)
+                    if not frame_metadata:
+                        frame_metadata = cleaner.frame_metadata_extractor.extract_metadata_from_frame_text(ocr_text)
+                    has_sensitive = cleaner.frame_metadata_extractor.is_sensitive_content(frame_metadata)
+                    if has_sensitive:
+                        frames_to_remove.append(abs_i)
+    return frames_to_remove
+
+def _remove_frames_from_video(cleaner, video_path, frames_to_remove, output_path, use_streaming):
+    if use_streaming:
+        return cleaner.remove_frames_from_video_streaming(
+            video_path, frames_to_remove, output_path, use_named_pipe=True
+        )
+    else:
+        return cleaner.remove_frames_from_video(
+            video_path, frames_to_remove, output_path
+        )
+
+def _verify_frame_removal_output(output_path):
+    if not output_path.exists() or output_path.stat().st_size == 0:
+        raise RuntimeError("Output video is empty or missing")
+
+@shared_task(bind=True)
+def remove_video_frames_task(self, video_id: int, selection_method: str = 'automatic',
+                            detection_engine: str = 'minicpm', use_streaming: bool = True,
+                            manual_frames: Optional[List[int]] = None):
+    """
+    Remove frames from video using streaming processing.
+    
+    Args:
+        video_id: ID of the VideoFile to process
+        selection_method: 'automatic' or 'manual'
+        detection_engine: 'minicpm' or 'traditional'
+        use_streaming: Whether to use streaming processing
+        manual_frames: List of frame indices to remove (for manual selection)
+    """
+    try:
+        # Update task progress
+        self.update_state(state='PROGRESS', meta={'progress': 0, 'message': 'Initializing frame removal...'})
+        
+        video, video_path, output_path, cleaner = _setup_frame_removal(video_id, detection_engine)
+        
+        self.update_state(state='PROGRESS', meta={'progress': 10, 'message': 'Setting up FrameCleaner...'})
+        
+        # Get total frame count
+        total_frames = cleaner._get_total_frames()
+        
+        frames_to_remove = _detect_sensitive_frames(
+            self, cleaner, video_path, selection_method, manual_frames, total_frames
+        )
+        
+        self.update_state(state='PROGRESS', meta={'progress': 70, 'message': f'Removing {len(frames_to_remove)} frames...'})
+        
+        # Remove frames using streaming
+        success = _remove_frames_from_video(cleaner, video_path, frames_to_remove, output_path, use_streaming)
+
+        if not success:
+            raise RuntimeError("Frame removal failed")
+        
+        self.update_state(state='PROGRESS', meta={'progress': 90, 'message': 'Finalizing...'})
+        
+        _verify_frame_removal_output(output_path)
+        
+        result = {
+            'status': 'completed',
+            'output_path': str(output_path),
+            'frames_removed': len(frames_to_remove),
+            'selection_method': selection_method,
+            'detection_engine': detection_engine,
+            'use_streaming': use_streaming,
+            'output_size': output_path.stat().st_size,
+            'message': f'Successfully removed {len(frames_to_remove)} frames'
+        }
+        
+        logger.info(f"Frame removal completed for video {video_id}: {len(frames_to_remove)} frames removed")
+        return result
+        
+    except Exception as e:
+        logger.error(f"Frame removal failed for video {video_id}: {e}")
+        self.update_state(
+            state='FAILURE',
+            meta={'error': str(e), 'message': f'Frame removal failed: {e}'}
+        )
+        raise
+
+
+@shared_task(bind=True)
+def reprocess_video_task(self, video_id: int):
+    """
+    Reprocess video with updated settings.
+    
+    Args:
+        video_id: ID of the VideoFile to reprocess
+    """
+    try:
+        self.update_state(state='PROGRESS', meta={'progress': 0, 'message': 'Starting video reprocessing...'})
+        
+        # Import models here to avoid circular imports
+        from endoreg_db.models import VideoFile
+        from lx_anonymizer.frame_cleaner import FrameCleaner
+        
+        # Get video file
+        video = get_object_or_404(VideoFile, pk=video_id)
+        video_path = Path(video.file.path)
+        
+        if not video_path.exists():
+            raise FileNotFoundError(f"Video file not found: {video_path}")
+        
+        self.update_state(state='PROGRESS', meta={'progress': 20, 'message': 'Initializing FrameCleaner...'})
+        
+        # Initialize FrameCleaner with optimal settings
+        cleaner = FrameCleaner()
+        
+        # Create output path
+        output_dir = video_path.parent / "processed"
+        output_dir.mkdir(exist_ok=True)
+        output_path = output_dir / f"{video_path.stem}_reprocessed{video_path.suffix}"
+        
+        self.update_state(state='PROGRESS', meta={'progress': 30, 'message': 'Analyzing video...'})
+        
+        # Perform full analysis
+        analysis_result = cleaner.analyze_video_sensitivity()
+        
+        self.update_state(state='PROGRESS', meta={'progress': 60, 'message': f'Processing with {analysis_result["recommended_method"]}...'})
+        
+        # Process based on analysis recommendation
+        if analysis_result["recommended_method"] == "masking":
+            # Apply device-specific masking
+            mask_config = cleaner._load_mask("olympus_cv_1500")  # Default device
+            success = cleaner._mask_video_streaming(
+                video_path, mask_config, output_path, use_named_pipe=True
+            )
+        else:
+            # Remove sensitive frames
+            sensitive_frames = analysis_result.get("sensitive_frame_list", [])
+            # Filter out string elements like "...truncated"
+            sensitive_frames = [f for f in sensitive_frames if isinstance(f, int)]
+            
+            success = cleaner.remove_frames_from_video_streaming(
+                video_path, sensitive_frames, output_path, use_named_pipe=True
+            )
+        
+        if not success:
+            raise RuntimeError("Video reprocessing failed")
+        
+        self.update_state(state='PROGRESS', meta={'progress': 90, 'message': 'Finalizing...'})
+        
+        # Update video metadata with analysis results
+        if hasattr(video, 'sensitive_frame_count'):
+            video.sensitive_frame_count = analysis_result.get('sensitive_frames', 0)
+        if hasattr(video, 'total_frames'):
+            video.total_frames = analysis_result.get('total_frames', 0)
+        if hasattr(video, 'sensitive_ratio'):
+            video.sensitive_ratio = analysis_result.get('sensitivity_ratio', 0.0)
+        
+        try:
+            video.save()
+        except Exception as e:
+            logger.warning(f"Could not save video metadata: {e}")
+        
+        result = {
+            'status': 'completed',
+            'output_path': str(output_path),
+            'analysis_result': analysis_result,
+            'processing_method': analysis_result["recommended_method"],
+            'output_size': output_path.stat().st_size if output_path.exists() else 0,
+            'message': 'Video reprocessing completed successfully'
+        }
+        
+        logger.info(f"Video reprocessing completed for video {video_id}")
+        return result
+        
+    except Exception as e:
+        logger.error(f"Video reprocessing failed for video {video_id}: {e}")
+        self.update_state(
+            state='FAILURE',
+            meta={'error': str(e), 'message': f'Video reprocessing failed: {e}'}
+        )
+        raise