endoreg-db 0.8.4.2__py3-none-any.whl → 0.8.4.3__py3-none-any.whl

endoreg_db/models/metadata/model_meta_logic.py

@@ -2,7 +2,7 @@ import shutil
 from logging import getLogger
 from pathlib import Path
 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
 
@@ -18,18 +18,14 @@ if TYPE_CHECKING:
     from .model_meta import ModelMeta  # Import ModelMeta for type hinting
 
 
-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
@@ -84,24 +80,17 @@ 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)
-            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 +100,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
 
@@ -127,8 +113,6 @@ def create_from_file_logic(
         logger.info(f"Copied weights from {source_weights_path} to {full_dest_path}")
     except Exception as e:
         raise IOError(f"Failed to copy weights file: {e}") from e
-    
-
 
     # --- Create/Update ModelMeta Instance ---
     defaults = {
@@ -146,11 +130,6 @@ def create_from_file_logic(
         version=target_version,
         defaults=defaults,
     )
-    
-    with open(full_dest_path, "rb") as f:
-        model_meta.weights.save(relative_dest_path.name, File(f), save=False)
-    model_meta.save()
-
 
     if created:
         logger.info(f"Created new ModelMeta: {model_meta}")
@@ -160,8 +139,8 @@ 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
 
@@ -240,22 +219,14 @@ 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
@@ -273,9 +244,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",
@@ -324,9 +293,7 @@ def infer_default_model_meta_from_hf(model_id: str) -> dict[str, Any]:
     }
 
 
-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.
     """
@@ -340,11 +307,11 @@ def setup_default_from_huggingface_logic(
     )
 
     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)
+    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,
@@ -359,3 +326,99 @@ def setup_default_from_huggingface_logic(
         size_y=meta["size_y"],
         description=meta["description"],
     )
+
+
+def validate_and_fix_ai_model_metadata_logic():
+    """
+    Validates that all AI models have proper active metadata and fixes any issues.
+    This prevents the "No model metadata found for this model" error.
+
+    Returns:
+        dict: Summary of fixes applied
+    """
+    from ..administration.ai.ai_model import AiModel
+    from ..label.label_set import LabelSet
+
+    summary = {"models_checked": 0, "models_fixed": 0, "metadata_created": 0, "active_meta_set": 0, "errors": []}
+
+    try:
+        all_models = AiModel.objects.all()
+        summary["models_checked"] = all_models.count()
+
+        for model in all_models:
+            logger.info(f"Validating model: {model.name}")
+
+            # Check if model has metadata versions
+            metadata_count = model.metadata_versions.count()
+
+            if metadata_count == 0:
+                # Create metadata for models that don't have any
+                logger.info(f"Creating metadata for {model.name}")
+
+                # Use existing labelset or create default
+                labelset = LabelSet.objects.first()
+                if not labelset:
+                    labelset = LabelSet.objects.create(name="default_colonoscopy_labels", description="Default colonoscopy classification labels")
+
+                # Import here to avoid circular imports
+                from .model_meta import ModelMeta
+
+                # Create basic metadata
+                meta = ModelMeta.objects.create(
+                    name=model.name,
+                    version="1.0",
+                    model=model,
+                    labelset=labelset,
+                    activation="sigmoid" if "classification" in model.name else "sigmoid",
+                    mean="0.485,0.456,0.406",  # ImageNet defaults
+                    std="0.229,0.224,0.225",  # ImageNet defaults
+                    size_x=224,
+                    size_y=224,
+                    axes="CHW",
+                    batchsize=32,
+                    num_workers=4,
+                    description=f"Auto-generated metadata for {model.name}",
+                )
+
+                model.active_meta = meta
+                model.save()
+                summary["models_fixed"] += 1
+                summary["metadata_created"] += 1
+                logger.info(f"Created and set metadata for {model.name}")
+
+            elif not model.active_meta:
+                # Model has metadata but no active meta set
+                first_meta = model.metadata_versions.first()
+                if first_meta:
+                    logger.info(f"Setting active metadata for {model.name}")
+                    model.active_meta = first_meta
+                    model.save()
+                    summary["models_fixed"] += 1
+                    summary["active_meta_set"] += 1
+                    logger.info(f"Set active metadata: {first_meta.name} v{first_meta.version}")
+                else:
+                    error_msg = f"No metadata versions available for {model.name}"
+                    logger.warning(error_msg)
+                    summary["errors"].append(error_msg)
+
+            else:
+                logger.info(f"Model {model.name} has valid active metadata: {model.active_meta}")
+
+        # Verify all models can get latest version
+        logger.info("Testing model metadata access...")
+        for model in all_models:
+            try:
+                latest = model.get_latest_version()
+                logger.info(f"✅ {model.name}: {latest}")
+            except Exception as e:
+                error_msg = f"Model {model.name} metadata test failed: {e}"
+                logger.error(error_msg)
+                summary["errors"].append(error_msg)
+
+        return summary
+
+    except Exception as e:
+        error_msg = f"Validation failed: {e}"
+        logger.error(error_msg)
+        summary["errors"].append(error_msg)
+        return summary