Split detections (#539)

* compute cone during seq creation

* round values

* drop seq with cones

* create alerts

* add overlap from triangulation pr

* new alerts strat

* missing init

* missings deps

* use preset variable

* updates routes

* update poetry

* update loc

* error management

* fix on seq case

* use started_at and last_seens_at

* clean output

* missing READ

* add test

* fix style

* test overlap

* mypy

* ruff on test overlap

* import issue

* fix style

* fix deletions to respect fk

* cast

* recompyte alerts after seq annotation

* fix alert update

* style

* style

* adapt test

* ruff on test

* add tests on detections

* increase test on seq

* ruff

* limit lat and lon

* rename fonction

* rename to sequence_azimuth

* rename sequence camera azimuth

* add AlertBase

* adapt e2e

* new headers

* header fix

* header fix

* add triangulation test

* drop dupicate

* imprrove test for label_sequence

* style

* add seq delete test

* fix(api): resolve merge conflict and fix router

* style

* test(api): add test coverage for organization deletion of alerts and alert sequences

* put back old delete

* style org

* style test

* fix test org

* reduce complexity

* style

* use pose_id

* style

* adapt test

* split seq based on bbox

* adapt test

* prevent UnboundLocalError

* fix mypy client

* complete client

* style

* ruff

* rename camera_azimuth

* fix test

* client/

* fix test

* reorder router

* srtyle

* mypy

* fix merge error in unitest

* ruff fix

* check to use the pose azimuth

* split bboxes

* allow cam to get pose

* allow camera to manage poses

* add split detections test

* increase test on client

* increase coverage on create det

* fix codacy warning adding if

* increase coverage

* simplify

* bboxes to bbox in db field and endpoints read

* added correct constraints on bbox and other_bboxes length

---------

Co-authored-by: fe51 <[email protected]>

Author: MateoLostanlen

client/pyroclient/client.py

@@ -4,7 +4,7 @@
 # See LICENSE or go to <https://opensource.org/licenses/Apache-2.0> for full license details.
 
 from enum import Enum
-from typing import Dict, List, Optional, Tuple
+from typing import Dict, List, Tuple
 from urllib.parse import urljoin
 
 import requests
@@ -22,6 +22,7 @@ class ClientRoute(str, Enum):
     CAMERAS_HEARTBEAT = "cameras/heartbeat"
     CAMERAS_IMAGE = "cameras/image"
     CAMERAS_FETCH = "cameras/"
+    CAMERAS_BY_ID = "cameras/{camera_id}"
     # POSES
     POSES_CREATE = "poses/"
     POSES_BY_ID = "poses/{pose_id}"
@@ -180,17 +181,36 @@ def create_pose(
             timeout=self.timeout,
         )
 
-    def patch_pose(
+    def get_current_poses(self, camera_id: int | None = None) -> Response:
+        """Fetch poses for the authenticated camera.
+
+        For admin/agent tokens, provide camera_id to retrieve poses via the camera endpoint.
+        """
+        if camera_id is not None:
+            return requests.get(
+                urljoin(self._route_prefix, ClientRoute.CAMERAS_BY_ID.format(camera_id=camera_id)),
+                headers=self.headers,
+                timeout=self.timeout,
+            )
+        return requests.get(
+            urljoin(self._route_prefix, ClientRoute.POSES_CREATE),
+            headers=self.headers,
+            timeout=self.timeout,
+        )
+
+    def update_pose(
         self,
         pose_id: int,
         azimuth: float | None = None,
         patrol_id: int | None = None,
     ) -> Response:
         """Update a pose
 
-        >>> api_client.patch_pose(pose_id=1, azimuth=90.0)
+        >>> api_client.update_pose(pose_id=1, azimuth=90.0)
         """
-        payload = {}
+        if azimuth is None and patrol_id is None:
+            raise ValueError("Either azimuth or patrol_id must be provided")
+        payload: Dict[str, float | int] = {}
         if azimuth is not None:
             payload["azimuth"] = azimuth
         if patrol_id is not None:
@@ -203,6 +223,9 @@ def patch_pose(
             timeout=self.timeout,
         )
 
+    # Backward compatibility alias
+    patch_pose = update_pose
+
     def delete_pose(self, pose_id: int) -> Response:
         """Delete a pose
 
@@ -296,34 +319,30 @@ def delete_occlusion_mask(self, mask_id: int) -> Response:
     def create_detection(
         self,
         media: bytes,
-        azimuth: float,
         bboxes: List[Tuple[float, float, float, float, float]],
-        pose_id: Optional[int] = None,
+        pose_id: int,
     ) -> Response:
         """Notify the detection of a wildfire on the picture taken by a camera.
 
         >>> from pyroclient import Client
         >>> api_client = Client("MY_CAM_TOKEN")
         >>> with open("path/to/my/file.ext", "rb") as f: data = f.read()
-        >>> response = api_client.create_detection(data, azimuth=124.2, bboxes=[(.1,.1,.5,.8,.5)], pose_id=12)
+        >>> response = api_client.create_detection(data, bboxes=[(.1,.1,.5,.8,.5)], pose_id=12)
 
         Args:
             media: byte data of the picture
-            azimuth: the azimuth of the camera when the picture was taken
             bboxes: list of tuples where each tuple is a relative coordinate in order xmin, ymin, xmax, ymax, conf
-            pose_id: optional, pose_id of the detection
+            pose_id: pose_id of the detection
 
         Returns:
             HTTP response
         """
         if not isinstance(bboxes, (list, tuple)) or len(bboxes) == 0 or len(bboxes) > 5:
             raise ValueError("bboxes must be a non-empty list of tuples with a maximum of 5 boxes")
-        data = {
-            "azimuth": azimuth,
+        data: Dict[str, str] = {
             "bboxes": _dump_bbox_to_json(bboxes),
         }
-        if pose_id is not None:
-            data["pose_id"] = pose_id
+        data["pose_id"] = str(pose_id)
         return requests.post(
             urljoin(self._route_prefix, ClientRoute.DETECTIONS_CREATE),
             headers=self.headers,

client/tests/conftest.py

@@ -1,4 +1,5 @@
 import os
+from operator import itemgetter
 from urllib.parse import urljoin
 
 import pytest
@@ -26,7 +27,7 @@ def mock_img():
 
 
 @pytest.fixture(scope="session")
-def cam_token():
+def cam_setup():
     admin_headers = {"Authorization": f"Bearer {SUPERADMIN_TOKEN}"}
     payload = {
         "name": "pyro-camera-01",
@@ -44,11 +45,27 @@ def cam_token():
     payload = {"azimuth": 359, "patrol_id": 1, "camera_id": cam_id}
     response = requests.post(urljoin(API_URL, "poses"), json=payload, headers=admin_headers, timeout=5)
     assert response.status_code == 201
+    pose_id = response.json()["id"]
 
-    # Create a cam token
-    return requests.post(urljoin(API_URL, f"cameras/{cam_id}/token"), headers=admin_headers, timeout=5).json()[
+    cam_token = requests.post(urljoin(API_URL, f"cameras/{cam_id}/token"), headers=admin_headers, timeout=5).json()[
         "access_token"
     ]
+    return {"token": cam_token, "pose_id": pose_id, "camera_id": cam_id}
+
+
+@pytest.fixture(scope="session")
+def cam_token(cam_setup):
+    return itemgetter("token")(cam_setup)
+
+
+@pytest.fixture(scope="session")
+def cam_pose_id(cam_setup):
+    return itemgetter("pose_id")(cam_setup)
+
+
+@pytest.fixture(scope="session")
+def cam_id(cam_setup):
+    return itemgetter("camera_id")(cam_setup)
 
 
 @pytest.fixture(scope="session")

client/tests/test_client.py

@@ -25,8 +25,35 @@ def test_client_constructor(token, host, timeout, expected_error):
             Client(token, host, timeout=timeout)
 
 
+def test_get_current_poses_camera(cam_token, cam_pose_id):
+    cam_client = Client(cam_token, "http://localhost:5050", timeout=10)
+    response = cam_client.get_current_poses()
+    assert response.status_code == 200, response.__dict__
+    poses = response.json()
+    assert isinstance(poses, list)
+    assert any(pose["id"] == cam_pose_id for pose in poses)
+
+
+def test_get_current_poses_admin(cam_id, cam_pose_id):
+    admin_client = Client(pytest.admin_token, "http://localhost:5050", timeout=10)
+    response = admin_client.get_current_poses(camera_id=cam_id)
+    assert response.status_code == 200, response.__dict__
+    payload = response.json()
+    assert isinstance(payload.get("poses"), list)
+    assert any(pose["id"] == cam_pose_id for pose in payload["poses"])
+
+
+def test_update_pose_camera(cam_token, cam_pose_id):
+    cam_client = Client(cam_token, "http://localhost:5050", timeout=10)
+    with pytest.raises(ValueError, match="Either azimuth or patrol_id must be provided"):
+        cam_client.update_pose(cam_pose_id)
+    response = cam_client.update_pose(cam_pose_id, azimuth=123.4)
+    assert response.status_code == 200, response.__dict__
+    assert response.json()["azimuth"] == 123.4
+
+
 @pytest.fixture(scope="session")
-def test_cam_workflow(cam_token, mock_img):
+def test_cam_workflow(cam_token, cam_pose_id, mock_img):
     cam_client = Client(cam_token, "http://localhost:5050", timeout=10)
     response = cam_client.heartbeat()
     assert response.status_code == 200
@@ -37,14 +64,18 @@ def test_cam_workflow(cam_token, mock_img):
     assert isinstance(response.json()["last_image"], str)
     # Check that adding bboxes works
     with pytest.raises(ValueError, match="bboxes must be a non-empty list of tuples"):
-        cam_client.create_detection(mock_img, 123.2, None)
+        cam_client.create_detection(mock_img, None, pose_id=cam_pose_id)
     with pytest.raises(ValueError, match="bboxes must be a non-empty list of tuples"):
-        cam_client.create_detection(mock_img, 123.2, [])
-    response = cam_client.create_detection(mock_img, 123.2, [(0, 0, 1.0, 0.9, 0.5)], pose_id=1)
+        cam_client.create_detection(mock_img, [], pose_id=cam_pose_id)
+    response = cam_client.create_detection(mock_img, [(0, 0, 1.0, 0.9, 0.5)], pose_id=cam_pose_id)
     assert response.status_code == 201, response.__dict__
-    response = cam_client.create_detection(mock_img, 123.2, [(0, 0, 1.0, 0.9, 0.5), (0.2, 0.2, 0.7, 0.7, 0.8)])
+    response = cam_client.create_detection(
+        mock_img,
+        [(0, 0, 1.0, 0.9, 0.5), (0.2, 0.2, 0.7, 0.7, 0.8)],
+        pose_id=cam_pose_id,
+    )
     assert response.status_code == 201, response.__dict__
-    response = cam_client.create_detection(mock_img, 123.2, [(0, 0, 1.0, 0.9, 0.5)])
+    response = cam_client.create_detection(mock_img, [(0, 0, 1.0, 0.9, 0.5)], pose_id=cam_pose_id)
     assert response.status_code == 201, response.__dict__
     return response.json()["id"]
 
@@ -81,4 +112,4 @@ def test_user_workflow(test_cam_workflow, user_token):
     assert len(response.json()) == 1
     response = user_client.fetch_sequences_detections(response.json()[0]["id"])
     assert response.status_code == 200, response.__dict__
-    assert len(response.json()) == 3
+    assert len(response.json()) == 4

scripts/test_e2e.py

@@ -95,6 +95,7 @@ def main(args):
         "azimuth": 45,
     }
     pose_id = api_request("post", f"{args.endpoint}/poses/", agent_auth, payload)["id"]
+    pose_azimuth = payload["azimuth"]
 
     # Take a picture
     file_bytes = requests.get("https://pyronear.org/img/logo.png", timeout=5).content
@@ -149,7 +150,7 @@ def main(args):
     assert sequence["camera_id"] == cam_id
     assert sequence["started_at"] == response.json()["created_at"]
     assert sequence["last_seen_at"] > sequence["started_at"]
-    assert sequence["camera_azimuth"] == response.json()["azimuth"]
+    assert sequence["camera_azimuth"] == pose_azimuth
     # Fetch the latest sequence
     assert len(api_request("get", f"{args.endpoint}/sequences/unlabeled/latest", agent_auth)) == 1
     # Fetch from date

src/app/api/api_v1/endpoints/alerts.py

@@ -37,7 +37,7 @@ async def _fetch_sequences_by_alert_ids(session: AsyncSession, alert_ids: List[i
         select(AlertSequence.alert_id, Sequence)
         .join(Sequence, cast(Any, Sequence.id == AlertSequence.sequence_id))
         .where(AlertSequence.alert_id.in_(alert_ids))  # type: ignore[attr-defined]
-        .order_by(AlertSequence.alert_id, desc(cast(Any, Sequence.last_seen_at)))
+        .order_by(cast(Any, AlertSequence.alert_id), desc(cast(Any, Sequence.last_seen_at)))
     )
     res = await session.exec(seq_stmt)
     for alert_id, sequence in res.all():