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

endoreg_db/models/medical/hardware/endoscopy_processor.py

@@ -160,7 +160,7 @@ class EndoscopyProcessor(models.Model):
             "height": self.endoscope_sn_height,
         }
 
-    def get_rois(self) -> dict[ str, dict[str, int | None] | None]:
+    def get_rois(self) -> dict[str, dict[str, int | None] | None]:
         return {
             "endoscope_image": self.get_roi_endoscope_image(),
             "examination_date": self.get_roi_examination_date(),
@@ -171,3 +171,12 @@ class EndoscopyProcessor(models.Model):
             "endoscope_type": self.get_roi_endoscope_type(),
             "endoscope_sn": self.get_roi_endoscopy_sn(),
         }
+
+    def get_sensitive_rois(self) -> dict[str, dict[str, int | None] | None]:
+        return {
+            "examination_date": self.get_roi_examination_date(),
+            "examination_time": self.get_roi_examination_time(),
+            "patient_first_name": self.get_roi_patient_first_name(),
+            "patient_last_name": self.get_roi_patient_last_name(),
+            "patient_dob": self.get_roi_patient_dob(),
+        }

endoreg_db/models/metadata/model_meta_logic.py

@@ -1,41 +1,45 @@
 import shutil
+from logging import getLogger
 from pathlib import Path
-from typing import Optional, TYPE_CHECKING, Any, Type
-from huggingface_hub import hf_hub_download
+from typing import TYPE_CHECKING, Any, Optional, Type
+
+from django.core.files import File
 from django.db import transaction
+from huggingface_hub import hf_hub_download
 
 # 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 WEIGHTS_DIR, STORAGE_DIR
-
-from logging import getLogger
+from ..utils import STORAGE_DIR, WEIGHTS_DIR
 
 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_model_meta_class():
+    """Lazy import to avoid circular imports"""
+    from .model_meta import ModelMeta
 
-def get_latest_version_number_logic(
-    cls: Type["ModelMeta"], meta_name: str, model_name: str
-) -> int:
+    return ModelMeta
+
+
+def get_latest_version_number_logic(cls: Type["ModelMeta"], meta_name: str, model_name: str) -> int:
     """
     Finds the highest numerical version for a given meta_name and model_name.
     Iterates through all versions, attempts to parse them as integers,
     and returns the maximum integer found. If no numeric versions are found,
     returns 0.
     """
