endoreg-db 0.8.3.4__py3-none-any.whl → 0.8.3.7__py3-none-any.whl

endoreg_db/management/commands/create_model_meta_from_huggingface.py

@@ -50,17 +50,11 @@ class Command(BaseCommand):
 
         try:
             # Download the model weights
-            weights_path = hf_hub_download(
-                repo_id=model_id,
-                filename="colo_segmentation_RegNetX800MF_base.ckpt",
-                local_dir="/tmp",
-            )
+            weights_path = hf_hub_download(repo_id=model_id, filename="pytorch_model.bin", local_dir="/tmp")
             self.stdout.write(f"Downloaded weights to: {weights_path}")
 
             # Get or create AI model
-            ai_model, created = AiModel.objects.get_or_create(
-                name=model_name, defaults={"description": f"Model from {model_id}"}
-            )
+            ai_model, created = AiModel.objects.get_or_create(name=model_name, defaults={"description": f"Model from {model_id}"})
             if created:
                 self.stdout.write(f"Created AI model: {ai_model.name}")
 
@@ -68,9 +62,7 @@ class Command(BaseCommand):
             try:
                 labelset = LabelSet.objects.get(name=labelset_name)
             except LabelSet.DoesNotExist:
-                self.stdout.write(
-                    self.style.ERROR(f"LabelSet '{labelset_name}' not found")
-                )
+                self.stdout.write(self.style.ERROR(f"LabelSet '{labelset_name}' not found"))
                 return
 
             # Create ModelMeta
@@ -94,20 +86,13 @@ class Command(BaseCommand):
 
             # Save the weights file to the model
             with open(weights_path, "rb") as f:
-                model_meta.weights.save(
-                    f"{model_name}_v{version}_colo_segmentation_RegNetX800MF_base.ckpt",
-                    ContentFile(f.read()),
-                )
+                model_meta.weights.save(f"{model_name}_v{version}_pytorch_model.bin", ContentFile(f.read()))
 
             # Set as active meta
             ai_model.active_meta = model_meta
             ai_model.save()
 
-            self.stdout.write(
-                self.style.SUCCESS(
-                    f"Successfully {'created' if created else 'updated'} ModelMeta: {model_meta}"
-                )
-            )
+            self.stdout.write(self.style.SUCCESS(f"Successfully {'created' if created else 'updated'} ModelMeta: {model_meta}"))
 
         except Exception as e:
             self.stdout.write(self.style.ERROR(f"Error creating ModelMeta: {e}"))

endoreg_db/models/metadata/model_meta_logic.py

@@ -1,21 +1,21 @@
 import shutil
-from logging import getLogger
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Type
-
-from django.db import transaction
+from typing import Optional, TYPE_CHECKING, Any, Type
 from huggingface_hub import hf_hub_download
+from django.db import transaction
 
 # Assuming ModelMeta, AiModel, LabelSet are importable from the correct locations
 # Adjust imports based on your project structure if necessary
 from ..administration.ai.ai_model import AiModel
 from ..label.label_set import LabelSet
-from ..utils import STORAGE_DIR, WEIGHTS_DIR
+from ..utils import WEIGHTS_DIR, STORAGE_DIR
+
+from logging import getLogger
 
 logger = getLogger("ai_model")
 
 if TYPE_CHECKING:
