Upload folder using huggingface_hub

.env

@@ -28,12 +28,12 @@ DATABASE_URL=sqlite+aiosqlite:///./emailval.db
 # NOTE: free-tier databases support ONLY db 0 0 -- one database per logical store.
 
 # Main cache -- db 0 of credible-kangaroo-120640
-REDIS_URL=rediss://default:gQAAAAAAAddAAQIgcDIwNGY2YmFkNThiMDI0ODhlODMxY2RkMjk3NmE5MThmOA@credible-kangaroo-120640.upstash.io:6379/0?ssl_cert_reqs=none
+REDIS_URL=rediss://default:gQAAAAAAA4vQAAIgcDEwZGE3NTU5MTU1ZjY0OTZlOWUxN2QwMjY1ZTlhMzViNA@new-parrot-232400.upstash.io:6379
 REDIS_CACHE_TTL=86400
 # Celery broker -- db 0 of immortal-gar-118475
-CELERY_BROKER_URL=rediss://default:gQAAAAAAAc7LAQIgcDFlNWNlNjEyZDlhN2I0YzdmOTEzNjk1ODQ3OTk5MTcyOA@immortal-gar-118475.upstash.io:6379/0?ssl_cert_reqs=none
+CELERY_BROKER_URL=rediss://default:gQAAAAAAA4vQAAIgcDEwZGE3NTU5MTU1ZjY0OTZlOWUxN2QwMjY1ZTlhMzViNA@new-parrot-232400.upstash.io:6379
 # Celery result backend -- db 0 of exciting-gannet-119131
-CELERY_RESULT_BACKEND=rediss://default:gQAAAAAAAdFbAQIgcDFhMGZjMjc3YzAxNGQ0ZDM1YWNhN2RlZTI2ZWI1NGY5ZQ@exciting-gannet-119131.upstash.io:6379/0?ssl_cert_reqs=none
+CELERY_RESULT_BACKEND=rediss://default:gQAAAAAAA4vQAAIgcDEwZGE3NTU5MTU1ZjY0OTZlOWUxN2QwMjY1ZTlhMzViNA@new-parrot-232400.upstash.io:6379
 
 # --- CORS ---
 CORS_ORIGINS=["http://localhost:5173","http://localhost:3000","http://127.0.0.1:5173","https://sitcod3-bridge-modul-x-api.hf.space","https://uranusmediaconnection-dot.github.io","https://frontend-j6yuq34u0-sitcod3lab-2797s-projects.vercel.app","https://frontend-grm2qel63-sitcod3lab-2797s-projects.vercel.app","https://frontend-seven-rose-23.vercel.app"]

app/api/routes.py

@@ -21,6 +21,14 @@ from ..db import repo
 _background_tasks: set[asyncio.Task] = set()
 _bulk_semaphore = asyncio.Semaphore(settings.bulk_concurrency)
 
+# Celery task handle (module level so the routing is testable/patchable).
+# Import failure degrades to the background-task path; Celery itself is only
+# required when celery_bulk_enabled=True.
+try:
+    from ..tasks.celery_tasks import bulk_validate_task  # noqa: E402
+except Exception:  # pragma: no cover - celery not installed
+    bulk_validate_task = None
+
 router = APIRouter()
 
 
@@ -159,7 +167,8 @@ async def validate_bulk(request: BulkEmailRequest):
     # .delay() would block retrying the Redis connection.
     try:
         from ..utils.cache import redis_available
-        use_celery = await redis_available()
+        use_celery = (settings.celery_bulk_enabled
+                      and await redis_available())
         print(f"[BULK] Redis available: {use_celery}")
     except Exception as e:
         print(f"[BULK] Redis check failed: {str(e)}")
@@ -167,7 +176,6 @@ async def validate_bulk(request: BulkEmailRequest):
 
     if use_celery:
         try:
-            from ..tasks.celery_tasks import bulk_validate_task
             task = bulk_validate_task.delay(request.emails, request.webhook_url, request.deep)
             # Record the job in Supabase so it can be tracked across restarts
             if settings.enable_db_persistence:

app/config.py

