media-engine 0.1.0__tar.gz → 0.1.1__tar.gz

{media_engine-0.1.0 → media_engine-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: media-engine
-Version: 0.1.0
+Version: 0.1.1
 Summary: AI-powered video extraction API for metadata, transcripts, faces, scenes, objects, and more
 Project-URL: Repository, https://github.com/thetrainroom/media-engine
 Project-URL: Issues, https://github.com/thetrainroom/media-engine/issues
@@ -28,6 +28,8 @@ Requires-Dist: psutil>=5.9.0
 Requires-Dist: pydantic-settings>=2.0.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: scenedetect[opencv]>=0.6.0
+Requires-Dist: tf-keras>=2.16.0
+Requires-Dist: transformers>=4.40.0
 Requires-Dist: uvicorn>=0.27.0
 Requires-Dist: webrtcvad>=2.0.10
 Provides-Extra: cpu
@@ -58,7 +60,6 @@ Provides-Extra: qwen
 Requires-Dist: accelerate>=0.30.0; extra == 'qwen'
 Requires-Dist: qwen-vl-utils>=0.0.8; extra == 'qwen'
 Requires-Dist: torch>=2.0.0; extra == 'qwen'
-Requires-Dist: transformers>=4.40.0; extra == 'qwen'
 Description-Content-Type: text/markdown
 
 # Media Engine

{media_engine-0.1.0 → media_engine-0.1.1}/media_engine/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)
 
 __commit_id__ = commit_id = None

{media_engine-0.1.0 → media_engine-0.1.1}/media_engine/routers/models.py

@@ -33,22 +33,38 @@ def _run_model_checks(check_id: str) -> None:
     _model_check_status[check_id] = "running"
 
     try:
-        # Test Qwen 2B
-        logger.info("Testing Qwen 2B model...")
-        start = time.time()
+        # Test Qwen 2B (requires qwen extras: pip install media-engine[qwen])
         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()
+            import importlib.util
+
+            if importlib.util.find_spec("transformers") is None:
+                results["qwen_2b"] = {
+                    "canLoad": False,
+                    "error": "transformers not installed. Install with: pip install media-engine[qwen]",
+                    "loadTimeSeconds": 0,
+                }
+            else:
+                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),
+                    }
         except Exception as e:
             results["qwen_2b"] = {
                 "canLoad": False,
                 "error": str(e),
-                "loadTimeSeconds": round(time.time() - start, 1),
+                "loadTimeSeconds": 0,
             }
 
         # Test Whisper large-v3

{media_engine-0.1.0 → media_engine-0.1.1}/pyproject.toml

