OTVision 0.6.5__tar.gz → 0.6.6__tar.gz

{otvision-0.6.5 → otvision-0.6.6}/OTVision/application/detect/detected_frame_factory.py

@@ -20,6 +20,7 @@ class DetectedFrameFactory:
 
         return DetectedFrame(
             source=frame[FrameKeys.source],
+            output=frame[FrameKeys.output],
             no=frame[FrameKeys.frame],
             occurrence=frame[FrameKeys.occurrence],
             detections=detections,

{otvision-0.6.5 → otvision-0.6.6}/OTVision/detect/otdet_file_writer.py

@@ -62,7 +62,7 @@ class OtdetFileWriter:
         detect_config = config.detect
 
         actual_frames = len(event.frames)
-        if (expected_duration := detect_config.expected_duration) is not None:
+        if expected_duration := detect_config.expected_duration:
             actual_fps = actual_frames / expected_duration.total_seconds()
         else:
             actual_fps = actual_frames / source_metadata.duration.total_seconds()

{otvision-0.6.5 → otvision-0.6.6}/OTVision/detect/rtsp_input_source.py

@@ -31,6 +31,7 @@ RETRY_SECONDS = 1
 
 class Counter:
     def __init__(self, start_value: int = 0) -> None:
+        self._start_value = start_value
         self.__counter = start_value
 
     def increment(self) -> None:
@@ -39,6 +40,9 @@ class Counter:
     def get(self) -> int:
         return self.__counter
 
+    def reset(self) -> None:
+        self.__counter = self._start_value
+
 
 class RtspInputSource(InputSourceDetect):
 
@@ -68,6 +72,10 @@ class RtspInputSource(InputSourceDetect):
     def flush_buffer_size(self) -> int:
         return self.stream_config.flush_buffer_size
 
+    @property
+    def fps(self) -> float:
+        return self.config.convert.output_fps
+
     def __init__(
         self,
         subject: Subject[FlushEvent],
@@ -82,6 +90,9 @@ class RtspInputSource(InputSourceDetect):
         self._get_current_config = get_current_config
         self._current_stream: str | None = None
         self._current_video_capture: VideoCapture | None = None
+        self._stream_start_time: datetime = self._datetime_provider.provide()
+        self._current_video_start_time = self._stream_start_time
+        self._outdated = True
 
     @property
     def _video_capture(self) -> VideoCapture:
@@ -106,20 +117,30 @@ class RtspInputSource(InputSourceDetect):
         return self._current_video_capture
 
     def produce(self) -> Generator[Frame, None, None]:
-        start_time = self._datetime_provider.provide()
+        self._stream_start_time = self._datetime_provider.provide()
+        self._current_video_start_time = self._stream_start_time
         while not self.should_stop():
             if (frame := self._read_next_frame()) is not None:
                 self._frame_counter.increment()
+                occurrence = self._datetime_provider.provide()
+
+                if self._outdated:
+                    self._current_video_start_time = occurrence
+                    self._outdated = False
 
                 yield Frame(
                     data=convert_frame_to_rgb(frame),  # YOLO expects RGB
                     frame=self.current_frame_number,
                     source=self.rtsp_url,
-                    occurrence=self._datetime_provider.provide(),
+                    output=self.create_output(),
+                    occurrence=occurrence,
                 )
                 if self.flush_condition_met():
-                    self._notify(start_time)
-        self._notify(start_time)
+                    self._notify()
+                    self._outdated = True
+                    self._frame_counter.reset()
+
+        self._notify()
 
     def _init_video_capture(self, source: str) -> VideoCapture:
         cap = VideoCapture(source)
@@ -152,24 +173,16 @@ class RtspInputSource(InputSourceDetect):
     def flush_condition_met(self) -> bool:
         return self.current_frame_number % self.flush_buffer_size == 0
 
-    def _notify(self, start_time: datetime) -> None:
+    def _notify(self) -> None:
         frame_width = int(self._video_capture.get(CAP_PROP_FRAME_WIDTH))
         frame_height = int(self._video_capture.get(CAP_PROP_FRAME_HEIGHT))
-        fps = self.config.convert.output_fps
-        _start_time = calculate_start_time(
-            start_time, self.current_frame_number, fps, self.flush_buffer_size
-        )
         frames = (
             self.flush_buffer_size
             if self.current_frame_number % self.flush_buffer_size == 0
             else self.current_frame_number % self.flush_buffer_size
         )
-        duration = timedelta(seconds=round(frames / fps))
-        output_filename = (
-            f"{self.stream_config.name}_FR{round(fps)}"
-            f"_{_start_time.strftime(DATETIME_FORMAT)}.mp4"
-        )
-        output = str(self.stream_config.save_dir / output_filename)
+        duration = timedelta(seconds=round(frames / self.fps))
+        output = self.create_output()
         self._subject.notify(
             FlushEvent.create(
                 source=self.rtsp_url,
@@ -177,22 +190,17 @@ class RtspInputSource(InputSourceDetect):
                 duration=duration,
                 source_width=frame_width,
                 source_height=frame_height,
-                source_fps=fps,
-                start_time=_start_time,
+                source_fps=self.fps,
+                start_time=self._current_video_start_time,
             )
         )
 
-
-def calculate_start_time(
-    start: datetime, current_frame_number: int, fps: float, flush_buffer_size: int
-) -> datetime:
-    offset_in_frames = (
-        current_frame_number // flush_buffer_size - 1
-    ) * flush_buffer_size
-    if offset_in_frames == 0:
-        return start
-    offset_in_seconds = offset_in_frames / fps
-    return start + timedelta(seconds=offset_in_seconds)
+    def create_output(self) -> str:
+        output_filename = (
+            f"{self.stream_config.name}_FR{round(self.fps)}"
+            f"_{self._current_video_start_time.strftime(DATETIME_FORMAT)}.mp4"
+        )
+        return str(self.stream_config.save_dir / output_filename)
 
 
 def convert_frame_to_rgb(frame: ndarray) -> ndarray:

{otvision-0.6.5 → otvision-0.6.6}/OTVision/detect/timestamper.py

@@ -61,6 +61,7 @@ class VideoTimestamper(Timestamper):
             data=frame[FrameKeys.data],
             frame=frame[FrameKeys.frame],
             source=frame[FrameKeys.source],
+            output=frame[FrameKeys.output],
             occurrence=occurrence,
         )
 

{otvision-0.6.5 → otvision-0.6.6}/OTVision/detect/video_input_source.py

@@ -116,6 +116,7 @@ class VideoSource(InputSourceDetect):
                                     FrameKeys.data: rotated_image,
                                     FrameKeys.frame: frame_number,
                                     FrameKeys.source: str(video_file),
+                                    FrameKeys.output: str(video_file),
                                 }
                             )
                         else:
