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

endoreg_db/utils/ai/multilabel_classification_net.py

@@ -91,7 +91,9 @@ class MultiLabelClassificationNet(LightningModule):
         if track_hparams:
             self.save_hyperparameters()
         if labels is None:
-            raise ValueError("labels must be provided to initialize MultiLabelClassificationNet")
+            raise ValueError(
+                "labels must be provided to initialize MultiLabelClassificationNet"
+            )
 
         self.model_type = model_type
         self.labels = list(labels)
@@ -135,13 +137,23 @@ class MultiLabelClassificationNet(LightningModule):
             strict = kwargs.pop("strict", True)
             labels = kwargs.pop("labels", None)
             if not labels:
-                raise ValueError("labels must be provided when loading .safetensors checkpoints")
+                raise ValueError(
+                    "labels must be provided when loading .safetensors checkpoints"
+                )
             model_type = kwargs.pop("model_type", None) or "EfficientNetB4"
             load_imagenet = kwargs.pop("load_imagenet_weights", False)
 
-            device = torch.device(map_location) if map_location is not None else torch.device("cpu")
+            device = (
+                torch.device(map_location)
+                if map_location is not None
+                else torch.device("cpu")
+            )
             if isinstance(device, torch.device):
-                device_hint = f"{device.type}:{device.index}" if device.index is not None else device.type
+                device_hint = (
+                    f"{device.type}:{device.index}"
+                    if device.index is not None
+                    else device.type
+                )
             else:
                 device_hint = device
 
@@ -160,7 +172,9 @@ class MultiLabelClassificationNet(LightningModule):
             if missing:
                 logger.warning("Missing parameters when loading %s: %s", path, missing)
             if unexpected:
-                logger.warning("Unexpected parameters when loading %s: %s", path, unexpected)
+                logger.warning(
+                    "Unexpected parameters when loading %s: %s", path, unexpected
+                )
 
             instance.to(device)
             return instance
@@ -245,7 +259,8 @@ class MultiLabelClassificationNet(LightningModule):
             self.parameters(), self.lr, momentum=0.5, weight_decay=self.weight_decay
         )
         lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(
-            optimizer, T_0=20,
+            optimizer,
+            T_0=20,
         )
 
         return {

endoreg_db/utils/ai/predict.py

@@ -85,11 +85,11 @@ class Classifier:
         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
@@ -107,10 +107,10 @@ class Classifier:
                 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)

endoreg_db/utils/ai/preprocess.py

@@ -1,6 +1,7 @@
 import numpy as np
 from PIL import Image, ImageOps  # Import the required modules from Pillow
 
+
 def crop_img(img, crop):
     """
     Crops the image based on the specified dimensions and adds padding to maintain aspect ratio.
@@ -15,21 +16,26 @@ def crop_img(img, crop):
     # Convert crop dimensions to Pillow format: left, upper, right, lower
     ymin, ymax, xmin, xmax = crop
     img_cropped = img.crop((xmin, ymin, xmax, ymax))
-    
+
     # Calculate the new size and the required padding
     width, height = img_cropped.size
     delta = width - height
-    
+
     if delta > 0:
-        padding = (0, abs(delta) // 2, 0, abs(delta) - abs(delta) // 2)  # (left, top, right, bottom)
+        padding = (
+            0,
+            abs(delta) // 2,
+            0,
+            abs(delta) - abs(delta) // 2,
+        )  # (left, top, right, bottom)
     elif delta < 0:
         padding = (abs(delta) // 2, 0, abs(delta) - abs(delta) // 2, 0)
     else:
         padding = (0, 0, 0, 0)
-    
+
     # Pad the image to make it square
     img_padded = ImageOps.expand(img_cropped, padding)
-    
+
     return img_padded
 
 
@@ -37,7 +43,9 @@ class Cropper:
     def __init__(self):
         pass
 
-    def __call__(self, img, crop=None, scale=None, scale_method=Image.Resampling.LANCZOS):
+    def __call__(
+        self, img, crop=None, scale=None, scale_method=Image.Resampling.LANCZOS
+    ):
         """
         Applies cropping and scaling transformations to the input image.
 
