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

endoreg_db/models/metadata/model_meta.py

@@ -31,7 +31,9 @@ class ModelMetaManager(models.Manager):
     Provides methods for retrieving ModelMeta instances using natural keys.
     """
 
-    def get_by_natural_key(self, name: str, version: str, model_name: str) -> "ModelMeta":
+    def get_by_natural_key(
+        self, name: str, version: str, model_name: str
+    ) -> "ModelMeta":
         """
         Retrieves a ModelMeta instance using its natural key.
 
@@ -80,10 +82,16 @@ class ModelMeta(models.Model):
         related_name="model_metadata",
         help_text="The set of labels this model version predicts.",
     )
-    activation = models.CharField(max_length=50, default="sigmoid", help_text="Output activation function (e.g., 'sigmoid', 'softmax', 'none').")
+    activation = models.CharField(
+        max_length=50,
+        default="sigmoid",
+        help_text="Output activation function (e.g., 'sigmoid', 'softmax', 'none').",
+    )
     weights = models.FileField(
         upload_to=WEIGHTS_DIR.name,  # Use .name for relative path
-        validators=[FileExtensionValidator(allowed_extensions=["safetensors", "pth", "pt"])],
+        validators=[
+            FileExtensionValidator(allowed_extensions=["safetensors", "pth", "pt"])
+        ],
         null=True,
         blank=True,
         help_text="Path to the model weights file (.safetensors), relative to MEDIA_ROOT.",
@@ -102,14 +110,24 @@ class ModelMeta(models.Model):
     )
     size_x = models.IntegerField(default=716, help_text="Expected input image width.")
     size_y = models.IntegerField(default=716, help_text="Expected input image height.")
-    axes = models.CharField(max_length=10, default="2,0,1", help_text="Comma-separated target axis order (e.g., '2,0,1' for CHW).")
+    axes = models.CharField(
+        max_length=10,
+        default="2,0,1",
+        help_text="Comma-separated target axis order (e.g., '2,0,1' for CHW).",
+    )
 
     # --- Inference Parameters ---
-    batchsize = models.IntegerField(default=16, help_text="Default batch size for inference.")
-    num_workers = models.IntegerField(default=0, help_text="Default number of workers for data loading.")
+    batchsize = models.IntegerField(
+        default=16, help_text="Default batch size for inference."
+    )
+    num_workers = models.IntegerField(
+        default=0, help_text="Default number of workers for data loading."
+    )
 
     # --- Metadata ---
-    description = models.TextField(blank=True, null=True, help_text="Optional description.")
+    description = models.TextField(
+        blank=True, null=True, help_text="Optional description."
+    )
     date_created = models.DateTimeField(auto_now_add=True)
 
     objects = ModelMetaManager()
@@ -117,7 +135,9 @@ class ModelMeta(models.Model):
     # --- Type Hinting for Related Fields ---
     if TYPE_CHECKING:
         labelset: models.ForeignKey["LabelSet"]
-        model: models.ForeignKey["AiModel"]  # Corrected from ai_model to match field name
+        model: models.ForeignKey[
+            "AiModel"
+        ]  # Corrected from ai_model to match field name
         weights = cast(FieldFile, weights)
 
     class Meta:
@@ -175,7 +195,9 @@ class ModelMeta(models.Model):
         )
 
     @classmethod
-    def get_latest_version_number(cls: Type["ModelMeta"], meta_name: str, model_name: str) -> int:
+    def get_latest_version_number(
+        cls: Type["ModelMeta"], meta_name: str, model_name: str
+    ) -> int:
         """
         Gets the latest version *number* using external logic.
         """
