endoreg-db 0.6.3__py3-none-any.whl → 0.8.1__py3-none-any.whl

endoreg_db/utils/ai/predict.py

@@ -0,0 +1,291 @@
+"""
+This module contains the Classifier class for making predictions using a trained model.
+"""
+
+import json
+import torch
+from torch.utils.data import DataLoader
+from torch import nn
+import numpy as np
+from tqdm import tqdm
+from icecream import ic
+from .inference_dataset import InferenceDataset
+from .postprocess import concat_pred_dicts, make_smooth_preds, find_true_pred_sequences
+
+sample_config = {
+    # mean and std for normalization
+    "mean": (0.45211223, 0.27139644, 0.19264949),
+    "std": (0.31418097, 0.21088019, 0.16059452),
+    # Image Size
+    "size_x": 716,
+    "size_y": 716,
+    # how to wrangle axes of the image before putting them in the network
+    "axes": [2, 0, 1],  # 2,1,0 for opencv
+    "batchsize": 16,
+    "num_workers": 0,  # always 1 for Windows systems # FIXME: fix celery crash if multiprocessing
+    # maybe add sigmoid after prediction?
+    "activation": nn.Sigmoid(),
+    "labels": [
+        "appendix",
+        "blood",
+        "diverticule",
+        "grasper",
+        "ileocaecalvalve",
+        "ileum",
+        "low_quality",
+        "nbi",
+        "needle",
+        "outside",
+        "polyp",
+        "snare",
+        "water_jet",
+        "wound",
+    ],
+}
+
+
+class Classifier:
+    def __init__(self, model=None, config=None, verbose=False):
+        if config is None:
+            config = sample_config.copy()
+        self.config = config
+        self.model = model
+        self.verbose = verbose
+
+    def pipe(self, paths, crops, verbose=None):
+        """
+        Processes input data through the model pipeline and returns predictions.
+        Args:
+            paths (list): List of file paths to the input data.
+            crops (list): List of crop regions for the input data.
+            verbose (bool, optional): If True, prints detailed logs. Defaults to None.
+        Returns:
+            list: Predictions generated by the model.
+        """
+
+        if verbose is None:
+            verbose = self.verbose
+
+        dataset = InferenceDataset(paths, crops, self.config)
+        if verbose:
+            ic("Dataset created")
+
+        dl = DataLoader(
+            dataset=dataset,
+            batch_size=self.config["batchsize"],
+            num_workers=self.config["num_workers"],
+            shuffle=False,
+            pin_memory=True,
+        )
+        if verbose:
+            ic("Dataloader created")
+
+        predictions = []
+
+        with torch.inference_mode():
+            if self.verbose:
+                ic("Starting inference")
+                
+            # Ensure model exists
+            if self.model is None:
+                raise ValueError("Model is not loaded")
+            
+            # Use the device the model is currently on, with fallback to CPU
+            try:
+                # Check what device the model parameters are on
+                model_device = next(self.model.parameters()).device
+                device = model_device
+                if verbose:
+                    print(f"Using device: {device}")
+            except StopIteration:
+                # Model has no parameters, default to CPU
+                device = torch.device("cpu")
+                if verbose:
+                    print("Model has no parameters, defaulting to CPU")
+            except Exception as e:
+                # Any other issue, fall back to CPU
+                device = torch.device("cpu")
+                if verbose:
+                    print(f"Device detection failed, using CPU: {e}")
+                    
+            # Ensure model is in eval mode
+            self.model.eval()
+            
+            for batch in tqdm(dl):
+                batch = batch.to(device, non_blocking=True)
+                prediction = self.model(batch)
+                prediction = (
+                    self.config["activation"](prediction).cpu().tolist()
+                )  # .numpy().tolist()
+                predictions += prediction
+
+        return predictions
+
+    def __call__(self, image, crop=None):
+        return self.pipe([image], [crop])
+
+    def readable(self, predictions):
+        """
+        Converts a list of predictions into a readable dictionary format.
+        Args:
+            predictions (list): A list of prediction values.
+        Returns:
+            dict: A dictionary where the keys are labels from the configuration
+                  and the values are the corresponding predictions. If a prediction
+                  value is of type numpy.int64, it is converted to a standard int.
+        """
+        readable_dict = {
+            label: prediction
+            for label, prediction in zip(self.config["labels"], predictions)
+        }
+
+        # when dumping to json we need to convert numpy.int64 to int
+        readable_dict = {
+            key: int(value) if isinstance(value, np.int64) else value
+            for key, value in readable_dict.items()
+        }
+
+        return readable_dict
+
+    def get_prediction_dict(self, predictions, paths):
+        """
+        Constructs a dictionary containing prediction results.
+        Args:
+            predictions (list): A list of prediction results.
+            paths (list): A list of paths corresponding to the predictions.
+        Returns:
+            dict: A dictionary with the following keys:
+                - "labels": The labels from the configuration.
+                - "paths": The provided paths.
+                - "predictions": The provided predictions.
+        """
+
+        json_dict = {
+            "labels": self.config["labels"],
+            "paths": paths,
+            "predictions": predictions,
+        }
+
+        return json_dict
+
+    def get_prediction_json(self, predictions, paths, json_target_path: str = None):
+        """
+        Saves predictions to a JSON file.
+
+        Args:
+            predictions (list): A list of prediction results.
+            paths (list): A list of paths corresponding to the predictions.
+            json_target_path (str, optional): The path to save the JSON file. Defaults to None.
+        """
+        if not json_target_path:
+            json_target_path = "predictions.json"
+
+        json_dict = self.get_prediction_dict(predictions, paths)
+
+        with open(json_target_path, "w", encoding="utf-8") as f:
+            json.dump(json_dict, f)
+
+        if self.verbose:
+            ic(f"Saved predictions to {json_target_path}")
+
+    def post_process_predictions(
+        self, pred_dicts, window_size_s=1, fps=50, min_seq_len_s=0.5
+    ):
+        """
+        pred_dicts: list of dictionaries with the same keys
+        window_size_s: size of the window in seconds for smoothing
+        fps: frames per second
+        min_seq_len_s: minimum length of a sequence in seconds
+
+        Returns:
+        predictions: concatenated predictions
+        smooth_predictions: smoothed predictions
+        binary_predictions: binary predictions
+        raw_sequences: raw sequences
+        filtered_sequences: filtered sequences
+        """
+        # Concatenate the predictions
+        predictions = concat_pred_dicts(pred_dicts)
+
+        smooth_predictions = {key: [] for key in predictions.keys()}
+        for key in predictions.keys():
+            smooth_predictions[key] = make_smooth_preds(
+                predictions[key], window_size_s=window_size_s, fps=fps
+            )
+
+        binary_predictions = {}
+        for key in smooth_predictions.keys():
+            binary_predictions[key] = np.array(
+                [p > 0.5 for p in smooth_predictions[key]]
+            )
+
+        raw_sequences = {}
+        for key, value in binary_predictions.items():
+            raw_sequences[key] = find_true_pred_sequences(value)
+
+        filtered_sequences = {}
+        min_seq_len = int(min_seq_len_s * fps)
+        for key, sequences in raw_sequences.items():
+            filtered_sequences[key] = [
+                s for s in sequences if s[1] - s[0] > min_seq_len
+            ]
+
+        return (
+            predictions,
+            smooth_predictions,
+            binary_predictions,
+            raw_sequences,
+            filtered_sequences,
+        )
+
+    def post_process_predictions_serializable(
+        self, pred_dicts, window_size_s=1, fps=50, min_seq_len_s=0.5
+    ):
+        """
+        Post-processes prediction dictionaries to make them serializable.
+        This method takes prediction dictionaries, processes them to ensure all
+        elements are serializable (e.g., converting numpy arrays to lists), and
+        organizes the results into a dictionary of dictionaries.
+        Args:
+            pred_dicts (list): List of prediction dictionaries.
+            window_size_s (int, optional): Window size in seconds. Defaults to 1.
+            fps (int, optional): Frames per second. Defaults to 50.
+            min_seq_len_s (float, optional): Minimum sequence length in seconds. Defaults to 0.5.
+        Returns:
+            dict: A dictionary containing processed prediction results with the following keys:
+                - "predictions": Processed predictions.
+                - "smooth_predictions": Smoothed predictions.
+                - "binary_predictions": Binary predictions.
+                - "raw_sequences": Raw sequences.
+                - "filtered_sequences": Filtered sequences.
+        """
+
+        result = self.post_process_predictions(
+            pred_dicts, window_size_s, fps, min_seq_len_s
+        )
+
+        for i, _dict in enumerate(result):
+            _keys = list(_dict.keys())
+            for key in _keys:
+                # if numpy array
+                if hasattr(_dict[key], "tolist"):
+                    result[i][key] = _dict[key].tolist()
+
+                # check if list of tuples
+                # if so, make sure each tuple has 2 elements and split to two lists (start, stop)
+                if all(isinstance(x, tuple) for x in _dict[key]):
+                    if all(len(x) == 2 for x in _dict[key]):
+                        result[i][f"{key}_start"] = [int(x[0]) for x in _dict[key]]
+                        result[i][f"{key}_stop"] = [int(x[1]) for x in _dict[key]]
+                        del result[i][key]
+
+        # make dict of dicts
+        result_dict = {
+            "predictions": result[0],
+            "smooth_predictions": result[1],
+            "binary_predictions": result[2],
+            "raw_sequences": result[3],
+            "filtered_sequences": result[4],
+        }
+
+        return result_dict

