OTVision 0.6.12__tar.gz → 0.6.14__tar.gz

{otvision-0.6.12 → otvision-0.6.14}/OTVision/application/config_parser.py

@@ -73,6 +73,11 @@ from OTVision.application.config import (
     _UndistortConfig,
 )
 from OTVision.domain.serialization import Deserializer
+from OTVision.plugin.ffmpeg_video_writer import (
+    ConstantRateFactor,
+    EncodingSpeed,
+    VideoCodec,
+)
 
 
 class InvalidOtvisionConfigError(Exception):
@@ -190,6 +195,21 @@ class ConfigParser:
         if expected_duration is not None:
             expected_duration = timedelta(seconds=int(expected_duration))
 
+        if video_codec := data.get(VIDEO_CODEC, None):
+            video_codec = VideoCodec(video_codec)
+        else:
+            video_codec = DetectConfig.video_codec
+
+        if encoding_speed := data.get(ENCODING_SPEED, None):
+            encoding_speed = EncodingSpeed(encoding_speed)
+        else:
+            encoding_speed = DetectConfig.encoding_speed
+
+        if data.get(CRF, None) is not None:
+            crf = ConstantRateFactor[data[CRF]]
+        else:
+            crf = DetectConfig.crf
+
         start_time = self._parse_start_time(data)
         return DetectConfig(
             paths=sources,
@@ -202,9 +222,9 @@ class ConfigParser:
             detect_start=data.get(DETECT_START, DetectConfig.detect_start),
             detect_end=data.get(DETECT_END, DetectConfig.detect_end),
             write_video=data.get(WRITE_VIDEO, DetectConfig.write_video),
-            video_codec=data.get(VIDEO_CODEC, DetectConfig.video_codec),
-            encoding_speed=data.get(ENCODING_SPEED, DetectConfig.encoding_speed),
-            crf=data.get(CRF, DetectConfig.crf),
+            video_codec=video_codec,
+            encoding_speed=encoding_speed,
+            crf=crf,
         )
 
     def parse_yolo_config(self, data: dict) -> YoloConfig:

{otvision-0.6.12 → otvision-0.6.14}/OTVision/application/track/ottrk.py

@@ -76,8 +76,9 @@ class OttrkBuilder:
             t_min=self.config.t_min,
             t_miss_max=self.config.t_miss_max,
         )
-        result[dataformat.TRACKING_RUN_ID] = self.config.tracking_run_id
-        result[dataformat.FRAME_GROUP] = self.config.frame_group
+        tracking_metadata = result[dataformat.TRACKING]
+        tracking_metadata[dataformat.TRACKING_RUN_ID] = self.config.tracking_run_id
+        tracking_metadata[dataformat.FRAME_GROUP] = self.config.frame_group
         return result
 
     def _build_data(self) -> list[dict]:

{otvision-0.6.12 → otvision-0.6.14}/OTVision/detect/builder.py

@@ -68,6 +68,8 @@ class DetectBuilder(ABC):
 
     @cached_property
     def configure_logger(self) -> ConfigureLogger:
+        if self._configure_logger is not None:
+            return self._configure_logger
         return ConfigureLogger()
 
     @cached_property
@@ -94,6 +96,8 @@ class DetectBuilder(ABC):
 
     @cached_property
     def current_config(self) -> CurrentConfig:
+        if self.__current_config is not None:
+            return self.__current_config
         return CurrentConfig(Config())
 
     @cached_property
@@ -173,8 +177,15 @@ class DetectBuilder(ABC):
     def detect_config(self) -> DetectConfig:
         return self.current_config.get().detect
 
-    def __init__(self, argv: list[str] | None = None) -> None:
+    def __init__(
+        self,
+        argv: list[str] | None = None,
+        current_config: CurrentConfig | None = None,
+        configure_logger: ConfigureLogger | None = None,
+    ) -> None:
         self.argv = argv
+        self.__current_config = current_config
+        self._configure_logger = configure_logger
 
     @property
     @abstractmethod

{otvision-0.6.12 → otvision-0.6.14}/OTVision/track/stream_ottrk_file_writer.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from typing import Any
 
 from OTVision.application.buffer import Buffer
 from OTVision.application.config import Config, TrackConfig
@@ -66,7 +67,7 @@ class StreamOttrkFileWriter(Buffer[TrackedFrame, OtdetFileWrittenEvent]):
         )
         self._builder.set_config(builder_config)
         last_frame = tracked_frames[-1]
-        self._builder.add_tracked_frames(self._get_buffered_elements())
+        self._builder.add_tracked_frames(tracked_frames)
         self._ottrk_unfinished_tracks = last_frame.unfinished_tracks
         self.reset()
 
@@ -103,9 +104,18 @@ class StreamOttrkFileWriter(Buffer[TrackedFrame, OtdetFileWrittenEvent]):
             )
             logger().warning(f"Unfinished tracks: {self._ottrk_unfinished_tracks}")
             if self.build_condition_fulfilled:
-                ottrk_data = self._builder.build()
-                self.write(ottrk_data)
-                self._in_writing_state = False
+                self._create_ottrk()
+
+    def _create_ottrk(self) -> None:
+        ottrk_data = self._builder.build()
+        self.write(ottrk_data)
+        self.full_reset()
+
+    def full_reset(self) -> None:
+        self._in_writing_state = False
+        self._builder.reset()
+        self._ottrk_unfinished_tracks = set()
+        self._current_output_file = None
 
     def write(self, ottrk: dict) -> None:
         write_json(
@@ -114,3 +124,6 @@ class StreamOttrkFileWriter(Buffer[TrackedFrame, OtdetFileWrittenEvent]):
             filetype=self.config.filetypes.track,
             overwrite=True,
         )
