OTVision 0.6.7__py3-none-any.whl → 0.6.9__py3-none-any.whl

OTVision/helpers/date.py

@@ -1,5 +1,7 @@
 from datetime import datetime, timezone
 
+from OTVision.dataformat import DATE_FORMAT
+
 
 def parse_date_string_to_utc_datime(date_string: str, date_format: str) -> datetime:
     """Parse a date string to a datetime object with UTC set as timezone.
@@ -24,3 +26,17 @@ def parse_timestamp_string_to_utc_datetime(timestamp: str | float) -> datetime:
         datetime: the datetime object with UTC as set timezone
     """
     return datetime.fromtimestamp(float(timestamp), timezone.utc)
+
+
+def parse_datetime(date: str | float) -> datetime:
+    """Parse a date string or timestamp to a datetime with UTC as timezone.
+
+    Args:
+        date (str | float): the date to parse
+
+    Returns:
+        datetime: the parsed datetime object with UTC set as timezone
+    """
+    if isinstance(date, str) and ("-" in date):
+        return parse_date_string_to_utc_datime(date, DATE_FORMAT)
+    return parse_timestamp_string_to_utc_datetime(date)

OTVision/plugin/ffmpeg_video_writer.py

@@ -0,0 +1,298 @@
+import logging
+from enum import IntEnum, StrEnum
+from pathlib import Path
+from subprocess import PIPE, Popen, TimeoutExpired
+from threading import Thread
+from typing import Callable, Iterator
+
+import ffmpeg
+from numpy import ndarray
+
+from OTVision.application.event.new_video_start import NewVideoStartEvent
+from OTVision.detect.detected_frame_buffer import FlushEvent
+from OTVision.domain.frame import Frame, FrameKeys
+from OTVision.domain.video_writer import VideoWriter
+from OTVision.helpers.log import LOGGER_NAME
+from OTVision.helpers.machine import ON_WINDOWS
+
+VideoSaveLocationStrategy = Callable[[str], str]
+
+BUFFER_SIZE_100MB = 10**8
+DEFAULT_CRF = 23
+VIDEO_SAVE_FILE_POSTFIX = "_processed"
+
+log = logging.getLogger(LOGGER_NAME)
+
+
+class VideoCodec(StrEnum):
+    """Enum of possible video codecs to be used with ffmpeg
+
+    Attributes:
+        H264_SOFTWARE: Software-based H.264 encoder.
+        H264_NVENC: NVIDIA GPU-based H.264 encoder.
+        H264_QSV: Intel Quick Sync Video encoder.
+        H264_VAAPI: Intel/AMD GPU-based H.264 encoder.
+        H264_VIDEOTOOLBOX: macOS hardware encoder.
+    """
+
+    H264_SOFTWARE = "libx264"
+    H264_NVENC = "h264_nvenc"
+    H264_QSV = "h264_qsv"
+    H264_VAAPI = "h264_vaapi"
+    H264_VIDEOTOOLBOX = "h264_videotoolbox"
+
+    @staticmethod
+    def as_list() -> list[str]:
+        return list(VideoCodec.__members__.values())
+
+
+class VideoFormat(StrEnum):
+    RAW = "rawvideo"
+    MP4 = "mp4"
+
+    @staticmethod
+    def as_list() -> list[str]:
+        return list(VideoFormat.__members__.values())
+
+
+class PixelFormat(StrEnum):
+    YUV420P = "yuv420p"  # compatible with most players for H.264
+    RGB24 = "rgb24"
+    BGR24 = "bgr24"
+
+    @staticmethod
+    def as_list() -> list[str]:
+        return list(PixelFormat.__members__.values())
+
+
+class EncodingSpeed(StrEnum):
+    ULTRA_FAST = "ultrafast"
+    SUPER_FAST = "superfast"
+    VERY_FAST = "veryfast"
+    FASTER = "faster"
+    FAST = "fast"
+    MEDIUM = "medium"
+    SLOW = "slow"
+    SLOWER = "slower"
+    VERY_SLOW = "veryslow"
+
+    @staticmethod
+    def as_list() -> list[str]:
+        return list(EncodingSpeed.__members__.values())
+
+
+class ConstantRateFactor(IntEnum):
+    """Adjust quality/size (lower means better quality/larger file).
+    Attributes:
+        LOSSLESS: Perfect quality, massive file size.
+        HIGH_QUALITY: Visually lossless for most eyes.
+        GOOD: High quality, slightly compressed.
+        DEFAULT: x264 default; good balance of size and quality.
+        COMPACT: Acceptable quality for small screens or streaming.
+        LOW_QUALITY: Noticeable compression artifacts; smaller file.
+        WORST_ACCEPTABLE: Very low quality; only for previews or constrained storage.
+    """
+
+    LOSSLESS = 0
+    HIGH_QUALITY = 18
+    GOOD = 20
+    DEFAULT = 23
+    COMPACT = 26
+    LOW_QUALITY = 28
+    WORST_ACCEPTABLE = 35
+
+    @staticmethod
+    def as_list() -> list[str]:
+        return list(ConstantRateFactor.__members__.keys())
+
+
+class FfmpegVideoWriter(VideoWriter):
+
+    @property
+    def _current_video_metadata(self) -> NewVideoStartEvent:
+        if self.__current_video_metadata is None:
+            raise ValueError("FfmpegVideoWriter is not configured yet.")
+        return self.__current_video_metadata
+
+    @property
+    def _ffmpeg_process(self) -> Popen:
+        if self.__ffmpeg_process is None:
+            raise ValueError("FfmpegVideoWriter is not initialized yet.")
+        return self.__ffmpeg_process
+
+    @property
+    def is_open(self) -> bool:
+        return self.__ffmpeg_process is not None
+
+    @property
+    def is_closed(self) -> bool:
+        return self.is_open is False
+
+    def __init__(
+        self,
+        save_location_strategy: VideoSaveLocationStrategy,
+        encoding_speed: EncodingSpeed = EncodingSpeed.FAST,
+        input_format: VideoFormat = VideoFormat.RAW,
+        output_format: VideoFormat = VideoFormat.MP4,
+        input_pixel_format: PixelFormat = PixelFormat.RGB24,
+        output_pixel_format: PixelFormat = PixelFormat.YUV420P,
+        output_video_codec: VideoCodec = VideoCodec.H264_SOFTWARE,
+        constant_rate_factor: ConstantRateFactor = ConstantRateFactor.LOSSLESS,
+    ) -> None:
+        if ON_WINDOWS:
+            log.warning(
+                "Writing every frame into a new video is not supported on Windows."
+            )
+        self._save_location_strategy = save_location_strategy
+        self._encoding_speed = encoding_speed
+        self._input_format = input_format
+        self._output_format = output_format
+        self._input_pixel_format = input_pixel_format
+        self._output_pixel_format = output_pixel_format
+        self._output_video_codec = output_video_codec
+        self.__ffmpeg_process: Popen | None = None
+        self.__current_video_metadata: NewVideoStartEvent | None = None
+        self._constant_rate_factor = constant_rate_factor
+        log.info(
+            "FFmpeg video writer settings: "
+            f"video_codec='{self._output_video_codec.value}', "
+            f"encoding_speed='{self._encoding_speed.value}', "
+            f"crf='{self._constant_rate_factor.value}'"
+        )
+
+    def open(self, output: str, width: int, height: int, fps: float) -> None:
+        self.__ffmpeg_process = self.__create_ffmpeg_process(
+            output_file=output,
+            width=width,
+            height=height,
+            fps=fps,
+        )
+
+    def write(self, image: ndarray) -> None:
+        try:
+            if self._ffmpeg_process.stdin:
+                self._ffmpeg_process.stdin.write(image.tobytes())
+                self._ffmpeg_process.stdin.flush()
+        except BrokenPipeError:
+            # Check if the process is still running
+            if self._ffmpeg_process.poll() is not None:
+                # Process has terminated, get the error message
+                stderr = (
+                    self._ffmpeg_process.stderr.read()
+                    if self._ffmpeg_process.stderr
+                    else b""
+                )
+                log.info(stderr.decode("utf-8", errors="ignore"))
+                raise RuntimeError(
+                    "ffmpeg process terminated unexpectedly: "
+                    f"{stderr.decode('utf-8', errors='ignore')}"
+                )
+            raise  # Re-raise the original exception if the process is still running
+
+    def close(self) -> None:
+        if self.__ffmpeg_process is not None:
+            process_to_cleanup = self._ffmpeg_process
+            self.__ffmpeg_process = None  # Immediately mark as closed
+
+            # Close stdin synchronously (fast operation)
+            try:
+                if process_to_cleanup.stdin:
+                    process_to_cleanup.stdin.flush()
+                    process_to_cleanup.stdin.close()
+            except Exception as cause:
+                log.debug(f"Error closing stdin: {cause}")
+
+            # Handle cleanup in background thread
+            def cleanup_process() -> None:
+                try:
+                    # Just check if it's still running and wait for it
+                    if process_to_cleanup.poll() is None:
+                        # Still running, close stdin and wait
+                        try:
+                            if (
+                                process_to_cleanup.stdin
+                                and not process_to_cleanup.stdin.closed
+                            ):
+                                process_to_cleanup.stdin.close()
+                        except Exception as cause:
+                            log.error(f"Error closing stdin: {cause}")
+
+                        # Simple wait with timeout
+                        try:
+                            process_to_cleanup.wait(timeout=5.0)
+                        except TimeoutExpired:
+                            process_to_cleanup.kill()
+                            try:
+                                process_to_cleanup.wait(timeout=1.0)
+                            except TimeoutExpired:
+                                log.error("Could not kill FFmpeg process")
+
+                    # Log return code if we care
+                    if process_to_cleanup.returncode != 0:
+                        log.debug(
+                            f"FFmpeg ended with code: {process_to_cleanup.returncode}"
+                        )
+
+                except Exception as e:
+                    log.debug(f"Cleanup completed with minor issues: {e}")
+
+            # Start cleanup in daemon thread (won't prevent program exit)
+            cleanup_thread = Thread(target=cleanup_process, daemon=True)
+            cleanup_thread.start()
+
+        self.__current_video_metadata = None
+
+    def notify_on_flush_event(self, event: FlushEvent) -> None:
+        self.close()
+
+    def notify_on_new_video_start(self, event: NewVideoStartEvent) -> None:
+        self.__current_video_metadata = event
+        self.open(event.output, event.width, event.height, event.fps)
+
+    def __create_ffmpeg_process(
+        self, output_file: str, width: int, height: int, fps: float
+    ) -> Popen:
+        save_file = self._save_location_strategy(output_file)
+        cmd = (
+            ffmpeg.input(
+                "pipe:0",
+                format=self._input_format.value,
+                framerate=fps,
+                pix_fmt=self._input_pixel_format.value,
+                s=f"{width}x{height}",
+            )
+            .output(
+                save_file,
+                pix_fmt=self._output_pixel_format.value,
+                vcodec=self._output_video_codec.value,
+                preset=self._encoding_speed.value,
+                crf=self._constant_rate_factor.value,
+                format=self._output_format.value,
+            )
+            .overwrite_output()
+            .compile()
+        )
+
+        process = Popen(
+            cmd,
+            stdin=PIPE,
+            stderr=PIPE,
+            bufsize=BUFFER_SIZE_100MB,
+        )
+        log.info(f"Writing new video file to '{save_file}'.")
+        return process
+
+    def filter(self, pipe: Iterator[Frame]) -> Iterator[Frame]:
+        for frame in pipe:
+            if (image := frame.get(FrameKeys.data)) is not None:
+                self.write(image)
+            yield frame
+
+
+def append_save_suffix_to_save_location(given: str) -> str:
+    filepath = Path(given)
+    return str(Path(filepath).with_stem(f"{filepath.stem}{VIDEO_SAVE_FILE_POSTFIX}"))
+
+
+def keep_original_save_location(given: str) -> str:
+    return given

