media-engine 0.1.0__py3-none-any.whl

media_engine/routers/models.py

@@ -0,0 +1,211 @@
+"""Model checking endpoints."""
+
+import logging
+import threading
+import time
+import uuid
+
+from fastapi import APIRouter, HTTPException
+
+from media_engine.config import get_free_memory_gb
+from media_engine.extractors import (
+    unload_clip_model,
+    unload_face_model,
+    unload_qwen_model,
+    unload_whisper_model,
+    unload_yolo_model,
+)
+
+router = APIRouter(tags=["models"])
+logger = logging.getLogger(__name__)
+
+# Store for model check results
+_model_check_results: dict[str, dict] = {}
+_model_check_status: dict[str, str] = {}  # "running", "complete", "error"
+
+
+def _run_model_checks(check_id: str) -> None:
+    """Background task to check which models can load."""
+    from media_engine.extractors.clip import get_clip_backend
+    from media_engine.extractors.objects_qwen import _get_qwen_model
+
+    results: dict[str, dict] = {}
+    _model_check_status[check_id] = "running"
+
+    try:
+        # Test Qwen 2B
+        logger.info("Testing Qwen 2B model...")
+        start = time.time()
+        try:
+            _get_qwen_model("Qwen/Qwen2-VL-2B-Instruct")
+            results["qwen_2b"] = {
+                "canLoad": True,
+                "error": None,
+                "loadTimeSeconds": round(time.time() - start, 1),
+            }
+            unload_qwen_model()
+        except Exception as e:
+            results["qwen_2b"] = {
+                "canLoad": False,
+                "error": str(e),
+                "loadTimeSeconds": round(time.time() - start, 1),
+            }
+
+        # Test Whisper large-v3
+        logger.info("Testing Whisper large-v3 model...")
+        start = time.time()
+        try:
+            from media_engine.config import has_cuda, is_apple_silicon
+
+            if is_apple_silicon():
+                # Create a tiny silent audio file to test model loading
+                import tempfile
+                import wave
+
+                with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+                    temp_path = f.name
+                    # Write a minimal valid WAV file (0.1 second of silence)
+                    with wave.open(f.name, "w") as wav:
+                        wav.setnchannels(1)
+                        wav.setsampwidth(2)
+                        wav.setframerate(16000)
+                        wav.writeframes(b"\x00" * 3200)  # 0.1s of silence
+
+                try:
+                    import mlx_whisper  # type: ignore[import-not-found]
+
+                    # This will load the model and transcribe the silent audio
+                    mlx_whisper.transcribe(
+                        temp_path,
+                        path_or_hf_repo="mlx-community/whisper-large-v3-mlx",
+                    )
+                finally:
+                    import os
+
+                    os.unlink(temp_path)
+            elif has_cuda():
+                from faster_whisper import WhisperModel  # type: ignore[import-not-found]
+
+                WhisperModel("large-v3", device="cuda")
+            else:
+                import whisper  # type: ignore[import-not-found]
+
+                whisper.load_model("large-v3")
+            results["whisper_large"] = {
+                "canLoad": True,
+                "error": None,
+                "loadTimeSeconds": round(time.time() - start, 1),
+            }
+            unload_whisper_model()
+        except Exception as e:
+            results["whisper_large"] = {
+                "canLoad": False,
+                "error": str(e),
+                "loadTimeSeconds": round(time.time() - start, 1),
+            }
+
+        # Test CLIP
+        logger.info("Testing CLIP model...")
+        start = time.time()
+        try:
+            get_clip_backend()
+            results["clip"] = {
+                "canLoad": True,
+                "error": None,
+                "loadTimeSeconds": round(time.time() - start, 1),
+            }
+            unload_clip_model()
+        except Exception as e:
+            results["clip"] = {
+                "canLoad": False,
+                "error": str(e),
+                "loadTimeSeconds": round(time.time() - start, 1),
+            }
+
+        # Test YOLO
+        logger.info("Testing YOLO model...")
+        start = time.time()
+        try:
+            from ultralytics import YOLO  # type: ignore[import-not-found]
+
+            YOLO("yolov8m.pt")
+            results["yolo"] = {
+                "canLoad": True,
+                "error": None,
+                "loadTimeSeconds": round(time.time() - start, 1),
+            }
+            unload_yolo_model()
+        except Exception as e:
+            results["yolo"] = {
+                "canLoad": False,
+                "error": str(e),
+                "loadTimeSeconds": round(time.time() - start, 1),
+            }
+
+        # Test Face detection (DeepFace)
+        logger.info("Testing Face detection model...")
+        start = time.time()
+        try:
+            from deepface import DeepFace  # type: ignore[import-not-found]
+
+            DeepFace.build_model("Facenet")
+            results["faces"] = {
+                "canLoad": True,
+                "error": None,
+                "loadTimeSeconds": round(time.time() - start, 1),
+            }
+            unload_face_model()
+        except Exception as e:
+            results["faces"] = {
+                "canLoad": False,
+                "error": str(e),
+                "loadTimeSeconds": round(time.time() - start, 1),
+            }
+
+        _model_check_results[check_id] = {
+            "results": results,
+            "freeMemoryGb": get_free_memory_gb(),
+        }
+        _model_check_status[check_id] = "complete"
+        logger.info(f"Model check {check_id} complete: {results}")
+
+    except Exception as e:
+        logger.error(f"Model check {check_id} failed: {e}")
+        _model_check_status[check_id] = "error"
+        _model_check_results[check_id] = {"error": str(e)}
+
+
+@router.post("/check-models")
+async def start_model_check():
+    """Start checking which models can actually load.
+
+    Returns immediately with a check_id. Poll GET /check-models/{check_id} for results.
+    Takes 30-60 seconds to complete.
+    """
+    check_id = str(uuid.uuid4())[:8]
+
+    # Start background thread
+    thread = threading.Thread(target=_run_model_checks, args=(check_id,), daemon=True)
+    thread.start()
+
+    return {"check_id": check_id, "status": "running"}
+
+
+@router.get("/check-models/{check_id}")
+async def get_model_check_result(check_id: str):
+    """Get the result of a model check.
+
+    Returns status: "running", "complete", or "error".
+    When complete, includes models dict with load results.
+    """
+    status = _model_check_status.get(check_id, "not_found")
+
+    if status == "not_found":
+        raise HTTPException(status_code=404, detail=f"Check ID {check_id} not found")
+
+    if status == "running":
+        return {"check_id": check_id, "status": "running"}
+
+    # Complete or error - return results
+    result = _model_check_results.get(check_id, {})
+    return {"check_id": check_id, "status": status, **result}

