Upload folder using huggingface_hub

app/ml/runtime.py

@@ -115,7 +115,7 @@ _model_lock = threading.Lock()
 
 
 def get_model() -> Optional[EmailRiskModel]:
-    """Process-wide model, built only when the flag and repo are configured."""
+    """Process-wide model, built AND loaded when flag + repo are configured."""
     global _model
     if not settings.ml_disposable_enabled or not settings.ml_model_repo:
         return None
@@ -126,4 +126,7 @@ def get_model() -> Optional[EmailRiskModel]:
                 token=settings.ml_hf_token,
                 batch_size=settings.ml_batch_size,
             )
+            # Load at construction: without this the model fail-opens to None
+            # on every predict and the feature is silently dead (found live).
+            _model.load()
         return _model

tests/test_ml_runtime.py

@@ -14,9 +14,6 @@ class RuntimeLoaderTests(unittest.TestCase):
     """
 
     def test_load_uses_the_injected_factory(self):
-        # Dependency injection: the factory builds the pipeline; the runtime
-        # never imports transformers itself. This is what makes the ML layer
-        # testable without patching a lazy module boundary.
         fake_pipe = MagicMock()
         calls = {}
 
@@ -41,8 +38,6 @@ class RuntimeLoaderTests(unittest.TestCase):
         self.assertIsNone(m._pipeline)
 
     def test_load_uses_pytorch_transformers_by_default(self):
-        # The production factory loads from transformers (PyTorch - the ONNX
-        # export produced garbage predictions, so it was abandoned).
         from app.ml.runtime import default_pipeline_factory
 
         m = EmailRiskModel(repo="user/model", token="t")
@@ -61,7 +56,6 @@ class RuntimeLoaderTests(unittest.TestCase):
         out = m.predict(["x [SEP] tempmail.example"])
 
         self.assertEqual(out, [("DISPOSABLE", 0.93)])
-        # Batching is passed through - 1-row calls are a performance bug.
         fake.assert_called_once()
         self.assertIn("batch_size", fake.call_args.kwargs)
 
@@ -80,40 +74,57 @@ class RuntimeLoaderTests(unittest.TestCase):
         self.assertEqual(m.predict(["a [SEP] b.test"])[0][0], "DISPOSABLE")
 
     def test_predict_accepts_plain_string_batch_return(self):
-        # transformers may return a plain list of dicts OR nested batch lists.
         m = EmailRiskModel(repo="user/model", token="t")
         fake = MagicMock(return_value=[[{"label": "NORMAL", "score": 0.7}]])
         m._pipeline = fake
         m._loaded = True
         self.assertEqual(m.predict(["a [SEP] b.test"]), [("NORMAL", 0.7)])
 
-    def test_config_defaults_are_off(self):
-        from app.config import settings
 
-        self.assertFalse(settings.ml_disposable_enabled)
-        self.assertEqual(settings.ml_model_repo, "")
+class GetModelTests(unittest.TestCase):
+    def setUp(self):
+        from app.ml import runtime
 
+        self.runtime = runtime
+        runtime._model = None  # reset the process-wide singleton
+
+    def tearDown(self):
+        self.runtime._model = None
+
+    def _patch_settings(self, enabled, repo):
+        return (
+            patch.object(self.runtime.settings, "ml_disposable_enabled", enabled),
+            patch.object(self.runtime.settings, "ml_model_repo", repo),
+        )
 
-class GetModelTests(unittest.TestCase):
     def test_returns_none_when_disabled(self):
-        with patch("app.ml.runtime.settings") as fake_settings:
-            fake_settings.ml_disposable_enabled = False
-            fake_settings.ml_model_repo = "user/model"
+        p1, p2 = self._patch_settings(False, "user/model")
+        with p1, p2:
             self.assertIsNone(get_model())
 
     def test_returns_none_when_no_repo(self):
-        with patch("app.ml.runtime.settings") as fake_settings:
-            fake_settings.ml_disposable_enabled = True
-            fake_settings.ml_model_repo = ""
+        p1, p2 = self._patch_settings(True, "")
+        with p1, p2:
             self.assertIsNone(get_model())
 
     def test_returns_model_when_enabled_and_configured(self):
-        with patch("app.ml.runtime.settings") as fake_settings:
-            fake_settings.ml_disposable_enabled = True
-            fake_settings.ml_model_repo = "user/model"
+        p1, p2 = self._patch_settings(True, "user/model")
+        with p1, p2, patch.object(
+            EmailRiskModel, "load", return_value=True
+        ) as load_mock:
             m = get_model()
         self.assertIsInstance(m, EmailRiskModel)
-        self.assertEqual(m.repo, "user/model")
+        # The model must actually be LOADED - an unloaded model fail-opens to
+        # None on every predict, silently disabling the feature (found live).
+        self.assertTrue(load_mock.called)
+
+    def test_load_failure_still_returns_model_but_fail_open(self):
+        p1, p2 = self._patch_settings(True, "user/model")
+        with p1, p2, patch.object(EmailRiskModel, "load", return_value=False):
+            m = get_model()
+        self.assertIsInstance(m, EmailRiskModel)
+        self.assertFalse(m.loaded)
+        self.assertIsNone(m.predict(["a [SEP] b.test"]))
 
 
 if __name__ == "__main__":