[AZ-180] Refactor detection event handling and improve SSE support

- Updated the detection image endpoint to require a channel ID for event streaming.
- Introduced a new endpoint for streaming detection events, allowing clients to receive real-time updates.
- Enhanced the internal buffering mechanism for detection events to manage multiple channels.
- Refactored the inference module to support the new event handling structure.

Made-with: Cursor

e2e/conftest.py

@@ -1,6 +1,9 @@
+import json
 import os
 import random
+import threading
 import time
+import uuid
 from contextlib import contextmanager
 from pathlib import Path
 
@@ -75,12 +78,83 @@ def auth_headers(jwt_token):
     return {"Authorization": f"Bearer {jwt_token}"} if jwt_token else {}
 
 
+@pytest.fixture
+def channel_id():
+    return str(uuid.uuid4())
+
+
+@pytest.fixture(scope="session")
+def image_detect(http_client, auth_headers):
+    def _detect(image_bytes, filename="img.jpg", config=None, timeout=30):
+        cid = str(uuid.uuid4())
+        headers = {**auth_headers, "X-Channel-Id": cid}
+        detections = []
+        errors = []
+        done = threading.Event()
+        connected = threading.Event()
+
+        def _listen():
+            try:
+                with http_client.get(
+                    f"/detect/events/{cid}",
+                    stream=True,
+                    timeout=timeout + 2,
+                    headers=auth_headers,
+                ) as resp:
+                    resp.raise_for_status()
+                    connected.set()
+                    for ev in sseclient.SSEClient(resp).events():
+                        if not ev.data or not str(ev.data).strip():
+                            continue
+                        data = json.loads(ev.data)
+                        if data.get("mediaStatus") == "AIProcessing":
+                            detections.extend(data.get("annotations", []))
+                        if data.get("mediaStatus") in ("AIProcessed", "Error"):
+                            break
+            except BaseException as e:
+                errors.append(e)
+            finally:
+                connected.set()
+                done.set()
+
+        th = threading.Thread(target=_listen, daemon=True)
+        th.start()
+        connected.wait(timeout=5)
+
+        data_form = {}
+        if config:
+            data_form["config"] = config
+
+        t0 = time.perf_counter()
+        r = http_client.post(
+            "/detect/image",
+            files={"file": (filename, image_bytes, "image/jpeg")},
+            data=data_form,
+            headers=headers,
+            timeout=timeout,
+        )
+        done.wait(timeout=timeout)
+        elapsed_ms = (time.perf_counter() - t0) * 1000.0
+
+        assert r.status_code == 202, f"Expected 202, got {r.status_code}: {r.text}"
+        assert not errors, f"SSE errors: {errors}"
+
+        th.join(timeout=1)
+        return detections, elapsed_ms
+
+    return _detect
+
+
 @pytest.fixture
 def sse_client_factory(http_client, auth_headers):
     @contextmanager
-    def _open(media_id: str):
-        with http_client.get(f"/detect/{media_id}", stream=True,
-                             timeout=600, headers=auth_headers) as resp:
+    def _open(channel_id: str):
+        with http_client.get(
+            f"/detect/events/{channel_id}",
+            stream=True,
+            timeout=600,
+            headers=auth_headers,
+        ) as resp:
             resp.raise_for_status()
             yield sseclient.SSEClient(resp)
 
@@ -201,19 +275,52 @@ def corrupt_image():
     return random.randbytes(1024)
 
 
-
 @pytest.fixture(scope="module")
 def warm_engine(http_client, image_small, auth_headers):
     deadline = time.time() + 120
-    files = {"file": ("warm.jpg", image_small, "image/jpeg")}
-    consecutive_errors = 0
     last_status = None
+    consecutive_errors = 0
+
     while time.time() < deadline:
+        cid = str(uuid.uuid4())
+        headers = {**auth_headers, "X-Channel-Id": cid}
+        done = threading.Event()
+
+        def _listen(cid=cid):
+            try:
+                with http_client.get(
+                    f"/detect/events/{cid}",
+                    stream=True,
+                    timeout=35,
+                    headers=auth_headers,
+                ) as resp:
+                    resp.raise_for_status()
+                    for ev in sseclient.SSEClient(resp).events():
+                        if not ev.data or not str(ev.data).strip():
+                            continue
+                        data = json.loads(ev.data)
+                        if data.get("mediaStatus") == "AIProcessed":
+                            break
+            except Exception:
+                pass
+            finally:
+                done.set()
+
+        th = threading.Thread(target=_listen, daemon=True)
+        th.start()
+        time.sleep(0.1)
+
         try:
-            r = http_client.post("/detect/image", files=files, headers=auth_headers)
-            if r.status_code == 200:
-                return
+            r = http_client.post(
+                "/detect/image",
+                files={"file": ("warm.jpg", image_small, "image/jpeg")},
+                headers=headers,
+            )
             last_status = r.status_code
+            if r.status_code == 202:
+                done.wait(timeout=30)
+                th.join(timeout=1)
+                return
             if r.status_code >= 500:
                 consecutive_errors += 1
                 if consecutive_errors >= 5:
@@ -225,5 +332,8 @@ def warm_engine(http_client, image_small, auth_headers):
                 consecutive_errors = 0
         except OSError:
             consecutive_errors = 0
+
+        th.join(timeout=1)
         time.sleep(2)
+
     pytest.fail(f"engine warm-up timed out after 120s (last status: {last_status})")