feat: adding testing into docker and pre-commit

api/dependencies.py

@@ -15,4 +15,4 @@ def get_safety_detection_model(request: HTTPConnection):
 
 
 def get_redis(request: HTTPConnection):
-    return request.app.state.redis
+    return request.app.state.redis

api/routers/camera_stream.py

@@ -1,6 +1,4 @@
-from backend.utils.profiling import profile_step
 from backend.services.pipeline import ProcessingPipeline
-from domain.detection_box_center import calculate_detection_box_center
 from api.dependencies import get_safety_detection_model
 from api.dependencies import get_detection_model, get_depth_model
 import asyncio
@@ -8,18 +6,10 @@ import itertools
 from fastapi import APIRouter, WebSocket, WebSocketDisconnect, Depends
 from api.routers.metrics import (
     active_cameras,
-    decode_duration_seconds,
-    depth_duration_seconds,
-    detection_duration_seconds,
-    frame_processing_duration_seconds,
 )
-from contracts.camera_metadata import CameraMetadata, DetectionMetadata
 import mlflow
 from utils.experiment import log_config
 
-import cv2 as cv
-import numpy as np
-import time
 
 router = APIRouter()
 
@@ -56,7 +46,6 @@ async def websocket_detect(
     step_counter = itertools.count()
     pipeline = ProcessingPipeline(detector, depth_model, safety_detector, redis)
 
-
     # Queue removing old images in case they were being stacked
     frame_queue: asyncio.Queue = asyncio.Queue(maxsize=1)
 
@@ -86,9 +75,13 @@ async def websocket_detect(
                 frame_bytes = await frame_queue.get()
 
                 try:
-                    results = await pipeline.run(camera_id, frame_bytes, next(step_counter))
+                    results = await pipeline.run(
+                        camera_id, frame_bytes, next(step_counter)
+                    )
                 except Exception as e:
-                    logger.warn(f"Error happened while processing a frame in {camera_id}: {e}")
+                    logger.warn(
+                        f"Error happened while processing a frame in {camera_id}: {e}"
+                    )
                     logger.exception(e)
                     continue
 
@@ -99,7 +92,9 @@ async def websocket_detect(
             logger.error(f"Processing Error: {e}", camera_id=camera_id)
             raise
 
-    with mlflow.start_run(run_name=f"camera_{camera_id}", nested=True, parent_run_id=state.mlflow_run_id):
+    with mlflow.start_run(
+        run_name=f"camera_{camera_id}", nested=True, parent_run_id=state.mlflow_run_id
+    ):
         log_config()
 
         try:
@@ -119,4 +114,4 @@ async def websocket_detect(
             await redis.srem(
                 "cameras:active", camera_id
             )  # Remove the camera from redis connected cameras
-            active_cameras.dec()
+            active_cameras.dec()

domain/detection_box_center.py

@@ -1,5 +1,4 @@
-def calculate_detection_box_center(detections, image_width:float):
-
+def calculate_detection_box_center(detections, image_width: float):
     boxes_center = []
     boxes_center_ratio = []
     for box in detections:
@@ -9,4 +8,4 @@ def calculate_detection_box_center(detections, image_width:float):
         boxes_center.append((int(xcenter), int(ycenter)))
         boxes_center_ratio.append(xcenter / image_width)
 
-    return (boxes_center,  boxes_center_ratio)
+    return (boxes_center, boxes_center_ratio)

domain/logger.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 
+
 class Logger(ABC):
     @abstractmethod
     def info(self, msg: str, **kwargs):
@@ -18,4 +19,4 @@ class Logger(ABC):
 
     @abstractmethod
     def exception(self, msg: str, **kwargs):
-        pass
+        pass

services/pipeline.py

@@ -20,9 +20,12 @@ class ProcessingPipeline:
     def _decode_frame(self, fb):
         return cv.imdecode(np.frombuffer(fb, np.uint8), cv.IMREAD_COLOR)
 
-    def _camera_metadata(self, camera_id, safety_detection, depth_points, boxes_center_ratio) -> CameraMetadata:
+    def _camera_metadata(
+        self, camera_id, safety_detection, depth_points, boxes_center_ratio
+    ) -> CameraMetadata:
         detection_metadata = [
-            DetectionMetadata(depth=depth, xRatio=xRatio) for depth, xRatio in zip(depth_points, boxes_center_ratio)
+            DetectionMetadata(depth=depth, xRatio=xRatio)
+            for depth, xRatio in zip(depth_points, boxes_center_ratio)
         ]
         metadata = CameraMetadata(
             camera_id=camera_id,
@@ -31,25 +34,48 @@ class ProcessingPipeline:
         )
         return metadata
 
-    async def run(self, camera_id:str, frame_bytes, frame_count):
+    async def run(self, camera_id: str, frame_bytes, frame_count):
         loop = asyncio.get_running_loop()
 
-        with profile_step("frame_processing_time", decode_duration_seconds, camera_id, frame_count):
-            frame_bytes = await loop.run_in_executor(None, self._decode_frame, frame_bytes)
+        with profile_step(
+            "frame_processing_time", decode_duration_seconds, camera_id, frame_count
+        ):
+            frame_bytes = await loop.run_in_executor(
+                None, self._decode_frame, frame_bytes
+            )
 
-        with profile_step("detection_duration_seconds", detection_duration_seconds, camera_id, frame_count):
-            detection_task = loop.run_in_executor(None, self.detector.detect, frame_bytes)
-            safety_task = loop.run_in_executor(None, self.safety_detector.detect, frame_bytes)
-            detections, safety_detection = await asyncio.gather(detection_task, safety_task)
+        with profile_step(
+            "detection_duration_seconds",
+            detection_duration_seconds,
+            camera_id,
+            frame_count,
+        ):
+            detection_task = loop.run_in_executor(
+                None, self.detector.detect, frame_bytes
+            )
+            safety_task = loop.run_in_executor(
+                None, self.safety_detector.detect, frame_bytes
+            )
+            detections, safety_detection = await asyncio.gather(
+                detection_task, safety_task
+            )
 
-        boxes_center, boxes_center_ratio = calculate_detection_box_center(detections.detections, frame_bytes.shape[1])
+        boxes_center, boxes_center_ratio = calculate_detection_box_center(
+            detections.detections, frame_bytes.shape[1]
+        )
 
         depth_points = []
-        if boxes_center: 
-            with profile_step("depth_duration_seconds", depth_duration_seconds, camera_id, frame_count):
-                depth_points = await loop.run_in_executor(None, self.depth_model.calculate_depth, frame_bytes, boxes_center)
+        if boxes_center:
+            with profile_step(
+                "depth_duration_seconds", depth_duration_seconds, camera_id, frame_count
+            ):
+                depth_points = await loop.run_in_executor(
+                    None, self.depth_model.calculate_depth, frame_bytes, boxes_center
+                )
 
-        metadata = self._camera_metadata(camera_id, safety_detection, depth_points, boxes_center_ratio)
+        metadata = self._camera_metadata(
+            camera_id, safety_detection, depth_points, boxes_center_ratio
+        )
 
         await self.redis.publish("dashboard_stream", metadata.model_dump_json())
         # Even if the camera was disconnected, redis is still going to show its data, which is not accurate.
@@ -61,4 +87,4 @@ class ProcessingPipeline:
         )
 
         # Note that JSONResponse doesn't work here, as it is for HTTP
-        return {"status": 200, "camera_id": camera_id}
+        return {"status": 200, "camera_id": camera_id}

utils/profiling.py

@@ -2,6 +2,7 @@ from contextlib import contextmanager
 import time
 import mlflow
 
+
 @contextmanager
 def profile_step(expr_name: str, prometheus_logger, camera_id, frame_count=None):
     """With statement utility to time block of code"""
@@ -14,7 +15,7 @@ def profile_step(expr_name: str, prometheus_logger, camera_id, frame_count=None)
         duration = round(time.time() - start_time, 4)
         prometheus_logger.labels(camera_id).observe(duration)
         mlflow.log_metric(
-                    expr_name,
-                    duration,
-                    frame_count,
-                )
+            expr_name,
+            duration,
+            frame_count,
+        )