endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/utils/frame_anonymization_utils.py

@@ -0,0 +1,463 @@
+"""
+Utility-Funktionen für Frame-Anonymisierung
+
+Diese Datei enthält Hilfsfunktionen für die Frame-Anonymisierung,
+einschließlich Bildverarbeitung, Pfad-Management und Sicherheitsfunktionen.
+"""
+
+import hashlib
+import secrets
+from pathlib import Path
+from typing import Optional, Dict, List
+from datetime import datetime, timedelta
+import logging
+
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from django.utils import timezone
+
+logger = logging.getLogger(__name__)
+
+# Unterstützte Ausgabeformate
+SUPPORTED_OUTPUT_FORMATS = ['jpg', 'jpeg', 'png', 'webp']
+
+# Anonymisierungsgrade
+ANONYMIZATION_LEVELS = ['minimal', 'faces', 'full']
+
+# Maximale Dateigröße für Frames (in MB)
+MAX_FRAME_SIZE_MB = 50
+
+
+def validate_anonymization_request(video_id: int, segment_ids: List[int], 
+                                 anonymization_level: str, output_format: str) -> Dict:
+    """
+    Validiert eine Frame-Anonymisierungsanfrage.
+    
+    Args:
+        video_id: Video-ID
+        segment_ids: Liste der Segment-IDs
+        anonymization_level: Anonymisierungsgrad
+        output_format: Ausgabeformat
+    
+    Returns:
+        Dict mit Validierungsergebnis
+    
+    Raises:
+        ValidationError: Bei ungültigen Parametern
+    """
+    errors = []
+    
+    # Anonymisierungsgrad validieren
+    if anonymization_level not in ANONYMIZATION_LEVELS:
+        errors.append(f"Invalid anonymization level: {anonymization_level}. "
+                     f"Supported levels: {', '.join(ANONYMIZATION_LEVELS)}")
+    
+    # Ausgabeformat validieren
+    if output_format.lower() not in SUPPORTED_OUTPUT_FORMATS:
+        errors.append(f"Invalid output format: {output_format}. "
+                     f"Supported formats: {', '.join(SUPPORTED_OUTPUT_FORMATS)}")
+    
+    # Segment-IDs validieren
+    if not segment_ids or len(segment_ids) == 0:
+        errors.append("At least one segment ID must be provided")
+    
+    if len(segment_ids) > 100:  # Reasonable limit
+        errors.append("Too many segments requested (max 100)")
+    
+    # Video-ID validieren
+    if video_id <= 0:
+        errors.append("Invalid video ID")
+    
+    if errors:
+        raise ValidationError(errors)
+    
+    return {
+        'valid': True,
+        'normalized_format': output_format.lower(),
+        'segment_count': len(segment_ids)
+    }
+
+
+def generate_secure_token(length: int = 32) -> str:
+    """
+    Generiert einen sicheren Token für Downloads.
+    
+    Args:
+        length: Token-Länge
+    
+    Returns:
+        Sicherer Token
+    """
+    return secrets.token_urlsafe(length)
+
+
+def create_secure_download_url(frame_id: int, expiry_hours: int = 24) -> Dict:
+    """
+    Erstellt eine sichere Download-URL für einen anonymisierten Frame.
+    
+    Args:
+        frame_id: Frame-ID
+        expiry_hours: Gültigkeitsdauer in Stunden
+    
+    Returns:
+        Dict mit URL und Token-Informationen
+    """
+    token = generate_secure_token()
+    expiry_time = timezone.now() + timedelta(hours=expiry_hours)
+    
+    # Token hashen für Datenbank-Speicherung
+    token_hash = hashlib.sha256(token.encode()).hexdigest()
+    
+    return {
+        'token': token,
+        'token_hash': token_hash,
+        'expires_at': expiry_time,
+        'frame_id': frame_id
+    }
+
+
+def validate_secure_token(token: str, frame_id: int) -> bool:
+    """
+    Validiert einen sicheren Download-Token.
+    
+    Args:
+        token: Download-Token
+        frame_id: Frame-ID
+    
+    Returns:
+        True wenn Token gültig ist
+    """
+    try:
+        from endoreg_db.models import AnonymousFrame
+        
+        # Token hashen
+        token_hash = hashlib.sha256(token.encode()).hexdigest()
+        
+        # Frame mit Token finden
+        frame = AnonymousFrame.objects.filter(
+            id=frame_id,
+            download_token_hash=token_hash,
+            download_expires_at__gt=timezone.now()
+        ).first()
+        
+        return frame is not None
+        
+    except Exception as e:
+        logger.error(f"Token validation error: {str(e)}")
+        return False
+
+
+def get_frame_file_info(frame_path: str) -> Optional[Dict]:
+    """
+    Holt Dateiinformationen für einen Frame.
+    
+    Args:
+        frame_path: Pfad zum Frame
+    
+    Returns:
+        Dict mit Dateiinformationen oder None
+    """
+    try:
+        path = Path(frame_path)
+        
+        if not path.exists():
+            return None
+        
+        stat = path.stat()
+        
+        return {
+            'filename': path.name,
+            'size_bytes': stat.st_size,
+            'size_mb': round(stat.st_size / (1024 * 1024), 2),
+            'created_at': datetime.fromtimestamp(stat.st_ctime),
+            'modified_at': datetime.fromtimestamp(stat.st_mtime),
+            'extension': path.suffix.lower(),
+            'exists': True
+        }
+        
+    except Exception as e:
+        logger.error(f"Error getting file info for {frame_path}: {str(e)}")
+        return None
+
+
+def calculate_anonymization_progress(total_frames: int, processed_frames: int, 
+                                   failed_frames: int) -> Dict:
+    """
+    Berechnet den Fortschritt der Anonymisierung.
+    
+    Args:
+        total_frames: Gesamtzahl der Frames
+        processed_frames: Anzahl verarbeiteter Frames
+        failed_frames: Anzahl fehlgeschlagener Frames
+    
+    Returns:
+        Dict mit Fortschrittsinformationen
+    """
+    if total_frames == 0:
+        return {
+            'progress_percent': 0,
+            'completed_frames': 0,
+            'remaining_frames': 0,
+            'success_rate': 0,
+            'status': 'pending'
+        }
+    
+    completed_frames = processed_frames + failed_frames
+    progress_percent = (completed_frames / total_frames) * 100
+    success_rate = (processed_frames / completed_frames * 100) if completed_frames > 0 else 0
+    
+    # Status bestimmen
+    if completed_frames == 0:
+        status = 'pending'
+    elif completed_frames < total_frames:
+        status = 'processing'
+    elif failed_frames == total_frames:
+        status = 'failed'
+    else:
+        status = 'completed'
+    
+    return {
+        'progress_percent': round(progress_percent, 1),
+        'completed_frames': completed_frames,
+        'remaining_frames': total_frames - completed_frames,
+        'success_rate': round(success_rate, 1),
+        'status': status,
+        'total_frames': total_frames,
+        'processed_frames': processed_frames,
+        'failed_frames': failed_frames
+    }
+
+
+def estimate_processing_time(total_frames: int, anonymization_level: str) -> Dict:
+    """
+    Schätzt die Verarbeitungszeit für die Anonymisierung.
+    
+    Args:
+        total_frames: Anzahl der zu verarbeitenden Frames
+        anonymization_level: Anonymisierungsgrad
+    
+    Returns:
+        Dict mit Zeitschätzungen
+    """
+    # Geschätzte Verarbeitungszeit pro Frame (in Sekunden)
+    time_per_frame = {
+        'minimal': 0.5,
+        'faces': 1.0,
+        'full': 0.8
+    }
+    
+    base_time = time_per_frame.get(anonymization_level, 1.0)
+    estimated_seconds = total_frames * base_time
+    
+    # Overhead für Setup und Cleanup
+    overhead_seconds = min(30, total_frames * 0.1)
+    total_seconds = estimated_seconds + overhead_seconds
+    
+    return {
+        'estimated_seconds': int(total_seconds),
+        'estimated_minutes': round(total_seconds / 60, 1),
+        'frames_per_second': round(1 / base_time, 1),
+        'anonymization_level': anonymization_level
+    }
+
+
+def cleanup_expired_tokens():
+    """
+    Bereinigt abgelaufene Download-Tokens.
+    
+    Returns:
+        Anzahl bereinigter Tokens
+    """
+    try:
+        from endoreg_db.models import AnonymousFrame
+        
+        # Frames mit abgelaufenen Tokens finden
+        expired_frames = AnonymousFrame.objects.filter(
+            download_expires_at__lt=timezone.now(),
+            download_token_hash__isnull=False
+        )
+        
+        count = expired_frames.count()
+        expired_frames.update(download_token_hash=None, download_expires_at=None)
+        
+        logger.info(f"Cleaned up {count} expired download tokens")
+        return count
+        
+    except Exception as e:
+        logger.error(f"Error cleaning up expired tokens: {str(e)}")
+        return 0
+
+
+def get_anonymization_statistics(video_id: Optional[int] = None) -> Dict:
+    """
+    Holt Statistiken zur Frame-Anonymisierung.
+    
+    Args:
+        video_id: Optional - Video-ID für spezifische Statistiken
+    
+    Returns:
+        Dict mit Statistiken
+    """
+    try:
+        from endoreg_db.models import FrameAnonymizationRequest, AnonymousFrame
+        from django.db.models import Count, Q
+        
+        # Basis-Queryset
+        requests_qs = FrameAnonymizationRequest.objects.all()
+        frames_qs = AnonymousFrame.objects.all()
+        
+        if video_id:
+            requests_qs = requests_qs.filter(video_file_id=video_id)
+            frames_qs = frames_qs.filter(video_file_id=video_id)
+        
+        # Request-Statistiken
+        request_stats = requests_qs.aggregate(
+            total_requests=Count('id'),
+            pending_requests=Count('id', filter=Q(status='pending')),
+            processing_requests=Count('id', filter=Q(status='processing')),
+            completed_requests=Count('id', filter=Q(status='completed')),
+            failed_requests=Count('id', filter=Q(status='failed'))
+        )
+        
+        # Frame-Statistiken
+        frame_stats = frames_qs.aggregate(
+            total_frames=Count('id'),
+            faces_anonymized=Count('id', filter=Q(anonymization_level='faces')),
+            full_anonymized=Count('id', filter=Q(anonymization_level='full')),
+            minimal_anonymized=Count('id', filter=Q(anonymization_level='minimal'))
+        )
+        
+        # Disk-Space Statistiken
+        total_size = 0
+        for frame in frames_qs.values_list('anonymized_frame_path', flat=True):
+            file_info = get_frame_file_info(frame)
+            if file_info:
+                total_size += file_info['size_bytes']
+        
+        return {
+            'requests': request_stats,
+            'frames': frame_stats,
+            'storage': {
+                'total_size_bytes': total_size,
+                'total_size_mb': round(total_size / (1024 * 1024), 2)
+            },
+            'video_id': video_id
+        }
+        
+    except Exception as e:
+        logger.error(f"Error getting anonymization statistics: {str(e)}")
+        return {
+            'requests': {},
+            'frames': {},
+            'storage': {},
+            'error': str(e)
+        }
+
+
+def validate_frame_path(frame_path: str) -> bool:
+    """
+    Validiert einen Frame-Pfad auf Sicherheit.
+    
+    Args:
+        frame_path: Zu validierender Pfad
+    
+    Returns:
+        True wenn Pfad sicher ist
+    """
+    try:
+        path = Path(frame_path).resolve()
+        
+        # Basis-Verzeichnisse definieren
+        allowed_dirs = [
+            Path(settings.MEDIA_ROOT).resolve(),
+            Path(getattr(settings, 'FRAME_STORAGE_ROOT', '/tmp')).resolve()
+        ]
+        
+        # Prüfen ob Pfad in erlaubten Verzeichnissen liegt
+        for allowed_dir in allowed_dirs:
+            try:
+                path.relative_to(allowed_dir)
+                return True
+            except ValueError:
+                continue
+        
+        logger.warning(f"Frame path outside allowed directories: {frame_path}")
+        return False
+        
+    except Exception as e:
+        logger.error(f"Error validating frame path {frame_path}: {str(e)}")
+        return False
+
+
+def get_video_frame_count(video_id: int) -> int:
+    """
+    Ermittelt die Anzahl verfügbarer Frames für ein Video.
+    
+    Args:
+        video_id: Video-ID
+    
+    Returns:
+        Anzahl der Frames
+    """
+    try:
+        from endoreg_db.models import VideoFile
+        
+        video = VideoFile.objects.get(id=video_id)
+        
+        if not video.frame_dir:
+            return 0
+        
+        frame_dir = Path(video.frame_dir)
+        if not frame_dir.exists():
+            return 0
+        
+        # Zähle alle Bilddateien
+        frame_count = 0
+        for ext in ['*.jpg', '*.jpeg', '*.png']:
+            frame_count += len(list(frame_dir.glob(ext)))
+        
+        return frame_count
+        
+    except Exception as e:
+        logger.error(f"Error counting frames for video {video_id}: {str(e)}")
+        return 0
+
+
+def format_file_size(size_bytes: int) -> str:
+    """
+    Formatiert Dateigröße in lesbares Format.
+    
+    Args:
+        size_bytes: Größe in Bytes
+    
+    Returns:
+        Formatierte Größe
+    """
+    for unit in ['B', 'KB', 'MB', 'GB']:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.1f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.1f} TB"
+
+
+def log_anonymization_activity(activity_type: str, details: Dict, user_id: Optional[int] = None):
+    """
+    Protokolliert Anonymisierungsaktivitäten für Audit-Zwecke.
+    
+    Args:
+        activity_type: Art der Aktivität
+        details: Details der Aktivität
+        user_id: Optional - Benutzer-ID
+    """
+    try:
+        log_entry = {
+            'timestamp': timezone.now().isoformat(),
+            'activity_type': activity_type,
+            'details': details,
+            'user_id': user_id
+        }
+        
+        logger.info(f"Anonymization activity: {activity_type}", extra=log_entry)
+        
+    except Exception as e:
+        logger.error(f"Error logging anonymization activity: {str(e)}")