endoreg_db/{models/ai_model/lightning → utils/ai}/preprocess.py

@@ -65,4 +65,4 @@ class Cropper:
         # Convert PIL Image back to numpy array
         img = np.array(img)
         
-        return img
+        return img

endoreg_db/utils/calc_duration_seconds.py

@@ -0,0 +1,24 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from endoreg_db.models import VideoFile
+
+
+def _calc_duration_vf(obj:"VideoFile") -> float:
+    """
+    Calculate duration of a VideoFile.
+    """
+    if not obj.ffmpeg_meta:
+        raise ValueError("ffmpeg_meta is missing, cannot calculate duration.")
+
+    fps = obj.get_fps()
+    frame_count = obj.frame_count #TODO similar implementation as in get_fps
+
+    duration = frame_count / fps if fps > 0 else -1
+    if duration > 0:
+        return duration
+    else:
+        raise ValueError(
+            f"Invalid duration calculated for video {obj.uuid}: {duration}. "
+            "Ensure the video file is valid and accessible."
+        )

endoreg_db/utils/check_video_files.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Simple video file existence checker and path corrector for VideoFile records.
+"""
+
+import os
+import sys
+from pathlib import Path
+import argparse
+
+# Parse command-line arguments and environment variables for configuration
+parser = argparse.ArgumentParser(description="Simple video file existence checker and path corrector for VideoFile records.")
+parser.add_argument('--django-base', type=str, default=os.environ.get('ENDOREG_DJANGO_PROJECT_PATH', str(Path(__file__).resolve().parent.parent.parent)),
+                    help='Path to the Django project base (default: env ENDOREG_DJANGO_PROJECT_PATH or project root)')
+parser.add_argument('--django-settings', type=str, default=os.environ.get('DJANGO_SETTINGS_MODULE', 'dev.dev_settings'),
+                    help='Django settings module (default: env DJANGO_SETTINGS_MODULE or dev.dev_settings)')
+parser.add_argument('--storage-dir', type=str, default=os.environ.get('ENDOREG_STORAGE_DIR', './storage'),
+                    help='Path to the storage directory (default: ./storage or $ENDOREG_STORAGE_DIR)')
+args, unknown = parser.parse_known_args()
+
+sys.path.insert(0, args.django_base)
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', args.django_settings)
+
+try:
+    import django
+    django.setup()
+    from endoreg_db.models import VideoFile
+    DJANGO_AVAILABLE = True
+except Exception as e:
+    print(f"Django not available: {e}")
+    DJANGO_AVAILABLE = False
+
+def find_video_files():
+    """Find all video files in storage directory."""
+    storage_dir = Path(args.storage_dir)
+    video_files = []
+    
+    for pattern in ['**/*.mp4', '**/*.avi', '**/*.mov', '**/*.mkv']:
+        video_files.extend(storage_dir.glob(pattern))
+    
+    return video_files
+
+def check_video_file_accessibility(file_path):
+    """Check if a video file is accessible and valid."""
+    try:
+        if not file_path.exists():
+            return False, "File does not exist"
+        
+        if file_path.stat().st_size == 0:
+            return False, "File is empty (0 bytes)"
+        
+        if not os.access(file_path, os.R_OK):
+            return False, "File is not readable"
+        
+        # Try to read first few bytes to check if it's actually a file
+        with open(file_path, 'rb') as f:
+            header = f.read(8)
+            if len(header) < 8:
+                return False, "File too small or corrupted"
+        
+        return True, f"OK - {file_path.stat().st_size / (1024*1024):.1f} MB"
+        
+    except Exception as e:
+        return False, f"Error checking file: {e}"
+
+def main():
+    print("🔍 VIDEO FILE EXISTENCE CHECKER")
+    print("=" * 40)
+    
+    # Find all video files
+    print("1. Scanning for video files...")
+    video_files = find_video_files()
+    print(f"Found {len(video_files)} video files in storage directory")
+    
+    if not video_files:
+        print("❌ No video files found in storage directory!")
+        return
+    
+    # Check each file
+    print("\n2. Checking file accessibility...")
+    accessible_files = []
+    
+    for video_file in video_files[:10]:  # Check first 10
+        accessible, message = check_video_file_accessibility(video_file)
+        status = "✅" if accessible else "❌"
+        print(f"{status} {video_file.name}: {message}")
+        
+        if accessible:
+            accessible_files.append(video_file)
+    
+    if not accessible_files:
+        print("\n❌ No accessible video files found!")
+        return
+    
+    print(f"\n✅ Found {len(accessible_files)} accessible video files")
+    
+    # If Django is available, check database records
+    if DJANGO_AVAILABLE:
+        print("\n3. Checking database records...")
+        try:
+            video_5 = VideoFile.objects.get(pk=5)
+            print(f"📋 Video ID 5 found in database:")
+            print(f"   UUID: {video_5.uuid}")
+            
+            # Check different file path attributes
+            for attr in ['raw_file', 'processed_file']:
+                if hasattr(video_5, attr):
+                    file_field = getattr(video_5, attr)
+                    if file_field:
+                        try:
+                            file_path = Path(file_field.path)
+                            accessible, message = check_video_file_accessibility(file_path)
+                            status = "✅" if accessible else "❌"
+                            print(f"   {attr}: {status} {file_path} ({message})")
+                        except Exception as e:
+                            print(f"   {attr}: ❌ Error accessing path: {e}")
+                    else:
+                        print(f"   {attr}: ❌ No file set")
+            
+            # Check if UUID matches any found files
+            uuid_str = str(video_5.uuid)
+            matching_files = [f for f in accessible_files if uuid_str in str(f)]
+            
+            if matching_files:
+                print(f"\n💡 Found matching files for UUID {uuid_str}:")
+                for match in matching_files:
+                    accessible, message = check_video_file_accessibility(match)
+                    print(f"   ✅ {match} ({message})")
+                    
+                print(f"\n🔧 SOLUTION: Update VideoFile record to use:")
+                print(f"   {matching_files[0]}")
+                print(f"\n🐍 Django command to fix:")
+                print(f"   video = VideoFile.objects.get(pk=5)")
+                print(f"   video.raw_file.name = '{matching_files[0].relative_to(Path(args.storage_dir))}'")
+                print(f"   video.save()")
+            else:
+                print(f"\n❌ No files found matching UUID {uuid_str}")
+                
+        except Exception as e:
+            print(f"❌ Error checking database: {e}")
+    
+    print(f"\n4. 🎯 QUICK TEST RECOMMENDATION:")
+    print(f"   Use this accessible file for testing:")
+    print(f"   {accessible_files[0]}")
+    print(f"   Size: {accessible_files[0].stat().st_size / (1024*1024):.1f} MB")
+
+if __name__ == "__main__":
+    main()

endoreg_db/utils/dataloader.py

@@ -1,8 +1,7 @@
 import os
 import yaml
 from django.core.exceptions import ObjectDoesNotExist
-
-from icecream import ic
+from django.db import OperationalError, transaction
 
 
 def load_model_data_from_yaml(command, model_name, metadata, verbose):
@@ -38,25 +37,53 @@ def load_data_with_foreign_keys(
     command, model, yaml_data, foreign_keys, foreign_key_models, verbose
 ):
     """