OTVision/plugin/generate_video.py

@@ -0,0 +1,24 @@
+from functools import cached_property
+
+from OTVision.application.video.generate_video import GenerateVideo
+from OTVision.detect.file_based_detect_builder import FileBasedDetectBuilder
+
+
+class GenerateVideoBuilder(FileBasedDetectBuilder):
+    @cached_property
+    def generate_video(self) -> GenerateVideo:
+        return GenerateVideo(
+            input_source=self.input_source, video_writer=self.video_file_writer
+        )
+
+    def build_generate_video(self) -> GenerateVideo:
+        self.register_observers()
+        return self.generate_video
+
+    def register_observers(self) -> None:
+        self.input_source.subject_new_video_start.register(
+            self.video_file_writer.notify_on_new_video_start
+        )
+        self.input_source.subject_flush.register(
+            self.video_file_writer.notify_on_flush_event
+        )

OTVision/track/builder.py

@@ -7,6 +7,7 @@ from OTVision.application.configure_logger import ConfigureLogger
 from OTVision.application.get_config import GetConfig
 from OTVision.application.get_current_config import GetCurrentConfig
 from OTVision.application.track.get_track_cli_args import GetTrackCliArgs
+from OTVision.application.track.tracking_run_id import StrIdGenerator
 from OTVision.application.track.update_current_track_config import (
     UpdateCurrentTrackConfig,
 )