endoreg_db/utils/hashs.py

@@ -0,0 +1,153 @@
+import hashlib
+from pathlib import Path
+from datetime import datetime, date
+
+import os
+
+SALT = os.getenv("DJANGO_SALT", "default_salt")
+DJANGO_NAME_SALT = os.environ.get("DJANGO_SALT", "default_salt")
+
+
+def get_video_hash(video_path):
+    """
+    Get the hash of a video file.
+    """
+    # Open the video file in read-binary mode:
+    with open(video_path, "rb") as f:
+        # Create the hash object, passing in the video contents for hashing:
+        hash_object = hashlib.sha256(f.read())
+        # Get the hexadecimal representation of the hash
+        video_hash = hash_object.hexdigest()
+        assert len(video_hash) <= 255, "Hash length exceeds 255 characters"
+
+    return video_hash
+
+
+def get_pdf_hash(pdf_path: Path):
+    """
+    Get the hash of a pdf file.
+    """
+    pdf_hash = None
+
+    # Open the file in binary mode and read its contents
+    with open(pdf_path, "rb") as f:
+        pdf_contents = f.read()
+        # Create a hash object using SHA-256 algorithm
+
+    hash_object = hashlib.sha256(pdf_contents, usedforsecurity=False)
+    # Get the hexadecimal representation of the hash
+    pdf_hash = hash_object.hexdigest()
+    assert len(pdf_hash) <= 255, "Hash length exceeds 255 characters"
+
+    return pdf_hash
+
+
+def _get_date_hash_string(date_obj: date) -> str:
+    # if date is datetime object, convert to date
+    if isinstance(date_obj, datetime):
+        # warnings.warn("Date is a datetime object. Converting to date object.")
+        date_obj = date_obj.date()
+    elif isinstance(date_obj, str):
+        # warnings.warn(f"Date is a string ({date_obj}). Converting to date object.")
+        date_obj = datetime.strptime(date_obj, "%Y-%m-%d").date()
+
+    assert isinstance(date_obj, date), "Date must be a date object"
+    # if date is 1900-01-01, make it an empty string
+    if date_obj == date(1900, 1, 1):
+        date_str = ""
+    else:
+        date_str = date_obj.strftime("%Y-%m-%d")
+
+    return date_str
+
+
+def get_hash_string(
+    first_name: str = "",
+    last_name: str = "",
+    dob: date = date(1900, 1, 1),
+    center_name: str = "",
+    examination_date: date = date(1900, 1, 1),
+    endoscope_sn: str = "",
+    salt: str = "",
+):
+    """
+    Get the string to be hashed for a patient's first name, last name, date of birth, examination date, and endoscope serial number.
+    """
+    if not salt:
+        salt = SALT
+
+    examination_date_str = _get_date_hash_string(examination_date)
+    dob_str = _get_date_hash_string(dob)
+
+    # Concatenate the patient's first name, last name, date of birth, examination date, endoscope serial number, and salt:
+    hash_str = f"{first_name}{last_name}{dob_str}{center_name}{dob_str}{examination_date_str}{endoscope_sn}{salt}"
+    return hash_str
+
+
+def get_patient_hash(
+    first_name: str, last_name: str, dob: date, center: str, salt: str = ""
+):
+    """
+    Get the hash of a patient's first name, last name, and date of birth.
+    """
+    # Concatenate the patient's first name, last name, date of birth, and salt:
+    hash_str = get_hash_string(
+        first_name=first_name,
+        last_name=last_name,
+        dob=dob,
+        center_name=center,
+        salt=salt,
+    )
+    # Create a hash object using SHA-256 algorithm
+    hash_object = hashlib.sha256(hash_str.encode())
+    # Get the hexadecimal representation of the hash
+    patient_hash = hash_object.hexdigest()
+
+    return patient_hash
+
+
+def get_patient_examination_hash(
+    first_name: str,
+    last_name: str,
+    dob: date,
+    center: str,
+    examination_date: date,
+    salt: str = "",
+):
+    """
+    Get the hash of a patient's first name, last name, date of birth, and examination date.
+    """
+    # Concatenate the patient's first name, last name, date of birth, examination date, and salt:
+    hash_str = get_hash_string(
+        first_name=first_name,
+        last_name=last_name,
+        center_name=center,
+        dob=dob,
+        examination_date=examination_date,
+        salt=salt,
+    )
+    # Create a hash object using SHA-256 algorithm
+    hash_object = hashlib.sha256(hash_str.encode())
+    # Get the hexadecimal representation of the hash
+    patient_examination_hash = hash_object.hexdigest()
+
+    return patient_examination_hash
+
+
+def get_examiner_hash(first_name, last_name, center_name, salt):
+    """
+    Get the hash of an examiner's first name, last name, and center name.
+    """
+    # Concatenate the examiner's first name, last name, center name, and salt:
+    hash_str = get_hash_string(
+        first_name=first_name,
+        last_name=last_name,
+        center_name=center_name,
+        salt=salt,
+    )
+    # Create a hash object using SHA-256 algorithm
+    hash_object = hashlib.sha256(hash_str.encode())
+    # Get the hexadecimal representation of the hash
+    examiner_hash = hash_object.hexdigest()
+
+    return examiner_hash