@@ -228,10 +250,16 @@ class ModelMeta(models.Model):
         Retrieves a ModelMeta instance by name, model name, and optionally version using external logic.
         """
         # Delegate to logic function
-        return logic.get_model_meta_by_name_version_logic(cls, meta_name, model_name, version)
+        return logic.get_model_meta_by_name_version_logic(
+            cls, meta_name, model_name, version
+        )
 
     @classmethod
-    def get_latest(cls: Type["ModelMeta"], meta_name: str, model_name: str) -> "ModelMeta":
+    def get_latest(
+        cls: Type["ModelMeta"], meta_name: str, model_name: str
+    ) -> "ModelMeta":
         """Alias for get_by_name_version(meta_name, model_name, version=None) using external logic."""
         # Delegate directly to the specific logic function
-        return logic.get_model_meta_by_name_version_logic(cls, meta_name, model_name, version=None)
+        return logic.get_model_meta_by_name_version_logic(
+            cls, meta_name, model_name, version=None
+        )

endoreg_db/models/metadata/model_meta_logic.py

@@ -25,14 +25,18 @@ def _get_model_meta_class():
     return ModelMeta
 
 
-def get_latest_version_number_logic(cls: Type["ModelMeta"], meta_name: str, model_name: str) -> int:
+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
@@ -88,7 +92,9 @@ def create_from_file_logic(
     try:
         label_set = labelset_qs.get()
     except LabelSet.DoesNotExist as exc:
-        raise ValueError(f"LabelSet '{labelset_name}' with version '{labelset_version}' not found.") from exc
+        raise ValueError(
+            f"LabelSet '{labelset_name}' with version '{labelset_version}' not found."
+        ) from exc
     except LabelSet.MultipleObjectsReturned:
         # Prefer the highest version when duplicates remain and no explicit version requested
         label_set = labelset_qs.order_by("-version").first()
@@ -101,17 +107,23 @@ 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}' already exists. Use bump_if_exists=True to increment."
             )
         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()
@@ -121,7 +133,10 @@ 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
 
@@ -216,7 +231,9 @@ def _parse_float_sequence(value: Any, *, fallback: Iterable[float]) -> list[floa
         try:
             parsed.append(float(token))
         except (TypeError, ValueError):
-            logger.warning("Failed to parse normalisation value %r; using fallback", token)
+            logger.warning(
+                "Failed to parse normalisation value %r; using fallback", token
+            )
             return list(fallback)
 
     return parsed or list(fallback)
@@ -237,7 +254,9 @@ def _parse_axes(axes_value: str | Iterable[Any]) -> list[int]:
     if isinstance(axes_value, str):
         token_source = axes_value.strip()
         if "," in token_source:
-            tokens = [token.strip() for token in token_source.split(",") if token.strip()]
+            tokens = [
+                token.strip() for token in token_source.split(",") if token.strip()
+            ]
         else:
             tokens = [char for char in token_source if char.strip()]
     else:
@@ -316,14 +335,22 @@ 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()
+        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}'.")
+            raise cls.DoesNotExist(
+                f"No ModelMeta found for '{meta_name}' and model '{model_name}'."
+            )
 
 
 import re
@@ -341,7 +368,9 @@ 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",
@@ -409,7 +438,9 @@ def setup_default_from_huggingface_logic(
             local_dir=WEIGHTS_DIR,
         )
     except Exception as exc:  # pragma: no cover - network errors
-        raise RuntimeError("Failed to download safetensor weights from Hugging Face; ensure the repository provides a .safetensors artifact.") from exc
+        raise RuntimeError(
+            "Failed to download safetensor weights from Hugging Face; ensure the repository provides a .safetensors artifact."
+        ) from exc
 
     ai_model, _ = AiModel.objects.get_or_create(name=meta["name"])
     if not labelset_name:
@@ -426,12 +457,16 @@ def setup_default_from_huggingface_logic(
             labelset_qs = labelset_qs.filter(version=version_value)
         labelset = labelset_qs.order_by("-version").first()
         if not labelset:
-            raise ValueError(f"LabelSet '{labelset_name}' with version '{labelset_version}' not found.")
+            raise ValueError(
+                f"LabelSet '{labelset_name}' with version '{labelset_version}' not found."
+            )
 
     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.")
+        logger.info(
+            f"ModelMeta {meta['name']} for model {ai_model.name} already exists. Skipping creation."
+        )
         return model_meta
 
     return create_from_file_logic(

endoreg_db/models/metadata/sensitive_meta.py

@@ -2,11 +2,10 @@ import logging
 
 # Removed hash utils, datetime, random, os, timezone, sha256 imports
 # Removed icecream import (was used in old save logic)
-from typing import TYPE_CHECKING, Any, Dict, Self, Type, cast
+from typing import TYPE_CHECKING, Any, Dict, Type, cast
 
 from django.db import models
 
-from ..administration.person.patient import PatientExternalID
 
 # Import models needed for type hints and FKs
 from ..state import SensitiveMetaState  # Needed for post-save state check
@@ -34,8 +33,6 @@ class SensitiveMeta(models.Model):
     Stores potentially sensitive information extracted from media.
     Logic for creation, hashing, pseudo-anonymization, and saving is in sensitive_meta_logic.py.
     """
-    
-    
 
     # --- Examination and Patient Info ---
     examination_date = models.DateField(blank=True, null=True)