@@ -25,6 +25,8 @@ dependencies = [
     "ffmpeg-python>=0.2.0",
     "scenedetect[opencv]>=0.6.0",
     "deepface>=0.0.79",
+    "tf-keras>=2.16.0",  # Required by deepface with TensorFlow 2.16+
+    "transformers>=4.40.0",  # Required for Qwen VLM
     "paddleocr>=2.7.0",
     "paddlepaddle>=2.5.0",
     "webrtcvad>=2.0.10",
@@ -70,7 +72,6 @@ cpu = [
     "ultralytics>=8.0.0",
 ]
 qwen = [
-    "transformers>=4.40.0",
     "accelerate>=0.30.0",
     "qwen-vl-utils>=0.0.8",
     "torch>=2.0.0",

media_engine-0.1.1/tests/test_dependencies.py

@@ -0,0 +1,176 @@
+"""Test that all required dependencies are importable."""
+
+import importlib
+import importlib.util
+
+import pytest
+
+# Modules that crash on import (e.g., paddle on macOS) - check with find_spec only
+SPEC_CHECK_ONLY = {"paddle"}
+
+
+class TestBaseDependencies:
+    """Test base dependencies that are always required."""
+
+    @pytest.mark.parametrize(
+        "module",
+        [
+            "fastapi",
+            "uvicorn",
+            "pydantic",
+            "pydantic_settings",
+            "ffmpeg",
+            "scenedetect",
+            "deepface",
+            "tf_keras",
+            "transformers",
+            "paddleocr",
+            "paddle",
+            "webrtcvad",
+            "psutil",
+            "langdetect",
+            "httpx",
+        ],
+    )
+    def test_base_dependency_importable(self, module: str):
+        """Verify base dependency can be imported."""
+        if module in SPEC_CHECK_ONLY:
+            # Some modules crash on import but are installed - just check spec
+            if importlib.util.find_spec(module) is None:
+                pytest.fail(f"Base dependency '{module}' not installed")
+            return
+
+        try:
+            importlib.import_module(module)
+        except ImportError as e:
+            pytest.fail(f"Base dependency '{module}' not importable: {e}")
+
+
+class TestMLXDependencies:
+    """Test MLX dependencies (Apple Silicon)."""
+
+    @pytest.mark.parametrize(
+        "module",
+        [
+            "mlx",
+            "mlx_whisper",
+            "open_clip",
+            "torch",
+            "ultralytics",
+        ],
+    )
+    def test_mlx_dependency_importable(self, module: str):
+        """Verify MLX dependency can be imported if MLX extras installed."""
+        if importlib.util.find_spec("mlx") is None:
+            pytest.skip("MLX extras not installed")
+        try:
+            importlib.import_module(module)
+        except ImportError as e:
+            pytest.fail(f"MLX dependency '{module}' not importable: {e}")
+
+
+class TestCUDADependencies:
+    """Test CUDA dependencies (NVIDIA GPU)."""
+
+    @pytest.mark.parametrize(
+        "module",
+        [
+            "faster_whisper",
+            "open_clip",
+            "torch",
+            "ultralytics",
+        ],
+    )
+    def test_cuda_dependency_importable(self, module: str):
+        """Verify CUDA dependency can be imported if CUDA extras installed."""
+        if importlib.util.find_spec("faster_whisper") is None:
+            pytest.skip("CUDA extras not installed")
+        try:
+            importlib.import_module(module)
+        except ImportError as e:
+            pytest.fail(f"CUDA dependency '{module}' not importable: {e}")
+
+
+class TestCPUDependencies:
+    """Test CPU dependencies (fallback)."""
+
+    @pytest.mark.parametrize(
+        "module",
+        [
+            "whisper",
+            "open_clip",
+            "torch",
+            "ultralytics",
+        ],
+    )
+    def test_cpu_dependency_importable(self, module: str):
+        """Verify CPU dependency can be imported if CPU extras installed."""
+        if importlib.util.find_spec("whisper") is None:
+            pytest.skip("CPU extras not installed")
+        try:
+            importlib.import_module(module)
+        except ImportError as e:
+            pytest.fail(f"CPU dependency '{module}' not importable: {e}")
+
+
+class TestQwenDependencies:
+    """Test Qwen dependencies (VLM)."""
+
+    @pytest.mark.parametrize(
+        "module",
+        [
+            "accelerate",
+            "qwen_vl_utils",
+        ],
+    )
+    def test_qwen_dependency_importable(self, module: str):
+        """Verify Qwen dependency can be imported if Qwen extras installed."""
+        if importlib.util.find_spec("qwen_vl_utils") is None:
+            pytest.skip("Qwen extras not installed")
+        try:
+            importlib.import_module(module)
+        except ImportError as e:
+            pytest.fail(f"Qwen dependency '{module}' not importable: {e}")
+
+
+class TestMediaEngineImports:
+    """Test that media_engine modules are importable."""
+
+    @pytest.mark.parametrize(
+        "module",
+        [
+            "media_engine",
+            "media_engine.main",
+            "media_engine.config",
+            "media_engine.schemas",
+            "media_engine.extractors",
+            "media_engine.extractors.metadata",
+            "media_engine.extractors.scenes",
+            "media_engine.extractors.ocr",
+            "media_engine.extractors.telemetry",
+        ],
+    )
+    def test_media_engine_module_importable(self, module: str):
+        """Verify media_engine module can be imported."""
+        try:
+            importlib.import_module(module)
+        except ImportError as e:
+            pytest.fail(f"Module '{module}' not importable: {e}")
+
+    def test_extractors_with_torch(self):
+        """Verify extractors requiring torch are importable when torch is available."""
+        if importlib.util.find_spec("torch") is None:
+            pytest.skip("torch not installed")
+
+        modules = [
+            "media_engine.extractors.faces",
+            "media_engine.extractors.objects",
+            "media_engine.extractors.objects_qwen",
+            "media_engine.extractors.clip",
+            "media_engine.extractors.transcribe",
+        ]
+        for module in modules:
+            try:
+                importlib.import_module(module)
+            except ImportError as e:
+                pytest.fail(f"Module '{module}' not importable: {e}")