-    Load data handling foreign keys and many-to-many relationships.
-
-    Args:
-        command: Command object for stdout writing.
-        model: The Django model for the data.
-        yaml_data: Data loaded from YAML.
-        foreign_keys: List of foreign keys.
-        foreign_key_models: Corresponding models for the foreign keys.
-        verbose: Boolean indicating whether to print verbose output.
+    Load YAML data into Django model instances with FK and M2M support.
+    
+    Processes each YAML entry to create or update a model instance. For each entry, the
+    function extracts field data and uses the presence of a 'name' field to decide whether
+    to update an existing instance or create a new one. Foreign key fields listed in
+    foreign_keys are handled by retrieving related objects via natural keys. When a field
+    contains a list, it is treated as a many-to-many relationship and the corresponding
+    objects are set after the instance is saved. Missing or unresolved foreign keys trigger
+    warnings if verbose output is enabled.
+    
+    Parameters:
+        model: The Django model class representing the data.
+        yaml_data: A list of dictionaries representing YAML entries.
+        foreign_keys: A list of foreign key field names to process from each entry.
+        foreign_key_models: The corresponding Django model classes for each foreign key.
+        verbose: If True, prints detailed output and warnings during processing.
     """
     for entry in yaml_data:
         fields = entry.get("fields", {})
         name = fields.pop("name", None)
+
+
+        ####################
+        #TODO REMOVE AFTER TRANSLATION SUPPORT IS ADDED
+        SKIP_NAMES=[
+            "name_de",  # German name, not used
+            "name_en",  # English name, not used
+            "description_de",  # German description
+            "description_en",  # English description
+        ]
+
+        
+        # Remove fields that are not needed
+        for skip_name in SKIP_NAMES:
+            if skip_name in fields:
+                fields.pop(skip_name)
+        ########################
+
         m2m_relationships = {}  # Store many-to-many relationships
         # print(entry)
 
         # Handle foreign keys and many-to-many relationships
         for fk_field, fk_model in zip(foreign_keys, foreign_key_models):
-            # print(fk_field, fk_model)
+            # Skip fields that are not in the data
+            if fk_field not in fields:
+                continue
+
             target_keys = fields.pop(fk_field, None)
 
             # Ensure the foreign key exists
@@ -73,18 +100,20 @@ def load_data_with_foreign_keys(
             if isinstance(target_keys, list):  # Assume many-to-many relationship
                 related_objects = []
                 for key in target_keys:
-                    obj, created = fk_model.objects.get_or_create(name=key)
-                    if created and verbose:
-                        command.stdout.write(
-                            command.style.SUCCESS(f"Created {fk_model.__name__} {key}")
-                        )
+                    try:
+                        obj = fk_model.objects.get_by_natural_key(key)
+                    except ObjectDoesNotExist:
+                        if verbose:
+                            command.stdout.write(
+                                command.style.WARNING(
+                                    f"{fk_model.__name__} with key {key} not found"
+                                )
+                            )
+                        continue
                     related_objects.append(obj)
                 m2m_relationships[fk_field] = related_objects
             else:  # Single foreign key relationship
                 try:
-                    if model == "endoreg_db.case_template_rule":
-                        # print(fk_model, target_keys)
-                        pass
                     obj = fk_model.objects.get_by_natural_key(target_keys)
                 except ObjectDoesNotExist:
                     if verbose:
@@ -96,23 +125,51 @@ def load_data_with_foreign_keys(
                     continue
                 fields[fk_field] = obj
 
-        # Create or update the main object
-        if name is None:
-            obj, created = model.objects.get_or_create(**fields)
-        else:
-            obj, created = model.objects.update_or_create(defaults=fields, name=name)
+        # Create or update the main object (avoid update_or_create to prevent SQLite locks)
+        def _save_instance():
+            if name is None:
+                # Try to find an existing object by all provided fields
+                obj = model.objects.filter(**fields).first()
+                if obj is None:
+                    obj = model.objects.create(**fields)
+                    created = True
+                else:
+                    created = False
+            else:
+                obj = model.objects.filter(name=name).first()
+                if obj is None:
+                    obj = model.objects.create(name=name, **fields)
+                    created = True
+                else:
+                    # Update fields
+                    for k, v in fields.items():
+                        setattr(obj, k, v)
+                    obj.save()
+                    created = False
+            return obj, created
+
+        try:
+            # Attempt save inside a transaction for consistency
+            with transaction.atomic():
+                obj, created = _save_instance()
+        except OperationalError:
+            # Retry once on SQLite lock
+            obj, created = _save_instance()
+
         if created and verbose:
             command.stdout.write(
                 command.style.SUCCESS(f"Created {model.__name__} {name}")
             )
         elif verbose:
             pass
-            # command.stdout.write(
-            #     command.style.WARNING(
-            #         f"Skipped {model.__name__} {name}, already exists"
-            #     )
-            # )
 
         # Set many-to-many relationships
         for field_name, related_objs in m2m_relationships.items():
-            getattr(obj, field_name).set(related_objs)
+            if related_objs:  # Only set if there are objects to set
+                getattr(obj, field_name).set(related_objs)
+                if verbose:
+                    command.stdout.write(
+                        command.style.SUCCESS(
+                            f"Set {len(related_objs)} {field_name} for {model.__name__} {name}"
+                        )
+                    )

endoreg_db/utils/dates.py

@@ -1,6 +1,8 @@
 from datetime import datetime, date, timedelta
 from random import randint
 from calendar import monthrange
+from django.utils import timezone
+import datetime
 
 # TODO replace used random_day_by_year function implementation when
 # creating pseudo patients with new function "random date by age_at_date and examination_date"
@@ -37,3 +39,22 @@ def random_day_by_month_year(month: int, year) -> date:
 
     day = randint(1, monthrange(year, month)[1])
     return date(year, month, day)
+
+
+def ensure_aware_datetime(dt):
+    """
+    Ensures a datetime object is timezone-aware.
+    If the datetime is naive (has no timezone info), the current timezone is applied.
+    
+    Args:
+        dt: A datetime object that may be naive
+        
+    Returns:
+        A timezone-aware datetime object
+    """
+    if dt is None:
+        return None
+        
+    if isinstance(dt, datetime.datetime) and timezone.is_naive(dt):
+        return timezone.make_aware(dt)
+    return dt