@@ -124,6 +125,7 @@ class VideoSource(InputSourceDetect):
                                     FrameKeys.data: None,
                                     FrameKeys.frame: frame_number,
                                     FrameKeys.source: str(video_file),
+                                    FrameKeys.output: str(video_file),
                                 }
                             )
                         counter += 1
@@ -206,8 +208,9 @@ class VideoSource(InputSourceDetect):
     def __add_occurrence(self, timestamper: Timestamper, frame: dict) -> Frame:
         updated = timestamper.stamp(frame)
         return Frame(
-            data=updated["data"],
-            frame=updated["frame"],
-            source=updated["source"],
-            occurrence=updated["occurrence"],
+            data=updated[FrameKeys.data],
+            frame=updated[FrameKeys.frame],
+            source=updated[FrameKeys.source],
+            output=updated[FrameKeys.output],
+            occurrence=updated[FrameKeys.occurrence],
         )

{otvision-0.6.5 → otvision-0.6.6}/OTVision/domain/frame.py

@@ -20,6 +20,7 @@ class FrameKeys:
     frame: Literal["frame"] = "frame"
     source: Literal["source"] = "source"
     occurrence: Literal["occurrence"] = "occurrence"
+    output: Literal["output"] = "output"
 
 
 class Frame(TypedDict):
@@ -35,6 +36,7 @@ class Frame(TypedDict):
     data: Optional[ndarray]
     frame: int
     source: str
+    output: str
     occurrence: datetime
 
 
@@ -49,6 +51,7 @@ class DetectedFrame:
         no (FrameNo): Frame number.
         occurrence (datetime): Time stamp, at which frame was recorded.
         source (str): Source from where frame was obtained, e.g. video file path.