@@ -63,6 +63,11 @@ class Settings(BaseSettings):
     # gateway list (dead hotspot IPs) makes every lookup burn the full timeout
     # and fail — see dns_check.build_resolver.
     dns_nameservers: list[str] = ["1.1.1.1", "8.8.8.8"]
+    # Bulk validation only routes through Celery on hosts that actually run a
+    # worker. The HF Space runs uvicorn alone (Dockerfile CMD), so a reachable
+    # Redis must not by itself select the Celery branch — jobs would sit in
+    # the queue forever. Opt in on the VPS deployment.
+    celery_bulk_enabled: bool = False
     max_bulk_emails: int = 10000
     rate_limit_per_minute: int = 60
     bulk_sync_chunk_size: int = 50  # Process this many emails at a time in sync mode

app/utils/cache.py

@@ -77,8 +77,13 @@ async def get_redis():
                 url,
                 encoding="utf-8",
                 decode_responses=True,
-                socket_connect_timeout=2,
-                socket_timeout=2
+                # The TLS handshake to Upstash measures ~750-850 ms on some
+                # networks; a 2 s cap killed the very first PING at exactly
+                # the timeout (observed live), which made every cache op pay
+                # the full budget and trip the breaker. 5 s connects reliably
+                # while the breaker still fails fast on real outages.
+                socket_connect_timeout=5,
+                socket_timeout=5,
             )
             await _redis_client.ping()
         except Exception:

tests/test_bulk_async.py

@@ -99,6 +99,49 @@ class BulkAsyncTests(unittest.TestCase):
         self.assertEqual(body["status"], "completed")
         self.assertEqual(len(body["results"]), 1)
 
+    def test_redis_available_but_flag_off_uses_background_path(self):
+        """Redis being reachable must NOT switch bulk to Celery on its own.
+
+        The deployed Space runs uvicorn only (Dockerfile CMD) — no Celery
+        worker. If a live Redis alone selected the Celery branch, every bulk
+        job would sit in the queue forever and the Results page would show
+        "processing" indefinitely. The explicit flag (default off) is the
+        opt-in for hosts that actually run a worker.
+        """
+        with (
+            patch("app.utils.cache.redis_available",
+                  new=AsyncMock(return_value=True)),
+            patch("app.api.routes.settings.enable_db_persistence", False),
+            patch("app.api.routes.settings.celery_bulk_enabled", False),
+        ):
+            r = client.post("/api/v1/validate/bulk",
+                            json={"emails": ["a@b.test"]})
+
+        self.assertEqual(r.status_code, 200)
+        body = r.json()
+        self.assertNotEqual(body["task_id"], "sync")
+        self.assertIn("status", body)
+
+    def test_flag_on_and_redis_available_uses_celery(self):
+        from app.tasks.celery_tasks import bulk_validate_task  # noqa: F401
+
+        fake_task = MagicMock()
+        fake_task.id = "celery-123"
+        with (
+            patch("app.utils.cache.redis_available",
+                  new=AsyncMock(return_value=True)),
+            patch("app.api.routes.settings.enable_db_persistence", False),
+            patch("app.api.routes.settings.celery_bulk_enabled", True),
+            patch("app.api.routes.bulk_validate_task.delay",
+                  return_value=fake_task) as delay_mock,
+        ):
+            r = client.post("/api/v1/validate/bulk",
+                            json={"emails": ["a@b.test"]})
+
+        self.assertEqual(r.status_code, 200)
+        self.assertEqual(r.json()["task_id"], "celery-123")
+        delay_mock.assert_called_once()
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_ml_async.py

@@ -94,7 +94,10 @@ class NonBlockingInferenceTests(unittest.IsolatedAsyncioTestCase):
             predict_async(m, ["c [SEP] d.test"]),
         )
         elapsed = time.perf_counter() - t0
-        self.assertLess(elapsed, 0.55, f"inferences serialised ({elapsed:.2f}s)")
+        # Serial execution would take ~0.8 s (two full sleeps); anything
+        # comfortably below that proves overlap. 0.7 leaves scheduling slack
+        # on a loaded machine while still failing on serialisation.
+        self.assertLess(elapsed, 0.7, f"inferences serialised ({elapsed:.2f}s)")
 
 
 if __name__ == "__main__":