-    versions_qs = cls.objects.filter(
-        name=meta_name, model__name=model_name
-    ).values_list('version', flat=True)
+    versions_qs = cls.objects.filter(name=meta_name, model__name=model_name).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 +51,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,
@@ -84,13 +88,10 @@ def create_from_file_logic(
 
     if requested_version:
         target_version = str(requested_version)
-        existing = cls.objects.filter(
-            name=meta_name, model=ai_model, version=target_version
-        ).first()
+        existing = cls.objects.filter(name=meta_name, model=ai_model, version=target_version).first()
         if existing and not bump_if_exists:
             raise ValueError(
-                f"ModelMeta '{meta_name}' version '{target_version}' for model '{model_name}' "
-                f"already exists. Use bump_if_exists=True to increment."
+                f"ModelMeta '{meta_name}' version '{target_version}' for model '{model_name}' already exists. Use bump_if_exists=True to increment."
             )
         elif existing and bump_if_exists:
             target_version = str(latest_version_num + 1)
@@ -99,7 +100,6 @@ def create_from_file_logic(
         target_version = str(latest_version_num + 1)
         logger.info(f"Setting next version for {meta_name}/{model_name} to {target_version}")
 
-
     # --- Prepare Weights File ---
     source_weights_path = Path(weights_file).resolve()
     if not source_weights_path.exists():
@@ -125,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
@@ -147,40 +147,44 @@ def create_from_file_logic(
     # --- Optionally update AiModel's active_meta ---
     # You might want to add logic here to automatically set the newly created/updated
     # meta as the active one for the AiModel, e.g.:
-    # ai_model.active_meta = model_meta
-    # ai_model.save()
+    ai_model.active_meta = model_meta
+    ai_model.save()
 
     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
@@ -202,6 +206,7 @@ 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"],
@@ -222,22 +227,21 @@ def get_model_meta_by_name_version_logic(
         try:
             return cls.objects.get(name=meta_name, model=ai_model, version=version)
         except Exception as exc:
-            raise cls.DoesNotExist(
-                f"ModelMeta '{meta_name}' version '{version}' for model '{model_name}' not found."
-            ) from exc
+            raise cls.DoesNotExist(f"ModelMeta '{meta_name}' version '{version}' for model '{model_name}' not found.") from exc
     else:
         # Get latest version
         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}'."
-            )
-            
-from huggingface_hub import model_info
+            raise cls.DoesNotExist(f"No ModelMeta found for '{meta_name}' and model '{model_name}'.")
+
+
 import re
 
+from huggingface_hub import model_info
+
+
 def infer_default_model_meta_from_hf(model_id: str) -> dict[str, Any]:
     """
     Infers default model metadata (activation, normalization, input size)
@@ -295,7 +299,8 @@ 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):
     """
     Downloads model weights from Hugging Face and auto-fills ModelMeta fields.
@@ -303,10 +308,25 @@ def setup_default_from_huggingface_logic(cls, model_id: str, labelset_name: str
     meta = infer_default_model_meta_from_hf(model_id)
 
     # Download weights
-    weights_path = hf_hub_download(repo_id=model_id, filename="pytorch_model.bin", local_dir=WEIGHTS_DIR)
+    weights_path = hf_hub_download(
+        repo_id=model_id,
+        filename="colo_segmentation_RegNetX800MF_base.ckpt",
+        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)
+    if not labelset_name:
+        labelset = LabelSet.objects.first()
+        if not labelset:
+            raise ValueError("No labelset found and no labelset_name provided")
+    else:
+        labelset = LabelSet.objects.get(name=labelset_name)
+
+    ModelMeta = _get_model_meta_class()
+    model_meta = ModelMeta.objects.filter(name=meta["name"], model=ai_model).first()
+    if model_meta:
+        logger.info(f"ModelMeta {meta['name']} for model {ai_model.name} already exists. Skipping creation.")
+        return model_meta
 
     return create_from_file_logic(
         cls,

endoreg_db/models/metadata/sensitive_meta_logic.py

@@ -162,6 +162,9 @@ def calculate_patient_hash(instance: "SensitiveMeta", salt: str = SECRET_SALT) -
     if not center:
         raise ValueError("Center is required to calculate patient hash.")
 
+    assert first_name is not None, "First name is required to calculate patient hash."
+    assert last_name is not None, "Last name is required to calculate patient hash."
+
     hash_str = get_patient_hash(
         first_name=first_name,
         last_name=last_name,
@@ -208,11 +211,11 @@ def create_pseudo_examiner_logic(instance: "SensitiveMeta") -> "Examiner":
 
     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."
+            f"Incomplete examiner info for SensitiveMeta (pk={instance.pk or 'new'}). Using default examiner."
         )
         # Ensure default center exists or handle appropriately
         try:
-            default_center = Center.objects.get_by_natural_key("endoreg_db_demo")
+            default_center = Center.objects.get(name="endoreg_db_demo")
         except Center.DoesNotExist:
             logger.error(
                 "Default center 'endoreg_db_demo' not found. Cannot create default examiner."
@@ -287,7 +290,53 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
     """
     Contains the core logic for preparing a SensitiveMeta instance for saving.
     Handles data generation (dates), hash calculation, and linking pseudo-entities.
-    Returns the Examiner instance to be linked via M2M after the main save.
+
+    This function is called on every save() operation and implements a two-phase approach:
+
+    **Phase 1: Initial Creation (with defaults)**
+    - When a SensitiveMeta is first created (e.g., via get_or_create_sensitive_meta()),
+      it may have missing patient data (names, DOB, etc.)
+    - Default values are set to prevent hash calculation errors:
+      * patient_first_name: "unknown"
+      * patient_last_name: "unknown"
+      * patient_dob: random date (1920-2000)
+    - A temporary hash is calculated using these defaults
+    - Temporary pseudo-entities (Patient, Examination) are created
+
+    **Phase 2: Update (with extracted data)**
+    - When real patient data is extracted (e.g., from video OCR via lx_anonymizer),
+      update_from_dict() is called with actual values
+    - The instance fields are updated with real data (names, DOB, etc.)
+    - save() is called again, triggering this function
+    - Default-setting logic is skipped (fields are no longer empty)
+    - Hash is RECALCULATED with real data
+    - New pseudo-entities are created/retrieved based on new hash
+
+    **Example Flow:**
+    ```
+    # Initial creation
+    sm = SensitiveMeta.create_from_dict({"center": center})
+    # → patient_first_name = "unknown", patient_last_name = "unknown"
+    # → hash = sha256("unknown unknown 1990-01-01 ...")
+    # → pseudo_patient_temp created
+
+    # Later update with extracted data
+    sm.update_from_dict({"patient_first_name": "Max", "patient_last_name": "Mustermann"})
+    # → patient_first_name = "Max", patient_last_name = "Mustermann" (overwrites)
+    # → save() triggered → perform_save_logic() called again
+    # → Default-setting skipped (names already exist)
+    # → hash = sha256("Max Mustermann 1985-03-15 ...") (RECALCULATED)
+    # → pseudo_patient_real created/retrieved with new hash
+    ```
+
+    Args:
+        instance: The SensitiveMeta instance being saved
+
+    Returns:
+        Examiner: The pseudo examiner instance to be linked via M2M after save
+
+    Raises:
+        ValueError: If required fields (center, gender) cannot be determined
     """
 
     # --- Pre-Save Checks and Data Generation ---
@@ -295,12 +344,12 @@ 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."
+            f"SensitiveMeta (pk={instance.pk or 'new'}): 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."
+            f"SensitiveMeta (pk={instance.pk or 'new'}): Examination date missing, generating random."
         )
         instance.examination_date = generate_random_examination_date()
 
@@ -308,18 +357,70 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
     if not instance.center:
         raise ValueError("Center must be set before saving SensitiveMeta.")
 
+    # 2.5 CRITICAL: Set default patient names BEFORE hash calculation
+    #
+    # **Why this is necessary:**
+    # Hash calculation (step 4) requires first_name and last_name to be non-None.
+    # However, on initial creation (e.g., via get_or_create_sensitive_meta()), these
+    # fields may be empty because real patient data hasn't been extracted yet.
+    #
+    # **Two-phase approach:**
+    # - Phase 1 (Initial): Set defaults if names are missing
+    #   → Allows hash calculation to succeed without errors
+    #   → Creates temporary pseudo-entities with default hash
+    #
+    # - Phase 2 (Update): Real data extraction (OCR, manual input)
+    #   → update_from_dict() sets real names ("Max", "Mustermann")
+    #   → save() is called again
+    #   → This block is SKIPPED (names already exist)
+    #   → Hash is recalculated with real data (step 4)
+    #   → New pseudo-entities created with correct hash
+    #
+    # **Example:**
+    # Initial:  patient_first_name = "unknown" → hash = sha256("unknown unknown...")
+    # Updated:  patient_first_name = "Max"     → hash = sha256("Max Mustermann...")
+    #
+    if not instance.patient_first_name:
+        instance.patient_first_name = DEFAULT_UNKNOWN_NAME
+        logger.debug(
+            "SensitiveMeta (pk=%s): Patient first name missing, set to default '%s'.",
+            instance.pk or "new",
+            DEFAULT_UNKNOWN_NAME,
+        )
+
+    if not instance.patient_last_name:
+        instance.patient_last_name = DEFAULT_UNKNOWN_NAME
+        logger.debug(
+            "SensitiveMeta (pk=%s): Patient last name missing, set to default '%s'.",
+            instance.pk or "new",
+            DEFAULT_UNKNOWN_NAME,
+        )
+
     # 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:
+        # Use the now-guaranteed first_name for gender guessing
+        first_name = instance.patient_first_name
+        gender_str = guess_name_gender(first_name)
+        if not gender_str:
             raise ValueError(
                 "Patient gender could not be determined and must be set before saving."
             )
-        instance.patient_gender = gender
+        # Convert string to Gender object
+        try:
+            gender_obj = Gender.objects.get(name=gender_str)
+            instance.patient_gender = gender_obj
+        except Gender.DoesNotExist:
+            raise ValueError(f"Gender '{gender_str}' not found in database.")
 
     # 4. Calculate Hashes (depends on DOB, Exam Date, Center, Names)
+    #
+    # **IMPORTANT: Hashes are RECALCULATED on every save!**
+    # This enables the two-phase update pattern:
+    # - Initial save: Hash based on default "unknown unknown" names
+    # - Updated save: Hash based on real extracted names ("Max Mustermann")
+    #
+    # The new hash will link to different pseudo-entities, ensuring proper
+    # anonymization while maintaining referential integrity.
     instance.patient_hash = calculate_patient_hash(instance)
     instance.examination_hash = calculate_examination_hash(instance)
 
@@ -347,7 +448,50 @@ def perform_save_logic(instance: "SensitiveMeta") -> "Examiner":
 def create_sensitive_meta_from_dict(
     cls: Type["SensitiveMeta"], data: Dict[str, Any]
 ) -> "SensitiveMeta":
-    """Logic to create a SensitiveMeta instance from a dictionary."""
+    """
+    Create a SensitiveMeta instance from a dictionary.
+
+    **Center handling:**
+    This function accepts TWO ways to specify the center:
+    1. `center` (Center object) - Directly pass a Center instance
+    2. `center_name` (string) - Pass the center name as a string (will be resolved to Center object)
+
+    At least ONE of these must be provided.
+
+    **Example usage:**
+    ```python
+    # Option 1: With Center object
+    data = {
+        "patient_first_name": "Patient",
+        "patient_last_name": "Unknown",
+        "patient_dob": date(1990, 1, 1),
+        "examination_date": date.today(),
+        "center": center_obj,  # ← Center object
+    }
+    sm = SensitiveMeta.create_from_dict(data)
+
+    # Option 2: With center name string
+    data = {
+        "patient_first_name": "Patient",
+        "patient_last_name": "Unknown",
+        "patient_dob": date(1990, 1, 1),
+        "examination_date": date.today(),
+        "center_name": "university_hospital_wuerzburg",  # ← String
+    }
+    sm = SensitiveMeta.create_from_dict(data)
+    ```
+
+    Args:
+        cls: The SensitiveMeta class
+        data: Dictionary containing field values
+
+    Returns:
+        SensitiveMeta: The created instance
+
+    Raises:
+        ValueError: If neither center nor center_name is provided
+        ValueError: If center_name does not match any Center in database
+    """
 
     field_names = {
         f.name
@@ -484,15 +628,29 @@ def create_sensitive_meta_from_dict(
                 )
                 selected_data.pop("examination_date", None)
 
-    # Handle Center
+    # Handle Center - accept both center_name (string) and center (object)
+    from ..administration import Center
+
+    center = data.get("center")  # First try direct Center object
     center_name = data.get("center_name")
-    if not center_name:
-        raise ValueError("center_name is required in data dictionary.")
-    try:
-        center = Center.objects.get_by_natural_key(center_name)
+
+    if center is not None:
+        # Center object provided directly - validate it's a Center instance
+        if not isinstance(center, Center):
+            raise ValueError(f"'center' must be a Center instance, got {type(center)}")
         selected_data["center"] = center
-    except Center.DoesNotExist as exc:
-        raise ValueError(f"Center with name '{center_name}' does not exist.") from exc
+    elif center_name:
+        # center_name string provided - resolve to Center object
+        try:
+            center = Center.objects.get(name=center_name)
+            selected_data["center"] = center
+        except Center.DoesNotExist:
+            raise ValueError(f"Center with name '{center_name}' does not exist.")
+    else:
+        # Neither center nor center_name provided
+        raise ValueError(
+            "Either 'center' (Center object) or 'center_name' (string) is required in data dictionary."
+        )
 
     # Handle Names and Gender
     first_name = selected_data.get("patient_first_name") or DEFAULT_UNKNOWN_NAME
@@ -552,7 +710,50 @@ def create_sensitive_meta_from_dict(
 def update_sensitive_meta_from_dict(
     instance: "SensitiveMeta", data: Dict[str, Any]
 ) -> "SensitiveMeta":
-    """Logic to update a SensitiveMeta instance from a dictionary."""
+    """
+    Updates a SensitiveMeta instance from a dictionary of new values.
+
+    **Integration with two-phase save pattern:**
+    This function is typically called after initial SensitiveMeta creation when real
+    patient data becomes available (e.g., extracted from video OCR, PDF parsing, or
+    manual annotation).
+
+    **Example workflow:**
+    ```python
+    # Phase 1: Initial creation with defaults
+    sm = SensitiveMeta.create_from_dict({"center": center})
+    # → patient_first_name = "unknown", hash = sha256("unknown...")
+
+    # Phase 2: Update with extracted data
+    extracted = {
+        "patient_first_name": "Max",
+        "patient_last_name": "Mustermann",
+        "patient_dob": date(1985, 3, 15)
+    }
+    update_sensitive_meta_from_dict(sm, extracted)
+    # → Sets: sm.patient_first_name = "Max", sm.patient_last_name = "Mustermann"
+    # → Calls: sm.save()
+    # → Triggers: perform_save_logic() again
+    # → Result: Hash recalculated with real data, new pseudo-entities created
+    ```
+
+    **Key behaviors:**
+    - Updates instance attributes from provided dictionary
+    - Handles type conversions (date strings → date objects, gender strings → Gender objects)
+    - Tracks patient name changes to update name database
+    - Calls save() at the end, triggering full save logic including hash recalculation
+    - Default-setting in perform_save_logic() is skipped (fields already populated)
+
+    Args:
+        instance: The existing SensitiveMeta instance to update
+        data: Dictionary of field names and new values
+
+    Returns:
+        The updated SensitiveMeta instance
+
+    Raises:
+        Exception: If save fails or required conversions fail
+    """
     field_names = {
         f.name
         for f in instance._meta.get_fields()
@@ -564,17 +765,37 @@ def update_sensitive_meta_from_dict(
         k: v for k, v in data.items() if k in field_names and k not in excluded_fields
     }
 
-    # Handle potential Center update
+    # Handle potential Center update - accept both center_name (string) and center (object)
+    from ..administration import Center
+
+    center = data.get("center")  # First try direct Center object
     center_name = data.get("center_name")
-    if center_name:
+
+    if center is not None:
+        # Center object provided directly - validate and update
+        if isinstance(center, Center):
+            instance.center = center
+            logger.debug(f"Updated center from Center object: {center.name}")
+        else:
+            logger.warning(
+                f"Invalid center type {type(center)}, expected Center instance. Ignoring."
+            )
+        # Remove from selected_data to prevent override
+        selected_data.pop("center", None)
+    elif center_name:
+        # center_name string provided - resolve to Center object
         try:
-            center = Center.objects.get_by_natural_key(center_name)
-            instance.center = center  # Update center directly
-        except Center.DoesNotExist as exc:
+            center_obj = Center.objects.get(name=center_name)
+            instance.center = center_obj
+            logger.debug(f"Updated center from center_name string: {center_name}")
+        except Center.DoesNotExist:
             logger.warning(
                 f"Center '{center_name}' not found during update. Keeping existing center."
             )
-            selected_data.pop("center", None)  # Remove from dict if not found
+    else:
+        # Both are None/missing - remove 'center' from selected_data to preserve existing value
+        selected_data.pop("center", None)
+    # If both are None/missing, keep existing center (no update needed)
 
     # Set examiner names if provided, before calling save
     examiner_first_name = data.get("examiner_first_name")
@@ -657,6 +878,11 @@ def update_sensitive_meta_from_dict(
     # Update other attributes from selected_data
     patient_name_changed = False
     for k, v in selected_data.items():
+        # Skip None values to avoid overwriting existing data
+        if v is None:
+            logger.debug(f"Skipping field '{k}' during update because value is None")
+            continue
+
         # Avoid overwriting examiner names if they were just explicitly set
         if (
             k not in ["examiner_first_name", "examiner_last_name"]