@@ -52,17 +60,17 @@ class Cropper:
         """
         # Convert numpy array to PIL Image if necessary
         if isinstance(img, np.ndarray):
-            img = Image.fromarray(img.astype('uint8'), 'RGB')
-        
+            img = Image.fromarray(img.astype("uint8"), "RGB")
+
         if crop is not None:
             img = crop_img(img, crop)
         else:
             raise Exception("Automatic crop detection not implemented yet")
-        
+
         if scale is not None:
             img = img.resize(scale, resample=scale_method)
-        
+
         # Convert PIL Image back to numpy array
         img = np.array(img)
-        
+
         return img

endoreg_db/utils/calc_duration_seconds.py

@@ -4,7 +4,7 @@ if TYPE_CHECKING:
     from endoreg_db.models import VideoFile
 
 
-def _calc_duration_vf(obj:"VideoFile") -> float:
+def _calc_duration_vf(obj: "VideoFile") -> float:
     """
     Calculate duration of a VideoFile.
     """
@@ -12,13 +12,13 @@ def _calc_duration_vf(obj:"VideoFile") -> float:
         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
+    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}. "
+            f"Invalid duration calculated for video {obj.video_hash}: {duration}. "
             "Ensure the video file is valid and accessible."
-        )
+        )

endoreg_db/utils/case_generator/lab_sample_factory.py

@@ -1,6 +1,7 @@
 from datetime import datetime, timezone
 from endoreg_db.models import Patient, PatientLabSample, PatientLabSampleType
 
+
 class LabSampleFactory:
     """
     Provides methods to generate lab samples.
@@ -25,9 +26,7 @@ class LabSampleFactory:
         sample_type = PatientLabSampleType.objects.get(name="generic")
 
         lab_sample = PatientLabSample.objects.create(
-            patient=patient,
-            sample_type=sample_type,
-            date=datetime.now(tz=timezone.utc)
+            patient=patient, sample_type=sample_type, date=datetime.now(tz=timezone.utc)
         )
 
-        return lab_sample
+        return lab_sample

endoreg_db/utils/check_video_files.py

@@ -3,146 +3,173 @@
 Simple video file existence checker and path corrector for VideoFile records.
 """
 
+import argparse
 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)')
+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)
+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']:
+
+    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:
+        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"
-        
+
+        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}")
-            
+            print("📋 Video ID 5 found in database:")
+            print(f"   UUID: {video_5.video_hash}")
+
             # Check different file path attributes
-            for attr in ['raw_file', 'processed_file']:
+            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)
+                            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)
+            uuid_str = str(video_5.video_hash)
             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("\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()")
+                print("\n🐍 Django command to fix:")
+                print("   video = VideoFile.objects.get(pk=5)")
+                print(
+                    f"   video.raw_file.name = '{matching_files[0].relative_to(Path(args.storage_dir))}'"
+                )
+                print("   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("\n4. 🎯 QUICK TEST RECOMMENDATION:")
+    print("   Use this accessible file for testing:")
     print(f"   {accessible_files[0]}")
-    print(f"   Size: {accessible_files[0].stat().st_size / (1024*1024):.1f} MB")
+    print(f"   Size: {accessible_files[0].stat().st_size / (1024 * 1024):.1f} MB")
+
 
 if __name__ == "__main__":
-    main()
+    main()

endoreg_db/utils/cropping.py

@@ -1,29 +1,30 @@
 from PIL import Image
 
-def crop_and_insert(image:Image, x, y, h, w, bg_color=(255, 255, 255)):
+
+def crop_and_insert(image: Image, x, y, h, w, bg_color=(255, 255, 255)):
     """
     Crops a region from an inverted grayscale image and inserts it into a white image of the same size as the original.
-    
+
     Parameters:
     - fp: File path or a file object of the original image.
     - x, y: The top-left coordinates of the rectangle to be cropped.
     - h, w: The height and width of the rectangle to be cropped.
-    
+
     Returns:
     A PIL Image object containing the original image with the specified region replaced.
     """
     # Load the original image
     original_image = image
-    
+
     # Crop the specified region from the inverted image
     crop_rectangle = (x, y, x + w, y + h)
     cropped_content = original_image.crop(crop_rectangle)
-    
+
     # Create a new white image of the same size as the original image
-    white_background = Image.new('RGB', original_image.size, bg_color)
-    
+    white_background = Image.new("RGB", original_image.size, bg_color)
+
     # Paste the cropped content onto the white image at the specified location
     white_background.paste(cropped_content, (x, y))
-    
+
     # The final image can be displayed or saved as needed
-    return white_background
+    return white_background

endoreg_db/utils/dataloader.py

@@ -122,7 +122,9 @@ def load_data_with_foreign_keys(
             requirement_types = fields.get("requirement_types", [])
 
             if not requirement_types:
-                raise ValueError(f"Requirement '{name}' must define at least one requirement_types entry.")
+                raise ValueError(
+                    f"Requirement '{name}' must define at least one requirement_types entry."
+                )
 
         ####################
         # TODO REMOVE AFTER TRANSLATION SUPPORT IS ADDED
@@ -265,7 +267,9 @@ def load_data_with_foreign_keys(
             obj, created = _save_instance()
 
         if created and verbose:
-            command.stdout.write(command.style.SUCCESS(f"Created {model.__name__} {name}"))
+            command.stdout.write(
+                command.style.SUCCESS(f"Created {model.__name__} {name}")
+            )
         elif verbose:
             pass
 
@@ -274,4 +278,8 @@ def load_data_with_foreign_keys(
             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}"))
+                    command.stdout.write(
+                        command.style.SUCCESS(
+                            f"Set {len(related_objs)} {field_name} for {model.__name__} {name}"
+                        )
+                    )

endoreg_db/utils/dates.py

@@ -2,7 +2,6 @@ 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"
@@ -45,16 +44,16 @@ 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

endoreg_db/utils/defaults/set_default_center.py

@@ -1,5 +1,4 @@
 import subprocess
-from endoreg_db.models.administration.center import center
 
 # Start process with interactive pipes
 proc = subprocess.Popen(
@@ -8,7 +7,7 @@ proc = subprocess.Popen(
     stdout=subprocess.PIPE,
     stderr=subprocess.STDOUT,
     text=True,
-    bufsize=1
+    bufsize=1,
 )
 
 proc.stdin.write("print('Trying to extract...')\n")
@@ -17,11 +16,13 @@ proc.stdin.flush()
 try:
     subprocess.run(["python", "manage.py", "load_center_data"], check=True)
     proc.stdout.write("print('found center')")
-except subprocess.CalledProcessError as e:
-    proc.stdout.write("print('Didn't find center. Please add it to endoreg_db luxnix or via export DEFAULT_CENTER")
+except subprocess.CalledProcessError:
+    proc.stdout.write(
+        "print('Didn't find center. Please add it to endoreg_db luxnix or via export DEFAULT_CENTER"
+    )
 # """
 # Future Implementation using dialogue