+        output (str): Output file name, e.g. video file name.
         detections (Sequence[Detection]): A sequence of Detections occurring in frame.
         image (Optional[ndarray]): Optional image data of frame.
     """
@@ -56,6 +59,7 @@ class DetectedFrame:
     no: FrameNo
     occurrence: datetime
     source: str
+    output: str
     detections: Sequence[Detection]
     image: Optional[ndarray] = None
 
@@ -64,6 +68,7 @@ class DetectedFrame:
             no=self.no,
             occurrence=self.occurrence,
             source=self.source,
+            output=self.output,
             detections=self.detections,
             image=None,
         )
@@ -153,6 +158,7 @@ class TrackedFrame(DetectedFrame):
             no=self.no,
             occurrence=self.occurrence,
             source=self.source,
+            output=self.output,
             finished_tracks=self.finished_tracks,
             detections=detections,
             image=self.image,

{otvision-0.6.5 → otvision-0.6.6}/OTVision/track/parser/chunk_parser_plugins.py

@@ -62,6 +62,7 @@ class JsonChunkParser(ChunkParser):
                 no=int(key) + frame_offset,
                 occurrence=occurrence,
                 source=str(file),
+                output=str(file),
                 detections=detections,
                 image=None,
             )

{otvision-0.6.5 → otvision-0.6.6}/OTVision/track/tracker/tracker_plugin_iou.py

@@ -222,6 +222,7 @@ class IouTracker(Tracker):
             no=frame.no,
             occurrence=frame.occurrence,
             source=frame.source,
+            output=frame.output,
             detections=tracked_detections,
             image=frame.image,
             finished_tracks=set(finished_track_ids),

{otvision-0.6.5 → otvision-0.6.6}/OTVision/version.py

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

{otvision-0.6.5 → otvision-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OTVision
-Version: 0.6.5
+Version: 0.6.6
 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.5 → otvision-0.6.6}/tests/application/detect/test_detected_frame_factory.py

@@ -16,6 +16,7 @@ class TestDetectedFrameFactory:
 
         assert actual == DetectedFrame(
             source=given_frame[FrameKeys.source],
+            output=given_frame[FrameKeys.output],
             no=given_frame[FrameKeys.frame],
             occurrence=given_frame[FrameKeys.occurrence],
             detections=given_detections,
@@ -28,6 +29,7 @@ class TestDetectedFrameFactory:
             frame=1,
             occurrence=datetime(2020, 1, 1, 12, 1, 1),
             source="path/to/source.mp4",
+            output="path/to/output.mp4",
         )
 
     def create_detections(self) -> list[Detection]:

{otvision-0.6.5 → otvision-0.6.6}/tests/application/detect/test_timestamper.py

@@ -98,6 +98,7 @@ def create_frame_without_occurrence(frame_number: int) -> dict:
         FrameKeys.data: Mock(),
         FrameKeys.frame: frame_number,
         FrameKeys.source: SOURCE,
+        FrameKeys.output: SOURCE,
     }
 
 
@@ -112,5 +113,6 @@ def create_expected_frame(raw_data: dict, occurrence: datetime) -> Frame:
         data=raw_data[FrameKeys.data],
         frame=raw_data[FrameKeys.frame],
         source=raw_data[FrameKeys.source],
+        output=raw_data[FrameKeys.output],
         occurrence=occurrence,
     )

{otvision-0.6.5 → otvision-0.6.6}/tests/detect/test_detected_frame_buffer.py

@@ -47,6 +47,7 @@ class TestDetectedFrameBuffer:
         frame_number = 1
         occurrence = datetime(2020, 1, 1, 12, 0, 0)
         source = "my_source"
+        output = "path/to/output.mp4"
         detections: list[Detection] = create_mocks(3)
         image = Mock()
 
@@ -54,6 +55,7 @@ class TestDetectedFrameBuffer:
             no=frame_number,
             occurrence=occurrence,
             source=source,
+            output=output,
             detections=detections,
             image=image,
         )
@@ -64,6 +66,7 @@ class TestDetectedFrameBuffer:
             no=frame_number,
             occurrence=occurrence,
             source=source,
+            output=output,
             detections=detections,
             image=None,
         )

otvision-0.6.5/tests/detect/test_odet.py → otvision-0.6.6/tests/detect/test_otdet.py

@@ -19,6 +19,7 @@ GIVEN_ACTUAL_DURATION = timedelta(
     hours=36, seconds=33, milliseconds=12, microseconds=15
 )
 EXPECTED_VIDEO_LENGTH = "36:00:33"
+DETECTED_FRAME_OUTPUT = "path/to/output.mp4"
 
 
 def create_expected_video_metadata(
@@ -109,6 +110,7 @@ def create_detected_frame(source: str, frame_number: int) -> DetectedFrame:
     )
     return DetectedFrame(
         source=source,
+        output=DETECTED_FRAME_OUTPUT,
         no=frame_number,
         detections=[detection],
         occurrence=datetime(2020, 1, 1, 12, 0, 10),

{otvision-0.6.5 → otvision-0.6.6}/tests/detect/test_rtsp_input_source.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 from pathlib import Path
+from typing import Any
 from unittest.mock import Mock, call, patch
 
 import pytest
@@ -12,8 +13,11 @@ from OTVision.detect.rtsp_input_source import Counter, RtspInputSource
 from OTVision.domain.frame import Frame
 
 START_TIME = datetime(2020, 1, 1, 12, 0, 0)
+INIT_TIME = START_TIME - timedelta(seconds=1)
 FIRST_OCCURRENCE = START_TIME + timedelta(seconds=1)
 SECOND_OCCURRENCE = FIRST_OCCURRENCE + timedelta(seconds=2)
+THIRD_OCCURRENCE = SECOND_OCCURRENCE + timedelta(seconds=1)
+FOURTH_OCCURRENCE = THIRD_OCCURRENCE + timedelta(seconds=1)
 
 WIDTH = 800
 HEIGHT = 600
@@ -22,9 +26,13 @@ OUTPUT_FPS = 1.0
 FIRST_FRAME_DATA = Mock()
 SECOND_FRAME_DATA = Mock()
 THIRD_FRAME_DATA = Mock()
+FOURTH_FRAME_DATA = Mock()
+FIFTH_FRAME_DATA = Mock()
 
 FIRST_FRAME_RGB_DATA = Mock()
 THIRD_FRAME_RGB_DATA = Mock()
+FOURTH_FRAME_RGB_DATA = Mock()
+FIFTH_FRAME_RGB_DATA = Mock()
 RTSP_URL = "rtsp://192.168.1.100:554/1/h264preview"
 STREAM_NAME = "OTCamera15"
 STREAM_SAVE_DIR = Path("path/to/save/dir")
@@ -35,6 +43,22 @@ STREAM_CONFIG = StreamConfig(
     save_dir=STREAM_SAVE_DIR,
     flush_buffer_size=FLUSH_BUFFER_SIZE,
 )
+FIRST_OUTPUT = str(
+    STREAM_CONFIG.save_dir / f"{STREAM_NAME}_FR{round(OUTPUT_FPS)}"
+    f"_{FIRST_OCCURRENCE.strftime(DATETIME_FORMAT)}.mp4"
+)
+THIRD_OUTPUT = str(
+    STREAM_CONFIG.save_dir / f"{STREAM_NAME}_FR{round(OUTPUT_FPS)}"
+    f"_{FIRST_OCCURRENCE.strftime(DATETIME_FORMAT)}.mp4"
+)
+FOURTH_OUTPUT = str(
+    STREAM_CONFIG.save_dir / f"{STREAM_NAME}_FR{round(OUTPUT_FPS)}"
+    f"_{THIRD_OCCURRENCE.strftime(DATETIME_FORMAT)}.mp4"
+)
+FIFTH_OUTPUT = str(
+    STREAM_CONFIG.save_dir / f"{STREAM_NAME}_FR{round(OUTPUT_FPS)}"
+    f"_{THIRD_OCCURRENCE.strftime(DATETIME_FORMAT)}.mp4"
+)
 
 
 @dataclass
@@ -62,6 +86,8 @@ class TestRtspInputSource:
         actual = list()
         actual.append(next(generator))
         actual.append(next(generator))
+        actual.append(next(generator))
+        actual.append(next(generator))
         target.stop()
         with pytest.raises(StopIteration):
             next(generator)
@@ -71,43 +97,48 @@ class TestRtspInputSource:
                 data=FIRST_FRAME_RGB_DATA,
                 frame=1,
                 source=RTSP_URL,
+                output=FIRST_OUTPUT,
                 occurrence=FIRST_OCCURRENCE,
             ),
             Frame(
                 data=THIRD_FRAME_RGB_DATA,
                 frame=2,
                 source=RTSP_URL,
+                output=THIRD_OUTPUT,
                 occurrence=SECOND_OCCURRENCE,
             ),
+            Frame(
+                data=FOURTH_FRAME_RGB_DATA,
+                frame=1,
+                source=RTSP_URL,
+                output=FOURTH_OUTPUT,
+                occurrence=THIRD_OCCURRENCE,
+            ),
+            Frame(
+                data=FIFTH_FRAME_RGB_DATA,
+                frame=2,
+                source=RTSP_URL,
+                output=FIFTH_OUTPUT,
+                occurrence=FOURTH_OCCURRENCE,
+            ),
         ]
-        assert given.datetime_provider.provide.call_count == 3
-        assert given.video_capture_instance.read.call_count == 3
+        assert given.datetime_provider.provide.call_count == 6
+        assert given.video_capture_instance.read.call_count == 5
         assert given.convert_frame_to_rgb.call_args_list == [
             call(FIRST_FRAME_DATA),
             call(THIRD_FRAME_DATA),
+            call(FOURTH_FRAME_DATA),
+            call(FIFTH_FRAME_DATA),
         ]
         assert given.video_capture_instance.get.call_args_list == [
             call(CAP_PROP_FRAME_WIDTH),
             call(CAP_PROP_FRAME_HEIGHT),
             call(CAP_PROP_FRAME_WIDTH),
             call(CAP_PROP_FRAME_HEIGHT),
+            call(CAP_PROP_FRAME_WIDTH),
+            call(CAP_PROP_FRAME_HEIGHT),
         ]
-        expected_flush_event = FlushEvent.create(
-            source=RTSP_URL,
-            output=str(
-                STREAM_SAVE_DIR / f"{STREAM_NAME}_FR{round(OUTPUT_FPS)}"
-                f"_{START_TIME.strftime(DATETIME_FORMAT)}.mp4"
-            ),
-            duration=timedelta(seconds=2),
-            source_width=WIDTH,
-            source_height=HEIGHT,
-            source_fps=OUTPUT_FPS,
-            start_time=START_TIME,
-        )
-        assert given.subject.notify.call_args_list == [
-            call(expected_flush_event),
-            call(expected_flush_event),
-        ]
+        assert given.subject.notify.call_args_list == create_expected_flush_events()
 
 
 def create_given(video_capture: Mock, convert_frame_to_rgb: Mock) -> Given:
@@ -131,22 +162,36 @@ def create_target_with(
         (True, FIRST_FRAME_DATA),
         (False, SECOND_FRAME_DATA),
         (True, THIRD_FRAME_DATA),
+        (True, FOURTH_FRAME_DATA),
+        (True, FIFTH_FRAME_DATA),
     ]
 
     given.video_capture_instance.isOpened.return_value = video_capture_is_opened
     given.video_capture_instance.read.side_effect = frames
-    given.video_capture_instance.get.side_effect = [WIDTH, HEIGHT, WIDTH, HEIGHT]
+    given.video_capture_instance.get.side_effect = [
+        WIDTH,
+        HEIGHT,
+        WIDTH,
+        HEIGHT,
+        WIDTH,
+        HEIGHT,
+    ]
 
     given.datetime_provider.provide.side_effect = [
+        INIT_TIME,
         START_TIME,
         FIRST_OCCURRENCE,
         SECOND_OCCURRENCE,
+        THIRD_OCCURRENCE,
+        FOURTH_OCCURRENCE,
     ]
     given.video_capture.return_value = given.video_capture_instance
 
     given.convert_frame_to_rgb.side_effect = [
         FIRST_FRAME_RGB_DATA,
         THIRD_FRAME_RGB_DATA,
+        FOURTH_FRAME_RGB_DATA,
+        FIFTH_FRAME_RGB_DATA,
     ]
     given.config.stream = STREAM_CONFIG
     given.config.convert.output_fps = OUTPUT_FPS
@@ -158,3 +203,26 @@ def create_target_with(
         frame_counter=given.frame_counter,
         get_current_config=given.get_current_config,
     )
+
+
+def create_expected_flush_events() -> list[Any]:
+    return [
+        call(create_expected_flush_event(FIRST_OCCURRENCE)),
+        call(create_expected_flush_event(THIRD_OCCURRENCE)),
+        call(create_expected_flush_event(THIRD_OCCURRENCE)),
+    ]
+
+
+def create_expected_flush_event(start_time: datetime) -> FlushEvent:
+    return FlushEvent.create(
+        source=RTSP_URL,
+        output=str(
+            STREAM_SAVE_DIR / f"{STREAM_NAME}_FR{round(OUTPUT_FPS)}"
+            f"_{start_time.strftime(DATETIME_FORMAT)}.mp4"
+        ),
+        duration=timedelta(seconds=2),
+        source_width=WIDTH,
+        source_height=HEIGHT,
+        source_fps=OUTPUT_FPS,
+        start_time=start_time,
+    )

{otvision-0.6.5 → otvision-0.6.6}/tests/detect/test_video_input_source.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass
 from itertools import chain
 from pathlib import Path
-from unittest.mock import MagicMock, Mock, _Call, call, patch
+from typing import Any
+from unittest.mock import MagicMock, Mock, call, patch
 
 import pytest
 from av import VideoFrame
@@ -91,6 +92,7 @@ class TestVideoSource:
                     FrameKeys.data: rotated_frame,
                     FrameKeys.frame: frame_number,
                     FrameKeys.source: str(cyclist_mp4),
+                    FrameKeys.output: str(cyclist_mp4),
                 }
             )
             for frame_number, rotated_frame in enumerate(
@@ -137,6 +139,7 @@ class TestVideoSource:
                         FrameKeys.data: rotated_frame,
                         FrameKeys.frame: frame_number,
                         FrameKeys.source: str(input_file),
+                        FrameKeys.output: str(input_file),
                     }
                 )
                 for frame_number, rotated_frame in enumerate(
@@ -291,7 +294,7 @@ class TestVideoSource:
 
 def create_expected_frame_call(
     data: Mock | None, frame_number: int, source: Path
-) -> _Call:
+) -> Any:
     return call(
         {
             FrameKeys.data: data,

{otvision-0.6.5 → otvision-0.6.6}/tests/detect/yolo_test.py

@@ -178,4 +178,6 @@ class TestYoloDetector:
         if has_data:
             data = Mock()
 
-        return Frame(data=data, frame=frame_no, source=source, occurrence=Mock())
+        return Frame(
+            data=data, frame=frame_no, source=source, output=source, occurrence=Mock()
+        )

{otvision-0.6.5 → otvision-0.6.6}/tests/track/helper/data_builder.py

@@ -83,6 +83,7 @@ class DataBuilder:
             no=frame_number,
             occurrence=occurrence_date,
             source=str(self.input_file_path),
+            output=str(self.input_file_path),
             detections=[],
             image=None,
         )
@@ -170,6 +171,7 @@ class DataBuilder:
             no=frame_number,
             occurrence=occurrence_date,
             source=str(self.input_file_path),
+            output=str(self.input_file_path),
             detections=[
                 self.create_classification_object(label, confidence, x, y, w, h)
                 for i in range(0, number_of_classifications)
@@ -253,6 +255,7 @@ def create_frame(
         no=frame_number,
         occurrence=occurrence,
         source=str(input_file_path),
+        output=str(input_file_path),
         detections=detections,
         image=None,
     )

{otvision-0.6.5 → otvision-0.6.6}/tests/track/test_frame_chunk.py

@@ -72,6 +72,7 @@ class TestTrackedChunk(unittest.TestCase):
             no=no,
             occurrence=self._mock_occurrence(no),
             source=str(self.mock_file),
+            output=str(self.mock_file),
             detections=[self._mock_detection(track_id=i) for i in observed],
             image=None,
             finished_tracks=finished,

{otvision-0.6.5 → otvision-0.6.6}/tests/track/test_tracking_data_structures.py

@@ -194,6 +194,7 @@ class TestTrackedFrame:
                 no=frame.no,
                 occurrence=frame.occurrence,
                 source=frame.source,
+                output=frame.output,
                 detections=tuple(tracked_dets),
                 image=None,
                 finished_tracks=finished_ids,
@@ -273,6 +274,7 @@ class TestFinishedFrame(unittest.TestCase):
             no=no,
             occurrence=self._mock_occurrence(no),
             source=self.mock_file,
+            output=self.mock_file,
             detections=[self._mock_detection(track_id=i) for i in observed],
             image=None,
             finished_tracks=finished,