media_engine/routers/settings.py

@@ -0,0 +1,87 @@
+"""Settings endpoints."""
+
+import logging
+
+from fastapi import APIRouter
+
+from media_engine.config import get_settings, reload_settings, save_config_to_file
+from media_engine.schemas import SettingsResponse, SettingsUpdate
+
+router = APIRouter(tags=["settings"])
+logger = logging.getLogger(__name__)
+
+
+@router.get("/settings", response_model=SettingsResponse)
+async def get_settings_endpoint():
+    """Get current settings.
+
+    Returns all settings with sensitive values (like hf_token) masked.
+    """
+    settings = get_settings()
+    return SettingsResponse(
+        api_version=settings.api_version,
+        log_level=settings.log_level,
+        whisper_model=settings.whisper_model,
+        fallback_language=settings.fallback_language,
+        hf_token_set=bool(settings.hf_token),
+        diarization_model=settings.diarization_model,
+        face_sample_fps=settings.face_sample_fps,
+        object_sample_fps=settings.object_sample_fps,
+        min_face_size=settings.min_face_size,
+        object_detector=settings.object_detector,
+        qwen_model=settings.qwen_model,
+        qwen_frames_per_scene=settings.qwen_frames_per_scene,
+        yolo_model=settings.yolo_model,
+        clip_model=settings.clip_model,
+        ocr_languages=settings.ocr_languages,
+        temp_dir=settings.temp_dir,
+    )
+
+
+@router.put("/settings", response_model=SettingsResponse)
+async def update_settings(update: SettingsUpdate):
+    """Update settings.
+
+    Only provided fields are updated. Changes are persisted to config file.
+    Set hf_token to empty string to clear it.
+    """
+    settings = get_settings()
+
+    # Update only provided fields
+    update_data = update.model_dump(exclude_unset=True)
+
+    for field, value in update_data.items():
+        if field == "hf_token":
+            # Allow clearing token with empty string
+            if value == "":
+                value = None
+            setattr(settings, field, value)
+        else:
+            setattr(settings, field, value)
+
+    # Save to config file
+    save_config_to_file(settings)
+
+    # Reload to ensure consistency
+    new_settings = reload_settings()
+
+    logger.info(f"Settings updated: {list(update_data.keys())}")
+
+    return SettingsResponse(
+        api_version=new_settings.api_version,
+        log_level=new_settings.log_level,
+        whisper_model=new_settings.whisper_model,
+        fallback_language=new_settings.fallback_language,
+        hf_token_set=bool(new_settings.hf_token),
+        diarization_model=new_settings.diarization_model,
+        face_sample_fps=new_settings.face_sample_fps,
+        object_sample_fps=new_settings.object_sample_fps,
+        min_face_size=new_settings.min_face_size,
+        object_detector=new_settings.object_detector,
+        qwen_model=new_settings.qwen_model,
+        qwen_frames_per_scene=new_settings.qwen_frames_per_scene,
+        yolo_model=new_settings.yolo_model,
+        clip_model=new_settings.clip_model,
+        ocr_languages=new_settings.ocr_languages,
+        temp_dir=new_settings.temp_dir,
+    )