-#"""
+# """
 # # Send commands as if from terminal
 # proc.stdin.write("print('You dont have a default center set up yet. Please enter one here.')\n\nprint('Rule: use_this_format_and_connect_words_with_underscore')")
 # proc.stdin.flush()
@@ -29,4 +30,4 @@ except subprocess.CalledProcessError as e:
 # # Read responses
 # for _ in range(3):
 #     line = proc.stdout.readline()
-#     print("Selected >>", line.strip())
+#     print("Selected >>", line.strip())

endoreg_db/utils/env.py

@@ -2,6 +2,7 @@ import os
 
 DEBUG = os.getenv("DEBUG", "false").lower() == "true"
 
+
 def get_env_var(var_name: str, default: str = None) -> str | None:
     """
     Get the value of an environment variable, with an optional default value.
@@ -13,12 +14,13 @@ def get_env_var(var_name: str, default: str = None) -> str | None:
     """
     value = os.environ.get(var_name)
     if value:
-        value = value.strip('"\'')  # Strip both single and double quotes
+        value = value.strip("\"'")  # Strip both single and double quotes
         if DEBUG:
             print(f"Environment variable {var_name}: {value}")
         return value
     return default
 
+
 def set_env_var(var_name: str, value: str) -> None:
     """
     Set the value of an environment variable.
@@ -29,5 +31,7 @@ def set_env_var(var_name: str, value: str) -> None:
     if DEBUG:
         print(f"Set environment variable {var_name}: {value}")
 
-DJANGO_SETTINGS_MODULE = get_env_var("DJANGO_SETTINGS_MODULE") or "endoreg_db.settings_dev"
 
+DJANGO_SETTINGS_MODULE = (
+    get_env_var("DJANGO_SETTINGS_MODULE") or "endoreg_db.settings_dev"
+)

endoreg_db/utils/extract_specific_frames.py

@@ -1,13 +1,14 @@
 from pathlib import Path
 import shutil
 
+
 def extract_selected_frames(
     video_path: Path,
     frame_numbers: list,
     output_dir: Path,
     fps: int = 50,
     quality: int = 2,
-    ext: str = "png"
+    ext: str = "png",
 ):
     """
     Extract specific frames from a video using the same quality logic as the original extractor.
@@ -43,12 +44,21 @@ def extract_selected_frames(
             timestamp=timestamp_sec,
             output_path=str(output_file),
             quality=quality,
-            ext=ext
+            ext=ext,
         )
+
+
 import subprocess
 from pathlib import Path
 
-def extract_single_frame(input_path: str, timestamp: float, output_path: str, quality: int = 2, ext: str = "png"):
+
+def extract_single_frame(
+    input_path: str,
+    timestamp: float,
+    output_path: str,
+    quality: int = 2,
+    ext: str = "png",
+):
     """
     Extract a single frame from a video using ffmpeg.
 
@@ -61,12 +71,17 @@ def extract_single_frame(input_path: str, timestamp: float, output_path: str, qu
     """
     cmd = [
         "ffmpeg",
-        "-loglevel", "error",
-        "-ss", f"{timestamp:.3f}",
-        "-i", str(input_path),
-        "-frames:v", "1",
-        "-q:v", str(quality),
-        str(output_path)
+        "-loglevel",
+        "error",
+        "-ss",
+        f"{timestamp:.3f}",
+        "-i",
+        str(input_path),
+        "-frames:v",
+        "1",
+        "-q:v",
+        str(quality),
+        str(output_path),
     ]
 
     subprocess.run(cmd, check=True)