@@ -43,44 +40,72 @@ class SensitiveMeta(models.Model):
     casenumber = models.CharField(max_length=255, blank=True, null=True)
     file_path = models.CharField(max_length=1024, blank=True, null=True)
 
-
     # --- Core FKs ---
-    pseudo_patient = models.ForeignKey("Patient", on_delete=models.CASCADE, blank=True, null=True, help_text="FK to the pseudo-anonymized Patient record.")
+    pseudo_patient = models.ForeignKey(
+        "Patient",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        help_text="FK to the pseudo-anonymized Patient record.",
+    )
     pseudo_examination = models.ForeignKey(
-        "PatientExamination", on_delete=models.CASCADE, blank=True, null=True, help_text="FK to the pseudo-anonymized PatientExamination record."
+        "PatientExamination",
+        on_delete=models.CASCADE,
+        blank=True,
+        null=True,
+        help_text="FK to the pseudo-anonymized PatientExamination record.",
+    )
+    patient_gender = models.ForeignKey(
+        "Gender", on_delete=models.CASCADE, blank=True, null=True
+    )
+    examiners = models.ManyToManyField(
+        "Examiner", blank=True, help_text="Pseudo-anonymized examiner(s)"
+    )
+    center = models.ForeignKey(
+        "Center", on_delete=models.CASCADE, blank=True, null=True
     )
-    patient_gender = models.ForeignKey("Gender", on_delete=models.CASCADE, blank=True, null=True)
-    examiners = models.ManyToManyField("Examiner", blank=True, help_text="Pseudo-anonymized examiner(s)")
-    center = models.ForeignKey("Center", on_delete=models.CASCADE, blank=True, null=True)
 
     # --- Names and DOB ---
     patient_first_name = models.CharField(max_length=255, blank=True, null=True)
     patient_last_name = models.CharField(max_length=255, blank=True, null=True)
-    patient_dob = models.DateTimeField(blank=True, null=True, help_text="Date of birth (can be auto-generated).")
+    patient_dob = models.DateTimeField(
+        blank=True, null=True, help_text="Date of birth (can be auto-generated)."
+    )
 
-    examiner_first_name = models.CharField(max_length=255, blank=True, null=True, editable=False)
-    examiner_last_name = models.CharField(max_length=255, blank=True, null=True, editable=False)
+    examiner_first_name = models.CharField(
+        max_length=255, blank=True, null=True, editable=False
+    )
+    examiner_last_name = models.CharField(
+        max_length=255, blank=True, null=True, editable=False
+    )
 
     # --- Hashes ---
-    patient_hash = models.CharField(max_length=64, blank=True, null=True, editable=False, db_index=True)
-    examination_hash = models.CharField(max_length=64, blank=True, null=True, editable=False, db_index=True)
+    patient_hash = models.CharField(
+        max_length=64, blank=True, null=True, editable=False, db_index=True
+    )
+    examination_hash = models.CharField(
+        max_length=64, blank=True, null=True, editable=False, db_index=True
+    )
 
     # --- Endoscope Info ---
     endoscope_type = models.CharField(max_length=255, blank=True, null=True)
     endoscope_sn = models.CharField(max_length=255, blank=True, null=True)
 
     # --- External patient ID ---
-    external_id = models.ForeignKey("PatientExternalID", on_delete=models.CASCADE, blank=True, null=True)
+    external_id = models.ForeignKey(
+        "PatientExternalID", on_delete=models.CASCADE, blank=True, null=True
+    )
 
     if TYPE_CHECKING:
         pseudo_patient: models.ForeignKey["Patient|None"]
 
         patient_gender: models.ForeignKey["Gender|None"]
         pseudo_examination: models.ForeignKey["PatientExamination|None"]
-        state: models.ForeignKey["SensitiveMetaState|None"]  # Assuming related_name='state' is defined on SensitiveMetaState.origin
+        state: models.ForeignKey[
+            "SensitiveMetaState|None"
+        ]  # Assuming related_name='state' is defined on SensitiveMetaState.origin
         center: models.ForeignKey["Center|None"]
 
-        examiners = cast(models.manager.RelatedManager["Examiner"], examiners)
 
     @property
     def external_id_origin(self) -> str | None:
@@ -92,7 +117,7 @@ class SensitiveMeta(models.Model):
     # --- Text Fields ---
     text = models.TextField(blank=True, null=True)
     anonymized_text = models.TextField(blank=True, null=True)
-    
+
     # --- Anonymization helper method ---
     create_anonymized_record = logic._create_anonymized_record
 