media_engine/routers/utils.py

@@ -0,0 +1,135 @@
+"""Utility endpoints."""
+
+import logging
+import os
+import signal
+import threading
+import time
+
+from fastapi import APIRouter, HTTPException
+
+router = APIRouter(tags=["utils"])
+logger = logging.getLogger(__name__)
+
+
+@router.post("/shutdown")
+async def shutdown_engine():
+    """Gracefully shutdown the engine.
+
+    Call this before killing the process to ensure clean resource cleanup.
+    """
+    from media_engine.app import cleanup_resources
+
+    logger.info("Shutdown requested via API")
+    cleanup_resources()
+
+    # Schedule process exit after response is sent
+    def delayed_exit():
+        time.sleep(0.5)
+        os.kill(os.getpid(), signal.SIGTERM)
+
+    thread = threading.Thread(target=delayed_exit, daemon=True)
+    thread.start()
+
+    return {"status": "shutting_down"}
+
+
+@router.get("/extractors")
+async def list_extractors():
+    """List available extractors and their descriptions."""
+    return {
+        "extractors": [
+            {
+                "name": "metadata",
+                "description": "Video metadata (duration, resolution, codec, device, GPS)",
+                "enable_flag": "enable_metadata",
+            },
+            {
+                "name": "transcript",
+                "description": "Audio transcription using Whisper",
+                "enable_flag": "enable_transcript",
+            },
+            {
+                "name": "scenes",
+                "description": "Scene boundary detection",
+                "enable_flag": "enable_scenes",
+            },
+            {
+                "name": "faces",
+                "description": "Face detection with embeddings",
+                "enable_flag": "enable_faces",
+            },
+            {
+                "name": "objects",
+                "description": "Object detection with YOLO (fast, bounding boxes)",
+                "enable_flag": "enable_objects",
+            },
+            {
+                "name": "visual",
+                "description": "Scene descriptions with Qwen2-VL (slower, richer)",
+                "enable_flag": "enable_visual",
+            },
+            {
+                "name": "clip",
+                "description": "CLIP visual embeddings per scene",
+                "enable_flag": "enable_clip",
+            },
+            {
+                "name": "ocr",
+                "description": "Text extraction from video frames",
+                "enable_flag": "enable_ocr",
+            },
+            {
+                "name": "telemetry",
+                "description": "GPS/flight path (always extracted automatically)",
+            },
+        ]
+    }
+
+
+@router.post("/encode_text")
+async def encode_text(request: dict):
+    """Encode a text query to a CLIP embedding for text-to-image search.
+
+    Request body:
+        text: str - The text query to encode
+        model_name: str (optional) - CLIP model name (e.g., "ViT-B-32")
+        translate: bool (optional) - Whether to translate non-English queries to English (default: true)
+
+    Returns:
+        embedding: list[float] - The normalized CLIP embedding (512 or 768 dimensions)
+        model: str - The model used for encoding
+        original_text: str - The original query text
+        translated_text: str - The text that was actually encoded (may be translated)
+        detected_language: str | None - Detected language of the original text
+        was_translated: bool - Whether the text was translated
+    """
+    from media_engine.extractors.clip import encode_text_query, get_clip_backend
+    from media_engine.extractors.translate import translate_query_for_clip
+
+    text = request.get("text", "")
+    if not text:
+        raise HTTPException(status_code=400, detail="Text query is required")
+
+    model_name = request.get("model_name")
+    enable_translation = request.get("translate", True)
+
+    try:
+        # Translate query if needed
+        translated_text, detected_lang, was_translated = translate_query_for_clip(text, enable_translation=enable_translation)
+
+        # Encode the (possibly translated) text
+        embedding = encode_text_query(translated_text, model_name)
+        backend = get_clip_backend(model_name)
+
+        return {
+            "embedding": embedding,
+            "model": backend.get_model_name(),
+            "original_text": text,
+            "translated_text": translated_text,
+            "detected_language": detected_lang,
+            "was_translated": was_translated,
+        }
+    except Exception as e:
+        logger.error(f"Text encoding failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))