+
+    def force_flush(self, _: Any) -> None:
+        self._create_ottrk()

{otvision-0.6.12 → otvision-0.6.14}/OTVision/version.py

@@ -1,4 +1,4 @@
-__version__ = "v0.6.12"
+__version__ = "v0.6.14"
 
 
 def otdet_version() -> str:

{otvision-0.6.12 → otvision-0.6.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OTVision
-Version: 0.6.12
+Version: 0.6.14
 Summary: OTVision is a core module of the OpenTrafficCam framework to perform object detection and tracking.
 Project-URL: Homepage, https://opentrafficcam.org/
 Project-URL: Documentation, https://opentrafficcam.org/overview/

{otvision-0.6.12 → otvision-0.6.14}/tests/application/test_config_parser.py

@@ -1,3 +1,4 @@
+from datetime import datetime, timedelta
 from pathlib import Path
 from unittest.mock import Mock
 
@@ -5,11 +6,92 @@ import pytest
 
 from OTVision.application.config import (
     Config,
+    DetectConfig,
     StreamConfig,
     TrackConfig,
+    YoloConfig,
     _TrackIouConfig,
 )
 from OTVision.application.config_parser import ConfigParser, InvalidOtvisionConfigError
+from OTVision.plugin.ffmpeg_video_writer import (
+    ConstantRateFactor,
+    EncodingSpeed,
+    VideoCodec,
+)
+
+# Ensure paths are translated to the respective platform (unix, windows)
+VIDEO_1 = str(Path("tests/data/video1.mp4"))
+VIDEO_2 = str(Path("tests/data/video2.mp4"))
+
+
+class TestConfigParser:
+    @pytest.fixture
+    def given_deserializer(self) -> Mock:
+        return Mock()
+
+    @pytest.fixture
+    def given_config_parser(self, given_deserializer: Mock) -> ConfigParser:
+        return ConfigParser(given_deserializer)
+
+    def test_parse_detect_config_with_fully_specified_config(
+        self, given_config_parser: ConfigParser
+    ) -> None:
+        detect_dict = {
+            "PATHS": [VIDEO_1, VIDEO_2],
+            "RUN_CHAINED": False,
+            "YOLO": {
+                "WEIGHTS": "yolov8m.pt",
+                "CONF": 0.35,
+                "IOU": 0.5,
+                "IMGSIZE": 1280,
+                "NORMALIZED": False,
+            },
+            "EXPECTED_DURATION": 3600,
+            "OVERWRITE": False,
+            "HALF_PRECISION": True,
+            "START_TIME": "2025-10-15_14-30-00",
+            "DETECT_START": 10,
+            "DETECT_END": 100,
+            "WRITE_VIDEO": True,
+            "VIDEO_CODEC": "h264_nvenc",
+            "ENCODING_SPEED": "medium",
+            "CRF": "HIGH_QUALITY",
+        }
+
+        result = given_config_parser.parse_detect_config(detect_dict)
+
+        expected = DetectConfig(
+            paths=[VIDEO_1, VIDEO_2],
+            run_chained=False,
+            yolo_config=YoloConfig(
+                weights="yolov8m.pt",
+                conf=0.35,
+                iou=0.5,
+                img_size=1280,
+                normalized=False,
+            ),
+            expected_duration=timedelta(seconds=3600),
+            overwrite=False,
+            half_precision=True,
+            start_time=datetime(2025, 10, 15, 14, 30, 0),
+            detect_start=10,
+            detect_end=100,
+            write_video=True,
+            video_codec=VideoCodec.H264_NVENC,
+            encoding_speed=EncodingSpeed.MEDIUM,
+            crf=ConstantRateFactor.HIGH_QUALITY,
+        )
+        assert result == expected
+
+    def test_parse_detect_config_with_empty_config(
+        self, given_config_parser: ConfigParser
+    ) -> None:
+        detect_dict: dict = {}
+
+        result = given_config_parser.parse_detect_config(detect_dict)
+
+        expected = DetectConfig()
+        assert result == expected
 
 
 class TestConfigParserValidateFlushBufferSupportTrackLifecycle:

{otvision-0.6.12 → otvision-0.6.14}/tests/application/track/test_ottrk.py

@@ -348,6 +348,8 @@ def create_expected_track_metadata(
                 config.t_min,
                 config.t_miss_max,
             ),
+            dataformat.TRACKING_RUN_ID: config.tracking_run_id,
+            dataformat.FRAME_GROUP: config.frame_group,
         },
     }
 
@@ -431,14 +433,11 @@ def create_expected_ottrk(
 ) -> dict:
     otdet_metadata = create_otdet_metadata(actual_duration, expected_duration)
     track_metadata = create_expected_track_metadata(actual_duration, expected_duration)
-    config = create_ottrk_builder_config(actual_duration, expected_duration)
 
     # Add the missing fields that OttrkBuilder adds
     combined_metadata = {
         **otdet_metadata,
         **track_metadata,
-        dataformat.TRACKING_RUN_ID: config.tracking_run_id,
-        dataformat.FRAME_GROUP: config.frame_group,
     }
 
     return {