@@ -142,14 +167,18 @@ class SensitiveMeta(models.Model):
         # Keep this method for basic representation, ensure fields are accessed safely
         center_name = self.center.name if self.center else "None"
         gender_str = str(self.patient_gender) if self.patient_gender else "None"
-        dob_str = str(self.patient_dob.date()) if self.patient_dob else "None"  # Show only date part
+        dob_str = (
+            str(self.patient_dob.date()) if self.patient_dob else "None"
+        )  # Show only date part
         exam_date_str = str(self.examination_date) if self.examination_date else "None"
 
         examiners_str = "[Not saved yet]"
         if self.pk:
             try:
                 # Use prefetch_related in queries accessing this for efficiency
-                examiners_str = ", ".join([str(e) for e in self.examiners.all()]) or "[None]"
+                examiners_str = (
+                    ", ".join([str(e) for e in self.examiners.all()]) or "[None]"
+                )
             except Exception as e:
                 examiners_str = f"[Error: {e}]"
 
@@ -173,7 +202,9 @@ class SensitiveMeta(models.Model):
     def state_safe(self) -> "SensitiveMetaState":
         state = self.state
         if not state:
-            raise SensitiveMetaState.DoesNotExist("SensitiveMetaState does not exist for this SensitiveMeta instance.")
+            raise SensitiveMetaState.DoesNotExist(
+                "SensitiveMetaState does not exist for this SensitiveMeta instance."
+            )
         return state
 
     @property
@@ -217,13 +248,18 @@ class SensitiveMeta(models.Model):
             if self.pk:
                 state, created = SensitiveMetaState.objects.get_or_create(origin=self)
                 if created:
-                    logger.info("Created new SensitiveMetaState for SensitiveMeta %s (via get_or_create)", self.pk)
+                    logger.info(
+                        "Created new SensitiveMetaState for SensitiveMeta %s (via get_or_create)",
+                        self.pk,
+                    )
                 # Link the state back to the instance in memory
                 self.state = state
                 return state
             else:
                 # Cannot create state if the main instance has no PK
-                raise ValueError("Cannot get or create state for an unsaved SensitiveMeta instance.")
+                raise ValueError(
+                    "Cannot get or create state for an unsaved SensitiveMeta instance."
+                )
 
     def __repr__(self):
         return self.__str__()
@@ -274,7 +310,11 @@ class SensitiveMeta(models.Model):
                     SensitiveMetaState.objects.create(origin=self)
 
         # 4. Handle ManyToMany linking (examiners) *after* the instance has a PK.
-        if examiner_to_link and self.pk and not self.examiners.filter(pk=examiner_to_link.pk).exists():
+        if (
+            examiner_to_link
+            and self.pk
+            and not self.examiners.filter(pk=examiner_to_link.pk).exists()
+        ):
             self.examiners.add(examiner_to_link)
             # Adding to M2M handles its own DB interaction, no second super().save() needed.
 
@@ -303,6 +343,3 @@ class SensitiveMeta(models.Model):
         This method delegates the update operation to the external logic module responsible for managing name data.
         """
         logic.update_name_db(first_name, last_name)
-        
-        
-    

endoreg_db/models/metadata/sensitive_meta_logic.py

@@ -1017,7 +1017,7 @@ def update_sensitive_meta_from_dict(
                             logger.debug(
                                 "Parsed string patient_dob '%s' during update to aware datetime: %s",
                                 v,
-                            aware_dob,
+                                aware_dob,
                             )
                         else:
                             logger.warning(
@@ -1025,35 +1025,37 @@ def update_sensitive_meta_from_dict(
                                 v,
                             )
                             continue
-                    elif k == "examination_date":
-                        if isinstance(v, str):
-                            parsed = parse_any_date(v)
-                            if parsed:
-                                value_to_set = parsed  # field is DateField, so keep it as date
-                                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,
-                                )
-                                continue
-                        elif isinstance(v, date):
-                            value_to_set = v
+                elif k == "examination_date":
+                    if isinstance(v, str):
+                        parsed = parse_any_date(v)
+                        if parsed:
+                            value_to_set = (
+                                parsed  # field is DateField, so keep it as date
+                            )
+                            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,
+                            )
+                            continue
+                    elif isinstance(v, date):
+                        value_to_set = v
 
                         # --- End Conversion ---
 
-                        # Check if patient name is changing
-                        if (
-                            k in ["patient_first_name", "patient_last_name"]
-                            and getattr(instance, k) != value_to_set
-                        ):
-                            patient_name_changed = True
+                # Check if patient name is changing
+                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(