@@ -20,11 +21,7 @@ from OTVision.domain.serialization import Deserializer
 from OTVision.plugin.yaml_serialization import YamlDeserializer
 from OTVision.track.cli import ArgparseTrackCliParser
 from OTVision.track.exporter.filebased_exporter import FinishedChunkTrackExporter
-from OTVision.track.id_generator import (
-    StrIdGenerator,
-    track_id_generator,
-    tracking_run_uuid_generator,
-)
+from OTVision.track.id_generator import track_id_generator, tracking_run_uuid_generator
 from OTVision.track.model.filebased.frame_chunk import ChunkParser
 from OTVision.track.model.filebased.frame_group import FrameGroupParser
 from OTVision.track.model.track_exporter import FinishedTracksExporter

OTVision/track/id_generator.py

@@ -1,7 +1,5 @@
 import uuid
-from typing import Callable, Iterator
-
-StrIdGenerator = Callable[[], str]
+from typing import Iterator
 
 
 def tracking_run_uuid_generator() -> str:

OTVision/track/parser/chunk_parser_plugins.py

@@ -8,7 +8,6 @@ from OTVision.dataformat import (
     CLASS,
     CONFIDENCE,
     DATA,
-    DATE_FORMAT,
     DETECTIONS,
     OCCURRENCE,
     H,
@@ -18,10 +17,7 @@ from OTVision.dataformat import (
 )
 from OTVision.domain.detection import Detection
 from OTVision.domain.frame import DetectedFrame
-from OTVision.helpers.date import (
-    parse_date_string_to_utc_datime,
-    parse_timestamp_string_to_utc_datetime,
-)
+from OTVision.helpers.date import parse_datetime
 from OTVision.helpers.files import denormalize_bbox, read_json
 from OTVision.track.model.filebased.frame_chunk import ChunkParser, FrameChunk
 from OTVision.track.model.filebased.frame_group import FrameGroup
@@ -84,17 +80,3 @@ class DetectionParser:
             )
             detections.append(detected_item)
         return detections