-    from .model_meta import ModelMeta  # Import ModelMeta for type hinting
+    from .model_meta import ModelMeta # Import ModelMeta for type hinting
 
 
 def get_latest_version_number_logic(
@@ -29,13 +29,13 @@ def get_latest_version_number_logic(
     """
     versions_qs = cls.objects.filter(
         name=meta_name, model__name=model_name
-    ).values_list("version", flat=True)
+    ).values_list('version', flat=True)
 
     max_v = 0
     found_numeric_version = False
 
     for v_str in versions_qs:
-        if v_str is None:  # Skip None versions
+        if v_str is None: # Skip None versions
             continue
         try:
             v_int = int(v_str)
@@ -47,13 +47,13 @@ def get_latest_version_number_logic(
                 f"Warning: Could not parse version string '{v_str}' as an integer for "
                 f"meta_name='{meta_name}', model_name='{model_name}' while determining the max version."
             )
-
+    
     return max_v if found_numeric_version else 0
 
 
 @transaction.atomic
 def create_from_file_logic(
-    cls: Type["ModelMeta"],  # cls is ModelMeta
+    cls: Type["ModelMeta"], # cls is ModelMeta
     meta_name: str,
     model_name: str,
     labelset_name: str,
@@ -94,14 +94,11 @@ def create_from_file_logic(
             )
         elif existing and bump_if_exists:
             target_version = str(latest_version_num + 1)
-            logger.info(
-                f"Bumping version for {meta_name}/{model_name} to {target_version}"
-            )
+            logger.info(f"Bumping version for {meta_name}/{model_name} to {target_version}")
     else:
         target_version = str(latest_version_num + 1)
-        logger.info(
-            f"Setting next version for {meta_name}/{model_name} to {target_version}"
-        )
+        logger.info(f"Setting next version for {meta_name}/{model_name} to {target_version}")
+
 
     # --- Prepare Weights File ---
     source_weights_path = Path(weights_file).resolve()
@@ -111,10 +108,7 @@ def create_from_file_logic(
     # Construct destination path within MEDIA_ROOT/WEIGHTS_DIR
     weights_filename = source_weights_path.name
     # Relative path for the FileField upload_to
-    relative_dest_path = (
-        Path(WEIGHTS_DIR.relative_to(STORAGE_DIR))
-        / f"{meta_name}_v{target_version}_{weights_filename}"
-    )
+    relative_dest_path = Path(WEIGHTS_DIR.relative_to(STORAGE_DIR)) / f"{meta_name}_v{target_version}_{weights_filename}"
     # Full path for shutil.copy
     full_dest_path = STORAGE_DIR / relative_dest_path
 
@@ -131,8 +125,8 @@ def create_from_file_logic(
     # --- Create/Update ModelMeta Instance ---
     defaults = {
         "labelset": label_set,
-        "weights": relative_dest_path.as_posix(),  # Store relative path for FileField
-        **kwargs,  # Pass through other fields like activation, mean, std, etc.
+        "weights": relative_dest_path.as_posix(), # Store relative path for FileField
+        **kwargs, # Pass through other fields like activation, mean, std, etc.
     }
 
     # Remove None values from defaults to avoid overriding model defaults unnecessarily
@@ -158,39 +152,35 @@ def create_from_file_logic(
 
     return model_meta
 
-
 # --- Add other logic functions referenced by ModelMeta here ---
 # (get_latest_version_number_logic, get_activation_function_logic, etc.)
 # Placeholder for get_activation_function_logic
 def get_activation_function_logic(activation_name: str):
-    import torch.nn as nn  # Import locally as it's specific to this function
-
+    import torch.nn as nn # Import locally as it's specific to this function
     if activation_name.lower() == "sigmoid":
         return nn.Sigmoid()
     elif activation_name.lower() == "softmax":
         # Note: Softmax usually requires specifying the dimension
-        return nn.Softmax(dim=1)  # Assuming dim=1 (channels) is common
+        return nn.Softmax(dim=1) # Assuming dim=1 (channels) is common
     elif activation_name.lower() == "none":
         return nn.Identity()
     else:
         # Consider adding more activations or raising an error
         raise ValueError(f"Unsupported activation function: {activation_name}")
 
-
 # Placeholder for get_inference_dataset_config_logic
 def get_inference_dataset_config_logic(model_meta: "ModelMeta") -> dict:
     # This would typically extract relevant fields from model_meta
     # for configuring a dataset during inference
     return {
-        "mean": [float(x) for x in model_meta.mean.split(",")],
-        "std": [float(x) for x in model_meta.std.split(",")],
-        "size_y": model_meta.size_y,  # Add size_y key
-        "size_x": model_meta.size_x,  # Add size_x key
-        "axes": [int(x) for x in model_meta.axes.split(",")],
+        "mean": [float(x) for x in model_meta.mean.split(',')],
+        "std": [float(x) for x in model_meta.std.split(',')],
+        "size_y": model_meta.size_y, # Add size_y key
+        "size_x": model_meta.size_x, # Add size_x key
+        "axes": [int(x) for x in model_meta.axes.split(',')],
         # Add other relevant config like normalization type, etc.
     }
 
-
 # Placeholder for get_config_dict_logic
 def get_config_dict_logic(model_meta: "ModelMeta") -> dict:
     # Returns a dictionary representation of the model's configuration
@@ -212,7 +202,6 @@ def get_config_dict_logic(model_meta: "ModelMeta") -> dict:
         # Add any other relevant fields
     }
 
-
 # Placeholder for get_model_meta_by_name_version_logic
 def get_model_meta_by_name_version_logic(
     cls: Type["ModelMeta"],
@@ -238,23 +227,16 @@ def get_model_meta_by_name_version_logic(
             ) from exc
     else:
         # Get latest version
-        latest = (
-            cls.objects.filter(name=meta_name, model=ai_model)
-            .order_by("-date_created")
-            .first()
-        )
+        latest = cls.objects.filter(name=meta_name, model=ai_model).order_by("-date_created").first()
         if latest:
             return latest
         else:
             raise cls.DoesNotExist(
                 f"No ModelMeta found for '{meta_name}' and model '{model_name}'."
             )
-
-
-import re
-
+            
 from huggingface_hub import model_info
-
+import re
 
 def infer_default_model_meta_from_hf(model_id: str) -> dict[str, Any]:
     """
@@ -266,9 +248,7 @@ def infer_default_model_meta_from_hf(model_id: str) -> dict[str, Any]:
     """
 
     if not (info := model_info(model_id)):
-        logger.info(
-            f"Could not retrieve model info for {model_id}, using ColoReg segmentation defaults."
-        )
+        logger.info(f"Could not retrieve model info for {model_id}, using ColoReg segmentation defaults.")
         return {
             "name": "wg-lux/colo_segmentation_RegNetX800MF_base",
             "activation": "sigmoid",
@@ -315,29 +295,18 @@ def infer_default_model_meta_from_hf(model_id: str) -> dict[str, Any]:
         "size_y": size_y,
         "description": f"Inferred defaults for {model_id}",
     }
-
-
-def setup_default_from_huggingface_logic(
-    cls, model_id: str, labelset_name: str | None = None
-):
+    
+def setup_default_from_huggingface_logic(cls, model_id: str, labelset_name: str | None = None):
     """
     Downloads model weights from Hugging Face and auto-fills ModelMeta fields.
     """
     meta = infer_default_model_meta_from_hf(model_id)
 
     # Download weights
-    weights_path = hf_hub_download(
-        repo_id=model_id,
-        filename="colo_segmentation_RegNetX800MF_base.ckpt",
-        local_dir=WEIGHTS_DIR,
-    )
+    weights_path = hf_hub_download(repo_id=model_id, filename="pytorch_model.bin", local_dir=WEIGHTS_DIR)
 
     ai_model, _ = AiModel.objects.get_or_create(name=meta["name"])
-    labelset = (
-        LabelSet.objects.first()
-        if not labelset_name
-        else LabelSet.objects.get(name=labelset_name)
-    )
+    labelset = LabelSet.objects.first() if not labelset_name else LabelSet.objects.get(name=labelset_name)
 
     return create_from_file_logic(
         cls,

endoreg_db/models/metadata/sensitive_meta_logic.py

@@ -2,26 +2,26 @@ import logging
 import os
 import random
 import re  # Neu hinzugefügt für Regex-Pattern
+from datetime import date, datetime, timedelta
 from hashlib import sha256
-from datetime import datetime, timedelta, date
-from typing import TYPE_CHECKING, Dict, Any, Optional, Type
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type
 
-from django.utils import timezone
 from django.db import transaction
+from django.utils import timezone
 
-# Assuming these utils are correctly located
-from endoreg_db.utils.hashs import get_patient_hash, get_patient_examination_hash
 from endoreg_db.utils import guess_name_gender
 
+# Assuming these utils are correctly located
+from endoreg_db.utils.hashs import get_patient_examination_hash, get_patient_hash
+
 # Import models needed for logic, use local imports inside functions if needed to break cycles
-from ..administration import Center, Examiner, Patient, FirstName, LastName
-from ..other import Gender
+from ..administration import Center, Examiner, FirstName, LastName, Patient
 from ..medical import PatientExamination
+from ..other import Gender
 from ..state import SensitiveMetaState
 
-
 if TYPE_CHECKING:
-    from .sensitive_meta import SensitiveMeta # Import model for type hinting
+    from .sensitive_meta import SensitiveMeta  # Import model for type hinting
 
 logger = logging.getLogger(__name__)
 SECRET_SALT = os.getenv("DJANGO_SALT", "default_salt")
@@ -35,23 +35,23 @@ DE_RX = re.compile(r"^\d{2}\.\d{2}\.\d{4}$")
 def parse_any_date(s: str) -> Optional[date]:
     """
     Parst Datumsstring mit Priorität auf deutsches Format (DD.MM.YYYY).
-    
+
     Unterstützte Formate:
     1. DD.MM.YYYY (Priorität) - deutsches Format
     2. YYYY-MM-DD (Fallback) - ISO-Format
     3. Erweiterte Fallbacks über dateparser
-    
+
     Args:
         s: Datumsstring zum Parsen
-        
+
     Returns:
         date-Objekt oder None bei ungültigem/fehlendem Input
     """
     if not s:
         return None
-    
+
     s = s.strip()
-    
+
     # 1. German dd.mm.yyyy (PRIORITÄT)
     if DE_RX.match(s):
         try:
@@ -60,7 +60,7 @@ def parse_any_date(s: str) -> Optional[date]:
         except ValueError as e:
             logger.warning(f"Invalid German date format '{s}': {e}")
             return None
-    
+
     # 2. ISO yyyy-mm-dd (Fallback für Rückwärtskompatibilität)
     if ISO_RX.match(s):
         try:
@@ -68,23 +68,20 @@ def parse_any_date(s: str) -> Optional[date]:
         except ValueError as e:
             logger.warning(f"Invalid ISO date format '{s}': {e}")
             return None
-    
+
     # 3. Extended fallbacks
     try:
         # Try standard datetime parsing
         return datetime.fromisoformat(s).date()
     except Exception:
         pass
-    
+
     try:
         # Try dateparser with German locale preference
         import dateparser
+
         dt = dateparser.parse(
-            s, 
-            settings={
-                "DATE_ORDER": "DMY", 
-                "PREFER_DAY_OF_MONTH": "first"
-            }
+            s, settings={"DATE_ORDER": "DMY", "PREFER_DAY_OF_MONTH": "first"}
         )
         return dt.date() if dt else None
     except Exception as e:
@@ -95,10 +92,10 @@ def parse_any_date(s: str) -> Optional[date]:
 def format_date_german(d: Optional[date]) -> str:
     """
     Formatiert date-Objekt als deutsches Datumsformat (DD.MM.YYYY).
-    
+
     Args:
         d: date-Objekt oder None
-        
+
     Returns:
         Formatiertes Datum als String oder leerer String bei None
     """
@@ -110,10 +107,10 @@ def format_date_german(d: Optional[date]) -> str:
 def format_date_iso(d: Optional[date]) -> str:
     """
     Formatiert date-Objekt als ISO-Format (YYYY-MM-DD).
-    
+
     Args:
         d: date-Objekt oder None
-        
+
     Returns:
         Formatiertes Datum als String oder leerer String bei None
     """
@@ -137,7 +134,7 @@ def generate_random_dob() -> datetime:
 def generate_random_examination_date() -> date:
     """Generates a random date within the last 20 years."""
     today = date.today()
-    start_date = today - timedelta(days=20 * 365) # Approximate 20 years back
+    start_date = today - timedelta(days=20 * 365)  # Approximate 20 years back
     time_between_dates = today - start_date
     days_between_dates = time_between_dates.days
     random_number_of_days = random.randrange(days_between_dates)
@@ -169,13 +166,15 @@ def calculate_patient_hash(instance: "SensitiveMeta", salt: str = SECRET_SALT) -
         first_name=first_name,
         last_name=last_name,
         dob=dob,
-        center=center.name, # Use center name
+        center=center.name,  # Use center name
         salt=salt,
     )
     return sha256(hash_str.encode()).hexdigest()
 
 
-def calculate_examination_hash(instance: "SensitiveMeta", salt: str = SECRET_SALT) -> str:
+def calculate_examination_hash(
+    instance: "SensitiveMeta", salt: str = SECRET_SALT
+) -> str:
     """Calculates the examination hash for the instance."""
     dob = instance.patient_dob
     first_name = instance.patient_first_name
@@ -190,13 +189,12 @@ def calculate_examination_hash(instance: "SensitiveMeta", salt: str = SECRET_SAL
     if not center:
         raise ValueError("Center is required to calculate examination hash.")
 
-
     hash_str = get_patient_examination_hash(
         first_name=first_name,
         last_name=last_name,
         dob=dob,
         examination_date=examination_date,
-        center=center.name, # Use center name
+        center=center.name,  # Use center name
         salt=salt,
     )
     return sha256(hash_str.encode()).hexdigest()
@@ -206,15 +204,19 @@ def create_pseudo_examiner_logic(instance: "SensitiveMeta") -> "Examiner":
     """Creates or retrieves the pseudo examiner based on instance data."""
     first_name = instance.examiner_first_name
     last_name = instance.examiner_last_name
-    center = instance.center # Should be set before calling save
+    center = instance.center  # Should be set before calling save
 
     if not first_name or not last_name or not center:
-        logger.warning(f"Incomplete examiner info for SensitiveMeta (pk={instance.pk}). Using default examiner.")
+        logger.warning(
+            f"Incomplete examiner info for SensitiveMeta (pk={instance.pk}). Using default examiner."
+        )
         # Ensure default center exists or handle appropriately
         try:
             default_center = Center.objects.get_by_natural_key("endoreg_db_demo")
         except Center.DoesNotExist:
-            logger.error("Default center 'endoreg_db_demo' not found. Cannot create default examiner.")
+            logger.error(
+                "Default center 'endoreg_db_demo' not found. Cannot create default examiner."
+            )
             raise ValueError("Default center 'endoreg_db_demo' not found.")
 
         examiner, _created = Examiner.custom_get_or_create(
@@ -232,7 +234,7 @@ def get_or_create_pseudo_patient_logic(instance: "SensitiveMeta") -> "Patient":
     """Gets or creates the pseudo patient based on instance data."""
     # Ensure necessary fields are set
     if not instance.patient_hash:
-         instance.patient_hash = calculate_patient_hash(instance)
+        instance.patient_hash = calculate_patient_hash(instance)
     if not instance.center:
         raise ValueError("Center must be set before creating pseudo patient.")
     if not instance.patient_gender:
@@ -254,29 +256,33 @@ def get_or_create_pseudo_patient_logic(instance: "SensitiveMeta") -> "Patient":
     return patient
 
 
-def get_or_create_pseudo_patient_examination_logic(instance: "SensitiveMeta") -> "PatientExamination":
+def get_or_create_pseudo_patient_examination_logic(
+    instance: "SensitiveMeta",
+) -> "PatientExamination":
     """Gets or creates the pseudo patient examination based on instance data."""
     # Ensure necessary fields are set
     if not instance.patient_hash:
-         instance.patient_hash = calculate_patient_hash(instance)
+        instance.patient_hash = calculate_patient_hash(instance)
     if not instance.examination_hash:
-         instance.examination_hash = calculate_examination_hash(instance)
+        instance.examination_hash = calculate_examination_hash(instance)
 
     # Ensure the pseudo patient exists first, as PatientExamination might depend on it
     if not instance.pseudo_patient_id:
         pseudo_patient = get_or_create_pseudo_patient_logic(instance)
-        instance.pseudo_patient_id = pseudo_patient.pk # Assign FK directly
-
-    patient_examination, _created = PatientExamination.get_or_create_pseudo_patient_examination_by_hash(
-        patient_hash=instance.patient_hash,
-        examination_hash=instance.examination_hash,
-        # Optionally pass pseudo_patient if the method requires it
-        # pseudo_patient=instance.pseudo_patient
+        instance.pseudo_patient_id = pseudo_patient.pk  # Assign FK directly
+
+    patient_examination, _created = (
+        PatientExamination.get_or_create_pseudo_patient_examination_by_hash(
+            patient_hash=instance.patient_hash,
+            examination_hash=instance.examination_hash,
+            # Optionally pass pseudo_patient if the method requires it
+            # pseudo_patient=instance.pseudo_patient
+        )
     )
     return patient_examination
 
 
-@transaction.atomic # Ensure all operations within save succeed or fail together
+@transaction.atomic  # Ensure all operations within save succeed or fail together
 def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
     """
     Contains the core logic for preparing a SensitiveMeta instance for saving.
@@ -288,10 +294,14 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
 
     # 1. Ensure DOB and Examination Date exist
     if not instance.patient_dob:
-        logger.debug(f"SensitiveMeta (pk={instance.pk}): Patient DOB missing, generating random.")
+        logger.debug(
+            f"SensitiveMeta (pk={instance.pk}): Patient DOB missing, generating random."
+        )
         instance.patient_dob = generate_random_dob()
     if not instance.examination_date:
-        logger.debug(f"SensitiveMeta (pk={instance.pk}): Examination date missing, generating random.")
+        logger.debug(
+            f"SensitiveMeta (pk={instance.pk}): Examination date missing, generating random."
+        )
         instance.examination_date = generate_random_examination_date()
 
     # 2. Ensure Center exists (should be set before calling save)
@@ -300,13 +310,14 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
 
     # 3. Ensure Gender exists (should be set before calling save, e.g., during creation/update)
     if not instance.patient_gender:
-         # Attempt to guess if names are available
-         first_name = instance.patient_first_name or DEFAULT_UNKNOWN_NAME
-         gender = guess_name_gender(first_name)
-         if not gender:
-             raise ValueError("Patient gender could not be determined and must be set before saving.")
-         instance.patient_gender = gender
-
+        # Attempt to guess if names are available
+        first_name = instance.patient_first_name or DEFAULT_UNKNOWN_NAME
+        gender = guess_name_gender(first_name)
+        if not gender:
+            raise ValueError(
+                "Patient gender could not be determined and must be set before saving."
+            )
+        instance.patient_gender = gender
 
     # 4. Calculate Hashes (depends on DOB, Exam Date, Center, Names)
     instance.patient_hash = calculate_patient_hash(instance)
@@ -333,10 +344,16 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
     return examiner_instance
 
 
-def create_sensitive_meta_from_dict(cls: Type["SensitiveMeta"], data: Dict[str, Any]) -> "SensitiveMeta":
+def create_sensitive_meta_from_dict(
+    cls: Type["SensitiveMeta"], data: Dict[str, Any]
+) -> "SensitiveMeta":
     """Logic to create a SensitiveMeta instance from a dictionary."""
 
-    field_names = {f.name for f in cls._meta.get_fields() if not f.is_relation or f.one_to_one or (f.many_to_one and f.related_model)}
+    field_names = {
+        f.name
+        for f in cls._meta.get_fields()
+        if not f.is_relation or f.one_to_one or (f.many_to_one and f.related_model)
+    }
     selected_data = {k: v for k, v in data.items() if k in field_names}
 
     # --- Convert patient_dob if it's a date object ---
@@ -348,64 +365,123 @@ def create_sensitive_meta_from_dict(cls: Type["SensitiveMeta"], data: Dict[str,
         logger.debug("Converted patient_dob from date to aware datetime: %s", aware_dob)
     elif isinstance(dob, str):
         # Handle string DOB - check if it's a field name or actual date
-        if dob == "patient_dob" or dob in ["patient_first_name", "patient_last_name", "examination_date"]:
-            logger.warning("Skipping invalid patient_dob value '%s' - appears to be field name", dob)
+        if dob == "patient_dob" or dob in [
+            "patient_first_name",
+            "patient_last_name",
+            "examination_date",
+        ]:
+            logger.warning(
+                "Skipping invalid patient_dob value '%s' - appears to be field name",
+                dob,
+            )
             selected_data.pop("patient_dob", None)  # Remove invalid value
         else:
             # Try to parse as date string
             try:
                 import dateparser
-                parsed_dob = dateparser.parse(dob, languages=['de'], settings={'DATE_ORDER': 'DMY'})
+
+                parsed_dob = dateparser.parse(
+                    dob, languages=["de"], settings={"DATE_ORDER": "DMY"}
+                )
                 if parsed_dob:
-                    aware_dob = timezone.make_aware(parsed_dob.replace(hour=0, minute=0, second=0, microsecond=0))
+                    aware_dob = timezone.make_aware(
+                        parsed_dob.replace(hour=0, minute=0, second=0, microsecond=0)
+                    )
                     selected_data["patient_dob"] = aware_dob
-                    logger.debug("Parsed string patient_dob '%s' to aware datetime: %s", dob, aware_dob)
+                    logger.debug(
+                        "Parsed string patient_dob '%s' to aware datetime: %s",
+                        dob,
+                        aware_dob,
+                    )
                 else:
-                    logger.warning("Could not parse patient_dob string '%s', removing from data", dob)
+                    logger.warning(
+                        "Could not parse patient_dob string '%s', removing from data",
+                        dob,
+                    )
                     selected_data.pop("patient_dob", None)
             except Exception as e:
-                logger.warning("Error parsing patient_dob string '%s': %s, removing from data", dob, e)
+                logger.warning(
+                    "Error parsing patient_dob string '%s': %s, removing from data",
+                    dob,
+                    e,
+                )
                 selected_data.pop("patient_dob", None)
     # --- End Conversion ---
-    
+
     # Similar validation for examination_date
     exam_date = selected_data.get("examination_date")
     if isinstance(exam_date, str):
-        if exam_date == "examination_date" or exam_date in ["patient_first_name", "patient_last_name", "patient_dob"]:
-            logger.warning("Skipping invalid examination_date value '%s' - appears to be field name", exam_date)
+        if exam_date == "examination_date" or exam_date in [
+            "patient_first_name",
+            "patient_last_name",
+            "patient_dob",
+        ]:
+            logger.warning(
+                "Skipping invalid examination_date value '%s' - appears to be field name",
+                exam_date,
+            )
             selected_data.pop("examination_date", None)
         else:
             # Try to parse as date string
             try:
                 # First try simple ISO format for YYYY-MM-DD
-                if len(exam_date) == 10 and exam_date.count('-') == 2:
+                if len(exam_date) == 10 and exam_date.count("-") == 2:
                     try:
                         from datetime import datetime as dt
-                        parsed_date = dt.strptime(exam_date, '%Y-%m-%d').date()
+
+                        parsed_date = dt.strptime(exam_date, "%Y-%m-%d").date()
                         selected_data["examination_date"] = parsed_date
-                        logger.debug("Parsed ISO examination_date '%s' to date: %s", exam_date, parsed_date)
+                        logger.debug(
+                            "Parsed ISO examination_date '%s' to date: %s",
+                            exam_date,
+                            parsed_date,
+                        )
                     except ValueError:
                         # Fall back to dateparser for complex formats
                         import dateparser
-                        parsed_date = dateparser.parse(exam_date, languages=['de'], settings={'DATE_ORDER': 'DMY'})
+
+                        parsed_date = dateparser.parse(
+                            exam_date, languages=["de"], settings={"DATE_ORDER": "DMY"}
+                        )
                         if parsed_date:
                             selected_data["examination_date"] = parsed_date.date()
-                            logger.debug("Parsed string examination_date '%s' to date: %s", exam_date, parsed_date.date())
+                            logger.debug(
+                                "Parsed string examination_date '%s' to date: %s",
+                                exam_date,
+                                parsed_date.date(),
+                            )
                         else:
-                            logger.warning("Could not parse examination_date string '%s', removing from data", exam_date)
+                            logger.warning(
+                                "Could not parse examination_date string '%s', removing from data",
+                                exam_date,
+                            )
                             selected_data.pop("examination_date", None)
                 else:
                     # Use dateparser for non-ISO formats
                     import dateparser
-                    parsed_date = dateparser.parse(exam_date, languages=['de'], settings={'DATE_ORDER': 'DMY'})
+
+                    parsed_date = dateparser.parse(
+                        exam_date, languages=["de"], settings={"DATE_ORDER": "DMY"}
+                    )
                     if parsed_date:
                         selected_data["examination_date"] = parsed_date.date()
-                        logger.debug("Parsed string examination_date '%s' to date: %s", exam_date, parsed_date.date())
+                        logger.debug(
+                            "Parsed string examination_date '%s' to date: %s",
+                            exam_date,
+                            parsed_date.date(),
+                        )
                     else:
-                        logger.warning("Could not parse examination_date string '%s', removing from data", exam_date)
+                        logger.warning(
+                            "Could not parse examination_date string '%s', removing from data",
+                            exam_date,
+                        )
                         selected_data.pop("examination_date", None)
             except Exception as e:
-                logger.warning("Error parsing examination_date string '%s': %s, removing from data", exam_date, e)
+                logger.warning(
+                    "Error parsing examination_date string '%s': %s, removing from data",
+                    exam_date,
+                    e,
+                )
                 selected_data.pop("examination_date", None)
 
     # Handle Center
@@ -421,7 +497,7 @@ def create_sensitive_meta_from_dict(cls: Type["SensitiveMeta"], data: Dict[str,
     # Handle Names and Gender
     first_name = selected_data.get("patient_first_name") or DEFAULT_UNKNOWN_NAME
     last_name = selected_data.get("patient_last_name") or DEFAULT_UNKNOWN_NAME
-    selected_data["patient_first_name"] = first_name # Ensure defaults are set
+    selected_data["patient_first_name"] = first_name  # Ensure defaults are set
     selected_data["patient_last_name"] = last_name
 
     patient_gender_input = selected_data.get("patient_gender")
@@ -432,22 +508,34 @@ def create_sensitive_meta_from_dict(cls: Type["SensitiveMeta"], data: Dict[str,
     elif isinstance(patient_gender_input, str):
         # Input is a string (gender name)
         try:
-            selected_data["patient_gender"] = Gender.objects.get(name=patient_gender_input)
+            selected_data["patient_gender"] = Gender.objects.get(
+                name=patient_gender_input
+            )
         except Gender.DoesNotExist:
-            logger.warning(f"Gender with name '{patient_gender_input}' provided but not found. Attempting to guess or use default.")
+            logger.warning(
+                f"Gender with name '{patient_gender_input}' provided but not found. Attempting to guess or use default."
+            )
             # Fall through to guessing logic if provided string name is invalid
-            patient_gender_input = None # Reset to trigger guessing
-    
-    if not isinstance(selected_data.get("patient_gender"), Gender): # If not already a Gender object (e.g. was None, or string lookup failed)
+            patient_gender_input = None  # Reset to trigger guessing
+
+    if not isinstance(
+        selected_data.get("patient_gender"), Gender
+    ):  # If not already a Gender object (e.g. was None, or string lookup failed)
         gender_name_to_use = guess_name_gender(first_name)
         if not gender_name_to_use:
-            logger.warning(f"Could not guess gender for name '{first_name}'. Setting Gender to unknown.")
+            logger.warning(
+                f"Could not guess gender for name '{first_name}'. Setting Gender to unknown."
+            )
             gender_name_to_use = "unknown"
         try:
-            selected_data["patient_gender"] = Gender.objects.get(name=gender_name_to_use)
+            selected_data["patient_gender"] = Gender.objects.get(
+                name=gender_name_to_use
+            )
         except Gender.DoesNotExist:
             # This should ideally not happen if "unknown" gender is guaranteed to exist
-            raise ValueError(f"Default or guessed gender '{gender_name_to_use}' does not exist in Gender table.")
+            raise ValueError(
+                f"Default or guessed gender '{gender_name_to_use}' does not exist in Gender table."
+            )
 
     # Update name DB
     update_name_db(first_name, last_name)
@@ -456,32 +544,42 @@ def create_sensitive_meta_from_dict(cls: Type["SensitiveMeta"], data: Dict[str,
     sensitive_meta = cls(**selected_data)
 
     # Call save once at the end. This triggers the custom save logic.
-    sensitive_meta.save() # This will call perform_save_logic internally
+    sensitive_meta.save()  # This will call perform_save_logic internally
 
     return sensitive_meta
 
 
-def update_sensitive_meta_from_dict(instance: "SensitiveMeta", data: Dict[str, Any]) -> "SensitiveMeta":
+def update_sensitive_meta_from_dict(
+    instance: "SensitiveMeta", data: Dict[str, Any]
+) -> "SensitiveMeta":
     """Logic to update a SensitiveMeta instance from a dictionary."""
-    field_names = {f.name for f in instance._meta.get_fields() if not f.is_relation or f.one_to_one or (f.many_to_one and f.related_model)}
+    field_names = {
+        f.name
+        for f in instance._meta.get_fields()
+        if not f.is_relation or f.one_to_one or (f.many_to_one and f.related_model)
+    }
     # Exclude FKs that should not be updated directly from dict keys (handled separately or via save logic)
-    excluded_fields = {'pseudo_patient', 'pseudo_examination'}
-    selected_data = {k: v for k, v in data.items() if k in field_names and k not in excluded_fields}
+    excluded_fields = {"pseudo_patient", "pseudo_examination"}
+    selected_data = {
+        k: v for k, v in data.items() if k in field_names and k not in excluded_fields
+    }
 
     # Handle potential Center update
     center_name = data.get("center_name")
     if center_name:
         try:
             center = Center.objects.get_by_natural_key(center_name)
-            instance.center = center # Update center directly
+            instance.center = center  # Update center directly
         except Center.DoesNotExist as exc:
-            logger.warning(f"Center '{center_name}' not found during update. Keeping existing center.")
-            selected_data.pop('center', None) # Remove from dict if not found
+            logger.warning(
+                f"Center '{center_name}' not found during update. Keeping existing center."
+            )
+            selected_data.pop("center", None)  # Remove from dict if not found
 
     # Set examiner names if provided, before calling save
     examiner_first_name = data.get("examiner_first_name")
     examiner_last_name = data.get("examiner_last_name")
-    if examiner_first_name is not None: # Allow setting empty strings
+    if examiner_first_name is not None:  # Allow setting empty strings
         instance.examiner_first_name = examiner_first_name
     if examiner_last_name is not None:
         instance.examiner_last_name = examiner_last_name
@@ -495,10 +593,14 @@ def update_sensitive_meta_from_dict(instance: "SensitiveMeta", data: Dict[str, A
             elif isinstance(patient_gender_input, str):
                 gender_input_clean = patient_gender_input.strip()
                 # Try direct case-insensitive DB lookup first
-                gender_obj = Gender.objects.filter(name__iexact=gender_input_clean).first()
+                gender_obj = Gender.objects.filter(
+                    name__iexact=gender_input_clean
+                ).first()
                 if gender_obj:
                     selected_data["patient_gender"] = gender_obj
-                    logger.debug(f"Successfully matched gender string '{patient_gender_input}' to Gender object via iexact lookup")
+                    logger.debug(
+                        f"Successfully matched gender string '{patient_gender_input}' to Gender object via iexact lookup"
+                    )
                 else:
                     # Use mapping helper for fallback
                     mapped = _map_gender_string_to_standard(gender_input_clean)
@@ -506,95 +608,172 @@ def update_sensitive_meta_from_dict(instance: "SensitiveMeta", data: Dict[str, A
                         gender_obj = Gender.objects.filter(name__iexact=mapped).first()
                         if gender_obj:
                             selected_data["patient_gender"] = gender_obj
-                            logger.info(f"Mapped gender '{patient_gender_input}' to '{mapped}' via fallback mapping")
+                            logger.info(
+                                f"Mapped gender '{patient_gender_input}' to '{mapped}' via fallback mapping"
+                            )
                         else:
-                            logger.warning(f"Mapped gender '{patient_gender_input}' to '{mapped}', but no such Gender in DB. Trying 'unknown'.")
-                            unknown_gender = Gender.objects.filter(name__iexact='unknown').first()
+                            logger.warning(
+                                f"Mapped gender '{patient_gender_input}' to '{mapped}', but no such Gender in DB. Trying 'unknown'."
+                            )
+                            unknown_gender = Gender.objects.filter(
+                                name__iexact="unknown"
+                            ).first()
                             if unknown_gender:
                                 selected_data["patient_gender"] = unknown_gender
-                                logger.warning(f"Using 'unknown' gender as fallback for '{patient_gender_input}'")
+                                logger.warning(
+                                    f"Using 'unknown' gender as fallback for '{patient_gender_input}'"
+                                )
                             else:
-                                logger.error(f"No 'unknown' gender found in database. Cannot handle gender '{patient_gender_input}'. Skipping gender update.")
+                                logger.error(
+                                    f"No 'unknown' gender found in database. Cannot handle gender '{patient_gender_input}'. Skipping gender update."
+                                )
                                 selected_data.pop("patient_gender", None)
                     else:
                         # Last resort: try to get 'unknown' gender
-                        unknown_gender = Gender.objects.filter(name__iexact='unknown').first()
+                        unknown_gender = Gender.objects.filter(
+                            name__iexact="unknown"
+                        ).first()
                         if unknown_gender:
                             selected_data["patient_gender"] = unknown_gender
-                            logger.warning(f"Using 'unknown' gender as fallback for '{patient_gender_input}' (no mapping)")
+                            logger.warning(
+                                f"Using 'unknown' gender as fallback for '{patient_gender_input}' (no mapping)"
+                            )
                         else:
-                            logger.error(f"No 'unknown' gender found in database. Cannot handle gender '{patient_gender_input}'. Skipping gender update.")
+                            logger.error(
+                                f"No 'unknown' gender found in database. Cannot handle gender '{patient_gender_input}'. Skipping gender update."
+                            )
                             selected_data.pop("patient_gender", None)
             else:
-                logger.warning(f"Unexpected patient_gender type {type(patient_gender_input)}: {patient_gender_input}. Skipping gender update.")
+                logger.warning(
+                    f"Unexpected patient_gender type {type(patient_gender_input)}: {patient_gender_input}. Skipping gender update."
+                )
                 selected_data.pop("patient_gender", None)
         except Exception as e:
-            logger.exception(f"Error handling patient_gender '{patient_gender_input}': {e}. Skipping gender update.")
+            logger.exception(
+                f"Error handling patient_gender '{patient_gender_input}': {e}. Skipping gender update."
+            )
             selected_data.pop("patient_gender", None)
 
     # Update other attributes from selected_data
     patient_name_changed = False
     for k, v in selected_data.items():
         # Avoid overwriting examiner names if they were just explicitly set
-        if k not in ["examiner_first_name", "examiner_last_name"] or \
-           (k == "examiner_first_name" and examiner_first_name is None) or \
-           (k == "examiner_last_name" and examiner_last_name is None):
-
+        if (
+            k not in ["examiner_first_name", "examiner_last_name"]
+            or (k == "examiner_first_name" and examiner_first_name is None)
+            or (k == "examiner_last_name" and examiner_last_name is None)
+        ):
             try:
                 # --- Convert patient_dob if it's a date object ---
                 value_to_set = v
                 if k == "patient_dob":
                     if isinstance(v, date) and not isinstance(v, datetime):
-                        aware_dob = timezone.make_aware(datetime.combine(v, datetime.min.time()))
+                        aware_dob = timezone.make_aware(
+                            datetime.combine(v, datetime.min.time())
+                        )
                         value_to_set = aware_dob
-                        logger.debug("Converted patient_dob from date to aware datetime during update: %s", aware_dob)
+                        logger.debug(
+                            "Converted patient_dob from date to aware datetime during update: %s",
+                            aware_dob,
+                        )
                     elif isinstance(v, str):
                         # Handle string DOB - check if it's a field name or actual date
-                        if v == "patient_dob" or v in ["patient_first_name", "patient_last_name", "examination_date"]:
-                            logger.warning("Skipping invalid patient_dob value '%s' during update - appears to be field name", v)
+                        if v == "patient_dob" or v in [
+                            "patient_first_name",
+                            "patient_last_name",
+                            "examination_date",
+                        ]:
+                            logger.warning(
+                                "Skipping invalid patient_dob value '%s' during update - appears to be field name",
+                                v,
+                            )
                             continue  # Skip this field
                         else:
                             # Try to parse as date string
                             try:
                                 import dateparser
-                                parsed_dob = dateparser.parse(v, languages=['de'], settings={'DATE_ORDER': 'DMY'})
+
+                                parsed_dob = dateparser.parse(
+                                    v, languages=["de"], settings={"DATE_ORDER": "DMY"}
+                                )
                                 if parsed_dob:
-                                    value_to_set = timezone.make_aware(parsed_dob.replace(hour=0, minute=0, second=0, microsecond=0))
-                                    logger.debug("Parsed string patient_dob '%s' during update to aware datetime: %s", v, value_to_set)
+                                    value_to_set = timezone.make_aware(
+                                        parsed_dob.replace(
+                                            hour=0, minute=0, second=0, microsecond=0
+                                        )
+                                    )
+                                    logger.debug(
+                                        "Parsed string patient_dob '%s' during update to aware datetime: %s",
+                                        v,
+                                        value_to_set,
+                                    )
                                 else:
-                                    logger.warning("Could not parse patient_dob string '%s' during update, skipping", v)
+                                    logger.warning(
+                                        "Could not parse patient_dob string '%s' during update, skipping",
+                                        v,
+                                    )
                                     continue
                             except Exception as e:
-                                logger.warning("Error parsing patient_dob string '%s' during update: %s, skipping", v, e)
+                                logger.warning(
+                                    "Error parsing patient_dob string '%s' during update: %s, skipping",
+                                    v,
+                                    e,
+                                )
                                 continue
                 elif k == "examination_date" and isinstance(v, str):
-                    if v == "examination_date" or v in ["patient_first_name", "patient_last_name", "patient_dob"]:
-                        logger.warning("Skipping invalid examination_date value '%s' during update - appears to be field name", v)
+                    if v == "examination_date" or v in [
+                        "patient_first_name",
+                        "patient_last_name",
+                        "patient_dob",
+                    ]:
+                        logger.warning(
+                            "Skipping invalid examination_date value '%s' during update - appears to be field name",
+                            v,
+                        )
                         continue
                     else:
                         # Try to parse as date string
                         try:
                             import dateparser
-                            parsed_date = dateparser.parse(v, languages=['de'], settings={'DATE_ORDER': 'DMY'})
+
+                            parsed_date = dateparser.parse(
+                                v, languages=["de"], settings={"DATE_ORDER": "DMY"}
+                            )
                             if parsed_date:
                                 value_to_set = parsed_date.date()
-                                logger.debug("Parsed string examination_date '%s' during update to date: %s", v, value_to_set)
+                                logger.debug(
+                                    "Parsed string examination_date '%s' during update to date: %s",
+                                    v,
+                                    value_to_set,
+                                )
                             else:
-                                logger.warning("Could not parse examination_date string '%s' during update, skipping", v)
+                                logger.warning(
+                                    "Could not parse examination_date string '%s' during update, skipping",
+                                    v,
+                                )
                                 continue
                         except Exception as e:
-                            logger.warning("Error parsing examination_date string '%s' during update: %s, skipping", v, e)
+                            logger.warning(
+                                "Error parsing examination_date string '%s' during update: %s, skipping",
+                                v,
+                                e,
+                            )
                             continue
                 # --- End Conversion ---
 
                 # Check if patient name is changing
-                if k in ["patient_first_name", "patient_last_name"] and getattr(instance, k) != value_to_set:
+                if (
+                    k in ["patient_first_name", "patient_last_name"]
+                    and getattr(instance, k) != value_to_set
+                ):
                     patient_name_changed = True
-                
-                setattr(instance, k, value_to_set) # Use value_to_set
-                
+
+                setattr(instance, k, value_to_set)  # Use value_to_set
+
             except Exception as e:
-                logger.error(f"Error setting attribute '{k}' to '{v}': {e}. Skipping this field.")
+                logger.error(
+                    f"Error setting attribute '{k}' to '{v}': {e}. Skipping this field."
+                )
                 continue
 
     # Update name DB if patient names changed
@@ -617,7 +796,7 @@ def update_sensitive_meta_from_dict(instance: "SensitiveMeta", data: Dict[str, A
 def update_or_create_sensitive_meta_from_dict(
     cls: Type["SensitiveMeta"],
     data: Dict[str, Any],
-    instance: Optional["SensitiveMeta"] = None
+    instance: Optional["SensitiveMeta"] = None,
 ) -> "SensitiveMeta":
     """Logic to update or create a SensitiveMeta instance from a dictionary."""
     # Check if the instance already exists based on unique fields
@@ -632,9 +811,9 @@ def update_or_create_sensitive_meta_from_dict(
 def _map_gender_string_to_standard(gender_str: str) -> Optional[str]:
     """Maps various gender string inputs to standard gender names used in the DB."""
     mapping = {
-        'male': ['male', 'm', 'männlich', 'man'],
-        'female': ['female', 'f', 'weiblich', 'woman'],
-        'unknown': ['unknown', 'unbekannt', 'other', 'diverse', '']
+        "male": ["male", "m", "männlich", "man"],
+        "female": ["female", "f", "weiblich", "woman"],
+        "unknown": ["unknown", "unbekannt", "other", "diverse", ""],
     }
     gender_lower = gender_str.strip().lower()
     for standard, variants in mapping.items():

endoreg_db/services/video_import.py

@@ -18,6 +18,7 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import Union, Dict, Any, Optional, List, Tuple
 from django.db import transaction
+from moviepy import video
 from endoreg_db.models import VideoFile, SensitiveMeta
 from endoreg_db.utils.paths import STORAGE_DIR, VIDEO_DIR, ANONYM_VIDEO_DIR
 import random
@@ -715,11 +716,15 @@ class VideoImportService():
                 "Updated video.raw_file using fallback method: videos/sensitive/%s",
                 target_file_path.name,
             )
+            
+        self.processing_context["raw_video_path"] = target_file_path
+        self.processing_context["video_filename"] = target_file_path.name
+
 
         self.logger.info("Created sensitive file for %s at %s", video.uuid, target_file_path)
         return target_file_path
 
-    def _get_processor_roi_info(self) -> Tuple[Optional[dict[str, dict[str, int | None] | None]], Optional[dict[str, int | None]] ]:
+    def _get_processor_roi_info(self) -> Tuple[Optional[List[List[Dict[str, Any]]]], Optional[Dict[str, Any]]]:
         """Get processor ROI information for masking."""
         endoscope_data_roi_nested = None
         endoscope_image_roi = None
@@ -742,6 +747,16 @@ class VideoImportService():
         except Exception as exc:
             self.logger.error("Failed to retrieve processor ROI information: %s", exc)
 
+        # Convert dict to nested list if necessary to match return type
+        if isinstance(endoscope_data_roi_nested, dict):
+            # Convert dict[str, dict[str, int | None] | None] to List[List[Dict[str, Any]]]
+            converted_roi = []
+            for key, value in endoscope_data_roi_nested.items():
+                if isinstance(value, dict):
+                    converted_roi.append([value])
+                elif value is None:
+                    converted_roi.append([])
+            endoscope_data_roi_nested = converted_roi
 
         return endoscope_data_roi_nested, endoscope_image_roi
 
@@ -818,42 +833,47 @@ class VideoImportService():
     def _perform_frame_cleaning(self, endoscope_data_roi_nested, endoscope_image_roi):
         """Perform frame cleaning and anonymization."""
         # Instantiate frame cleaner
-        is_available, FrameCleaner = self._ensure_frame_cleaning_available()
+        is_available, frame_cleaner = self._ensure_frame_cleaning_available()
 
-        if not is_available or FrameCleaner is None:
+        if not is_available:
             raise RuntimeError("Frame cleaning not available")
 
         # Prepare parameters for frame cleaning
         raw_video_path = self.processing_context.get('raw_video_path')
         
         if not raw_video_path or not Path(raw_video_path).exists():
-            raise RuntimeError(f"Raw video path not found: {raw_video_path}")
+            try:
+                self.current_video = self._require_current_video()
+                raw_video_path = self.current_video.get_raw_file_path()
+            except Exception:
+                raise RuntimeError(f"Raw video path not found: {raw_video_path}")
 
+                
         # Create temporary output path for cleaned video
         video_filename = self.processing_context.get('video_filename', Path(raw_video_path).name)
         cleaned_filename = f"cleaned_{video_filename}"
         cleaned_video_path = Path(raw_video_path).parent / cleaned_filename
-
-        # Instantiate FrameCleaner object
-        frame_cleaner_instance = FrameCleaner()
-
+        
+                
+        
         # Clean video with ROI masking (heavy I/O operation)
-        actual_cleaned_path, extracted_metadata = frame_cleaner_instance.clean_video(
+        actual_cleaned_path, extracted_metadata = frame_cleaner.clean_video(
             video_path=Path(raw_video_path),
             endoscope_image_roi=endoscope_image_roi,
             endoscope_data_roi_nested=endoscope_data_roi_nested,
             output_path=cleaned_video_path,
             technique="mask_overlay"
         )
-
+        
+        
         # Store cleaned video path for later use in _cleanup_and_archive
         self.processing_context['cleaned_video_path'] = actual_cleaned_path
         self.processing_context['extracted_metadata'] = extracted_metadata
-
+        
         # Update sensitive metadata with extracted information
         self._update_sensitive_metadata(extracted_metadata)
         self.logger.info(f"Extracted metadata from frame cleaning: {extracted_metadata}")
-
+        
         self.logger.info(f"Frame cleaning with ROI masking completed: {actual_cleaned_path}")
         self.logger.info("Cleaned video will be moved to anonym_videos during cleanup")
 

{endoreg_db-0.8.3.4.dist-info → endoreg_db-0.8.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: endoreg-db
-Version: 0.8.3.4
+Version: 0.8.3.7
 Summary: EndoReg Db Django App
 Project-URL: Homepage, https://info.coloreg.de
 Project-URL: Repository, https://github.com/wg-lux/endoreg-db

{endoreg_db-0.8.3.4.dist-info → endoreg_db-0.8.3.7.dist-info}/RECORD

@@ -248,7 +248,7 @@ endoreg_db/management/__init__.py,sha256=3dsK9Mizq1veuWTcvSOyWMFT9VI8wtyk-P2K9Ri
 endoreg_db/management/commands/__init__.py,sha256=Ch0jwQfNpOSr4O5KKMfYJ93dsesk1Afb-JtbRVyFXZs,21
 endoreg_db/management/commands/anonymize_video.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 endoreg_db/management/commands/check_auth.py,sha256=TPiYeCZ5QcqIvR33xhbqXunO2nrcNAmHb_izoMTqgpg,5390
-endoreg_db/management/commands/create_model_meta_from_huggingface.py,sha256=RUuoBjTzdchuMY6qcwBENN7FTyTygPTZQBZYWwhugDc,3925
+endoreg_db/management/commands/create_model_meta_from_huggingface.py,sha256=enZiNBi3wKLnOwdCp6nV3EDLrkK50KVEn6urgblNVjw,3621
 endoreg_db/management/commands/create_multilabel_model_meta.py,sha256=qeoyqcF2CWcnhniVRrlYbmJmwNwyZb-VQ0pjkr6arJU,7566
 endoreg_db/management/commands/fix_missing_patient_data.py,sha256=5TPUTOQwI2fVh3Zd88o4ne0R8N_V98k0GZsI1gW0kGM,7766
 endoreg_db/management/commands/fix_video_paths.py,sha256=7LLwc38oX3B_tYWbLJA43Li_KBO3m5Lyw0CF6YqN5rU,7145
@@ -464,10 +464,10 @@ endoreg_db/models/medical/risk/risk_type.py,sha256=kEugcaWSTEWH_Vxq4dcF80Iv1L4_K
 endoreg_db/models/metadata/__init__.py,sha256=8I6oLj3YTmeaPGJpL0AWG5gLwp38QzrEggxSkTisv7c,474
 endoreg_db/models/metadata/frame_ocr_result.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 endoreg_db/models/metadata/model_meta.py,sha256=F_r-PTLeNi4J-4EaGCQkGIguhdl7Bwba7_i56ZAjc-4,7589
-endoreg_db/models/metadata/model_meta_logic.py,sha256=6w1YX8hVq40UXbVN1fvDO9OljwekBZaDVHEjVZecoV8,12252
+endoreg_db/models/metadata/model_meta_logic.py,sha256=27mqScxUTJXNUVc6CqAs5dXjspEsh0TWPmlxdJVulGc,12015
 endoreg_db/models/metadata/pdf_meta.py,sha256=BTmpSgqxmPKi0apcNjyrZAS4AFKCPXVdBd6VBeyyv6E,3174
 endoreg_db/models/metadata/sensitive_meta.py,sha256=ekLHrW-b5uYcjfkRd0EW5ncx5ef8Bu-K6msDkpWCAbk,13034
-endoreg_db/models/metadata/sensitive_meta_logic.py,sha256=Oh7ssZQEPfKGfRMF5nXKJpOIxXx-Xibd3rpOu-bQilk,29988
+endoreg_db/models/metadata/sensitive_meta_logic.py,sha256=by3eCW8CgglK1SHiDOepHhTOGaugswxJhkH0BZp7-gs,33909
 endoreg_db/models/metadata/video_meta.py,sha256=c6xWdLW3uNqJ5VPJXHCxXA3mbXw-b0uR54-TOS3qL2Q,14966
 endoreg_db/models/metadata/video_prediction_logic.py,sha256=j5N82mHtiomeeIaf1HA65kT5d0htQfJmbI2bJb8mpxQ,7677
 endoreg_db/models/metadata/video_prediction_meta.py,sha256=EyfctAAAVcW9L0gf76ZBc9-G8MLMcD-tc2kkjaaLH4w,10592
@@ -602,7 +602,7 @@ endoreg_db/services/pseudonym_service.py,sha256=CJhbtRa6K6SPbphgCZgEMi8AFQtB18CU
 endoreg_db/services/requirements_object.py,sha256=290zf8AEbVtCoHhW4Jr7_ud-RvrqYmb1Nz9UBHtTnc0,6164
 endoreg_db/services/segment_sync.py,sha256=YgHvIHkbW4mqCu0ACf3zjRSZnNfxWwt4gh5syUVXuE0,6400
 endoreg_db/services/storage_aware_video_processor.py,sha256=kKFK64vXLeBSVkp1YJonU3gFDTeXZ8C4qb9QZZB99SE,13420
-endoreg_db/services/video_import.py,sha256=RBk0n_oN3VXRBMHtUKsRVjVXYv9VnxlM6GsMx2yHL6s,45187
+endoreg_db/services/video_import.py,sha256=PNAHHZHzge2TYDaZP63CL-sslj01CxFky6sEi6Twavg,46045
 endoreg_db/tasks/upload_tasks.py,sha256=OJq7DhNwcbWdXzHY8jz5c51BCVkPN5gSWOz-6Fx6W5M,7799
 endoreg_db/tasks/video_ingest.py,sha256=kxFuYkHijINV0VabQKCFVpJRv6eCAw07tviONurDgg8,5265
 endoreg_db/tasks/video_processing_tasks.py,sha256=rZ7Kr49bAR4Q-vALO2SURebrhcJ5hSFGwjF4aULrOao,14089
@@ -786,7 +786,7 @@ endoreg_db/views/video/video_meta.py,sha256=C1wBMTtQb_yzEUrhFGAy2UHEWMk_CbU75WXX
 endoreg_db/views/video/video_processing_history.py,sha256=mhFuS8RG5GV8E-lTtuD0qrq-bIpnUFp8vy9aERfC-J8,770
 endoreg_db/views/video/video_remove_frames.py,sha256=2FmvNrSPM0fUXiBxINN6vBUUDCqDlBkNcGR3WsLDgKo,1696
 endoreg_db/views/video/video_stream.py,sha256=kLyuf0ORTmsLeYUQkTQ6iRYqlIQozWhMMR3Lhfe_trk,12148
-endoreg_db-0.8.3.4.dist-info/METADATA,sha256=a9terVG2Fh1NBsonpVMM9l5O7PS8FSlAPOMdcg1vAOY,14758
-endoreg_db-0.8.3.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-endoreg_db-0.8.3.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-endoreg_db-0.8.3.4.dist-info/RECORD,,
+endoreg_db-0.8.3.7.dist-info/METADATA,sha256=AnfCmoQPqWaQn-LvrsJB0xImN9vp12xyqd-jQLWCpzc,14758
+endoreg_db-0.8.3.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+endoreg_db-0.8.3.7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+endoreg_db-0.8.3.7.dist-info/RECORD,,