-
-
-def parse_datetime(date: str | float) -> datetime:
-    """Parse a date string or timestamp to a datetime with UTC as timezone.
-
-    Args:
-        date (str | float): the date to parse
-
-    Returns:
-        datetime: the parsed datetime object with UTC set as timezone
-    """
-    if isinstance(date, str) and ("-" in date):
-        return parse_date_string_to_utc_datime(date, DATE_FORMAT)
-    return parse_timestamp_string_to_utc_datetime(date)

OTVision/track/parser/frame_group_parser_plugins.py

@@ -1,34 +1,17 @@
-import re
 from datetime import datetime, timedelta
 from pathlib import Path
 
-from OTVision import dataformat, version
 from OTVision.application.config import TrackConfig
 from OTVision.application.get_current_config import GetCurrentConfig
-from OTVision.dataformat import (
-    EXPECTED_DURATION,
-    FILENAME,
-    FIRST_TRACKED_VIDEO_START,
-    LAST_TRACKED_VIDEO_END,
-    LENGTH,
-    OTTRACK_VERSION,
-    OTVISION_VERSION,
-    RECORDED_START_DATE,
-    TRACKER,
-    TRACKING,
-    VIDEO,
-)
-from OTVision.detect.otdet import parse_video_length
-from OTVision.helpers.files import (
-    FULL_FILE_NAME_PATTERN,
-    HOSTNAME,
-    InproperFormattedFilename,
-    read_json_bz2_metadata,
+from OTVision.application.track.ottrk import create_ottrk_metadata_entry
+from OTVision.detect.otdet import (
+    extract_expected_duration_from_otdet,
+    extract_hostname_from_otdet,
+    extract_start_date_from_otdet,
 )
+from OTVision.helpers.files import read_json_bz2_metadata
 from OTVision.track.model.filebased.frame_group import FrameGroup, FrameGroupParser
-from OTVision.track.parser.chunk_parser_plugins import parse_datetime
 
-MISSING_START_DATE = datetime(1900, 1, 1)
 MISSING_EXPECTED_DURATION = timedelta(minutes=15)
 
 
@@ -37,16 +20,6 @@ class TimeThresholdFrameGroupParser(FrameGroupParser):
     def config(self) -> TrackConfig:
         return self._get_current_config.get().track
 
-    @property
-    def _tracker_data(self) -> dict:
-        return tracker_metadata(
-            sigma_l=self.config.sigma_l,
-            sigma_h=self.config.sigma_h,
-            sigma_iou=self.config.sigma_iou,
-            t_min=self.config.t_min,
-            t_miss_max=self.config.t_miss_max,
-        )
-
     def __init__(
         self,
         get_current_config: GetCurrentConfig,
@@ -80,43 +53,28 @@ class TimeThresholdFrameGroupParser(FrameGroupParser):
         )
 
     def get_hostname(self, file_metadata: dict) -> str:
-        video_name = Path(file_metadata[VIDEO][FILENAME]).name
-        match = re.search(
-            FULL_FILE_NAME_PATTERN,
-            video_name,
-        )
-        if match:
-            return match.group(HOSTNAME)
-
-        raise InproperFormattedFilename(f"Could not parse {video_name}.")
+        return extract_hostname_from_otdet(file_metadata)
 
     def extract_start_date_from(self, metadata: dict) -> datetime:
-        if RECORDED_START_DATE in metadata[VIDEO].keys():
-            recorded_start_date = metadata[VIDEO][RECORDED_START_DATE]
-            return parse_datetime(recorded_start_date)
-        return MISSING_START_DATE
+        return extract_start_date_from_otdet(metadata)
 
     def extract_expected_duration_from(self, metadata: dict) -> timedelta:
-        if EXPECTED_DURATION in metadata[VIDEO].keys():
-            if expected_duration := metadata[VIDEO][EXPECTED_DURATION]:
-                return timedelta(seconds=int(expected_duration))
-        return self.parse_video_length(metadata)
-
-    def parse_video_length(self, metadata: dict) -> timedelta:
-        video_length = metadata[VIDEO][LENGTH]
-        return parse_video_length(video_length)
+        return extract_expected_duration_from_otdet(metadata)
 
     def update_metadata(self, frame_group: FrameGroup) -> dict[Path, dict]:
         metadata_by_file = dict(frame_group.metadata_by_file)
         for filepath in frame_group.files:
             metadata = metadata_by_file[filepath]
-            metadata[OTTRACK_VERSION] = version.ottrack_version()
-            metadata[TRACKING] = {
-                OTVISION_VERSION: version.otvision_version(),
-                FIRST_TRACKED_VIDEO_START: frame_group.start_date.timestamp(),
-                LAST_TRACKED_VIDEO_END: frame_group.end_date.timestamp(),
-                TRACKER: self._tracker_data,
-            }
+            ottrk_metadata = create_ottrk_metadata_entry(
+                start_date=frame_group.start_date,
+                end_date=frame_group.end_date,
+                sigma_l=self.config.sigma_l,
+                sigma_h=self.config.sigma_h,
+                sigma_iou=self.config.sigma_iou,
+                t_min=self.config.t_min,
+                t_miss_max=self.config.t_miss_max,
+            )
+            metadata.update(ottrk_metadata)
 
         return metadata_by_file
 
@@ -142,16 +100,3 @@ class TimeThresholdFrameGroupParser(FrameGroupParser):
                 last_group = current_group
         merged_groups.append(last_group)
         return merged_groups
-
-
-def tracker_metadata(
-    sigma_l: float, sigma_h: float, sigma_iou: float, t_min: float, t_miss_max: float
-) -> dict:
-    return {
-        dataformat.NAME: "IOU",
-        dataformat.SIGMA_L: sigma_l,
-        dataformat.SIGMA_H: sigma_h,
-        dataformat.SIGMA_IOU: sigma_iou,
-        dataformat.T_MIN: t_min,
-        dataformat.T_MISS_MAX: t_miss_max,
-    }

OTVision/track/stream_ottrk_file_writer.py

@@ -0,0 +1,116 @@
+from pathlib import Path
+
+from OTVision.application.buffer import Buffer
+from OTVision.application.config import Config, TrackConfig
+from OTVision.application.configure_logger import logger
+from OTVision.application.get_current_config import GetCurrentConfig
+from OTVision.application.otvision_save_path_provider import OtvisionSavePathProvider
+from OTVision.application.track.ottrk import OttrkBuilder, OttrkBuilderConfig
+from OTVision.application.track.tracking_run_id import GetCurrentTrackingRunId
+from OTVision.detect.otdet import OtdetBuilderConfig
+from OTVision.detect.otdet_file_writer import OtdetFileWrittenEvent
+from OTVision.domain.detection import TrackId
+from OTVision.domain.frame import TrackedFrame
+from OTVision.helpers.files import write_json
+
+STREAMING_FRAME_GROUP_ID = 0
+
+
+class StreamOttrkFileWriter(Buffer[TrackedFrame, OtdetFileWrittenEvent]):
+    @property
+    def config(self) -> Config:
+        return self._get_current_config.get()
+
+    @property
+    def track_config(self) -> TrackConfig:
+        return self.config.track
+
+    @property
+    def build_condition_fulfilled(self) -> bool:
+        return len(self._ottrk_unfinished_tracks) == 0
+
+    @property
+    def current_output_file(self) -> Path:
+        if self._current_output_file is None:
+            raise ValueError("Output file has not been set yet.")
+        return self._current_output_file
+
+    def __init__(
+        self,
+        builder: OttrkBuilder,
+        get_current_config: GetCurrentConfig,
+        get_current_tracking_run_id: GetCurrentTrackingRunId,
+        save_path_provider: OtvisionSavePathProvider,
+    ) -> None:
+        Buffer.__init__(self)
+        self._builder = builder
+        self._get_current_config = get_current_config
+        self._current_tracking_run_id = get_current_tracking_run_id
+        self._save_path_provider = save_path_provider
+
+        self._in_writing_state: bool = False
+        self._ottrk_unfinished_tracks: set[TrackId] = set()
+        self._current_output_file: Path | None = None
+
+    def on_flush(self, event: OtdetFileWrittenEvent) -> None:
+        tracked_frames = self._get_buffered_elements()
+        if not tracked_frames:
+            return
+
+        self._in_writing_state = True
+        self._current_output_file = self._save_path_provider.provide(
+            event.otdet_builder_config.source, self.config.filetypes.track
+        )
+        builder_config = self._create_ottrk_builder_config(
+            event.otdet_builder_config, event.number_of_frames
+        )
+        self._builder.set_config(builder_config)
+        last_frame = tracked_frames[-1]
+        self._builder.add_tracked_frames(self._get_buffered_elements())
+        self._ottrk_unfinished_tracks = last_frame.unfinished_tracks
+        self.reset()
+
+    def _create_ottrk_builder_config(
+        self,
+        otdet_builder_config: OtdetBuilderConfig,
+        number_of_frames: int,
+    ) -> OttrkBuilderConfig:
+        return OttrkBuilderConfig(
+            otdet_builder_config=otdet_builder_config,
+            number_of_frames=number_of_frames,
+            sigma_l=self.track_config.sigma_l,
+            sigma_h=self.track_config.sigma_h,
+            sigma_iou=self.track_config.sigma_iou,
+            t_min=self.track_config.t_min,
+            t_miss_max=self.track_config.t_miss_max,
+            tracking_run_id=self._current_tracking_run_id.get(),
+            frame_group=STREAMING_FRAME_GROUP_ID,
+        )
+
+    def reset(self) -> None:
+        self._reset_buffer()
+
+    def buffer(self, to_buffer: TrackedFrame) -> None:
+        self._buffer.append(to_buffer.without_image())
+
+        if self._in_writing_state:
+            self._builder.finish_tracks(to_buffer.finished_tracks)
+            self._builder.discard_tracks(to_buffer.discarded_tracks)
+            self._ottrk_unfinished_tracks = (
+                self._ottrk_unfinished_tracks.difference(to_buffer.unfinished_tracks)
+                .difference(to_buffer.finished_tracks)
+                .difference(to_buffer.discarded_tracks)
+            )
+            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
+
+    def write(self, ottrk: dict) -> None:
+        write_json(
+            dict_to_write=ottrk,
+            file=self.current_output_file,
+            filetype=self.config.filetypes.track,
+            overwrite=True,
+        )

OTVision/track/track.py

@@ -4,10 +4,11 @@ from tqdm import tqdm
 
 from OTVision.application.config import Config
 from OTVision.application.get_current_config import GetCurrentConfig
+from OTVision.application.track.tracking_run_id import StrIdGenerator
 from OTVision.helpers.files import get_files
 from OTVision.helpers.input_types import check_types
 from OTVision.helpers.log import LOGGER_NAME
-from OTVision.track.id_generator import StrIdGenerator, tracking_run_uuid_generator
+from OTVision.track.id_generator import tracking_run_uuid_generator
 from OTVision.track.model.track_exporter import FinishedTracksExporter
 from OTVision.track.tracker.filebased_tracking import UnfinishedChunksBuffer
 

OTVision/version.py

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