OTVision 0.6.4__py3-none-any.whl → 0.6.6__py3-none-any.whl

OTVision/convert/convert.py

@@ -27,8 +27,7 @@ from typing import Optional
 
 from tqdm import tqdm
 
-from OTVision.config import (
-    CONFIG,
+from OTVision.application.config import (
     CONVERT,
     DELETE_INPUT,
     FILETYPES,
@@ -40,6 +39,7 @@ from OTVision.config import (
     VID,
     VID_ROTATABLE,
 )
+from OTVision.config import CONFIG
 from OTVision.helpers.files import get_files
 from OTVision.helpers.formats import _get_fps_from_filename
 from OTVision.helpers.log import LOGGER_NAME
@@ -140,7 +140,7 @@ def convert(
         overwrite (bool, optional): Whether to overwrite existing video files.
             Defaults to CONFIG["CONVERT"]["OVERWRITE"].
         delete_input (bool, optional): Whether to delete the input h264.
-          Defaults to CONFIG["CONVERT"]["DELETE_INPUT"].
+            Defaults to CONFIG["CONVERT"]["DELETE_INPUT"].
 
     Raises:
         TypeError: If output video filetype is not supported.

OTVision/detect/builder.py

@@ -1,8 +1,11 @@
+from abc import ABC, abstractmethod
 from argparse import ArgumentParser
 from functools import cached_property
 
 from OTVision.abstraction.observer import Subject
 from OTVision.application.buffer import Buffer
+from OTVision.application.config import Config
+from OTVision.application.config_parser import ConfigParser
 from OTVision.application.configure_logger import ConfigureLogger
 from OTVision.application.detect.current_object_detector import CurrentObjectDetector
 from OTVision.application.detect.current_object_detector_metadata import (
@@ -24,7 +27,6 @@ from OTVision.application.frame_count_provider import FrameCountProvider
 from OTVision.application.get_config import GetConfig
 from OTVision.application.get_current_config import GetCurrentConfig
 from OTVision.application.update_current_config import UpdateCurrentConfig
-from OTVision.config import Config, ConfigParser
 from OTVision.detect.cli import ArgparseDetectCliParser
 from OTVision.detect.detect import OTVisionVideoDetect
 from OTVision.detect.detected_frame_buffer import (
@@ -37,7 +39,6 @@ from OTVision.detect.otdet_file_writer import OtdetFileWriter
 from OTVision.detect.plugin_av.rotate_frame import AvVideoFrameRotator
 from OTVision.detect.pyav_frame_count_provider import PyAVFrameCountProvider
 from OTVision.detect.timestamper import TimestamperFactory
-from OTVision.detect.video_input_source import VideoSource
 from OTVision.detect.yolo import YoloDetectionConverter, YoloFactory
 from OTVision.domain.cli import DetectCliParser
 from OTVision.domain.current_config import CurrentConfig
@@ -45,17 +46,15 @@ from OTVision.domain.detect_producer_consumer import DetectedFrameProducer
 from OTVision.domain.frame import DetectedFrame
 from OTVision.domain.input_source_detect import InputSourceDetect
 from OTVision.domain.object_detection import ObjectDetectorFactory
+from OTVision.domain.serialization import Deserializer
+from OTVision.plugin.yaml_serialization import YamlDeserializer
 
 
-class DetectBuilder:
+class DetectBuilder(ABC):
     @cached_property
     def get_config(self) -> GetConfig:
         return GetConfig(self.config_parser)
 
-    @cached_property
-    def config_parser(self) -> ConfigParser:
-        return ConfigParser()
-
     @cached_property
     def get_detect_cli_args(self) -> GetDetectCliArgs:
         return GetDetectCliArgs(self.detect_cli_parser)
@@ -108,19 +107,6 @@ class DetectBuilder:
     def update_current_config(self) -> UpdateCurrentConfig:
         return UpdateCurrentConfig(self.current_config)
 
-    def __init__(self, argv: list[str] | None = None) -> None:
-        self.argv = argv
-
-    @cached_property
-    def input_source(self) -> InputSourceDetect:
-        return VideoSource(
-            subject=Subject[FlushEvent](),
-            get_current_config=self.get_current_config,
-            frame_rotator=self.frame_rotator,
-            timestamper_factory=self.timestamper_factory,
-            save_path_provider=self.detection_file_save_path_provider,
-        )
-
     @cached_property
     def frame_rotator(self) -> AvVideoFrameRotator:
         return AvVideoFrameRotator()
@@ -171,10 +157,31 @@ class DetectBuilder:
             detected_frame_buffer=self.detected_frame_buffer,
         )
 
+    @cached_property
+    def config_parser(self) -> ConfigParser:
+        return ConfigParser(self.yaml_deserializer)
+
+    @cached_property
+    def yaml_deserializer(self) -> Deserializer:
+        return YamlDeserializer()
+
+    def __init__(self, argv: list[str] | None = None) -> None:
+        self.argv = argv
+
+    @property
+    @abstractmethod
+    def input_source(self) -> InputSourceDetect:
+        raise NotImplementedError
+
     def build(self) -> OTVisionVideoDetect:
         self.register_observers()
+        self._preload_object_detection_model()
         return OTVisionVideoDetect(self.detected_frame_producer)
 
+    def _preload_object_detection_model(self) -> None:
+        model = self.current_object_detector.get()
+        model.preload()
+
     def register_observers(self) -> None:
         self.input_source.register(self.detected_frame_buffer.on_flush)
         self.detected_frame_buffer.register(self.otdet_file_writer.write)

OTVision/detect/cli.py

@@ -2,7 +2,7 @@ from argparse import ArgumentParser, BooleanOptionalAction, Namespace
 from datetime import datetime, timedelta
 from pathlib import Path
 
-from OTVision.config import DATETIME_FORMAT
+from OTVision.application.config import DATETIME_FORMAT
 from OTVision.domain.cli import CliParseError, DetectCliArgs, DetectCliParser
 from OTVision.helpers.files import check_if_all_paths_exist
 from OTVision.helpers.log import DEFAULT_LOG_FILE, VALID_LOG_LEVELS
@@ -172,10 +172,10 @@ class ArgparseDetectCliParser(DetectCliParser):
                 )
             )
 
-    def _parse_files(self, files: list[str] | None) -> list[Path] | None:
+    def _parse_files(self, files: list[str] | None) -> list[str] | None:
         if files is None:
             return None
 
         result = [Path(file).expanduser() for file in files]
         check_if_all_paths_exist(result)
-        return result
+        return list(map(str, result))

OTVision/detect/detected_frame_buffer.py

@@ -8,6 +8,7 @@ from OTVision.domain.frame import DetectedFrame
 @dataclass
 class SourceMetadata:
     source: str
+    output: str
     duration: timedelta
     height: int
     width: int
@@ -22,6 +23,7 @@ class FlushEvent:
     @staticmethod
     def create(
         source: str,
+        output: str,
         duration: timedelta,
         source_height: int,
         source_width: int,
@@ -31,6 +33,7 @@ class FlushEvent:
         return FlushEvent(
             SourceMetadata(
                 source,
+                output,
                 duration,
                 source_height,
                 source_width,

OTVision/detect/file_based_detect_builder.py

@@ -0,0 +1,19 @@
+from functools import cached_property
+
+from OTVision.abstraction.observer import Subject
+from OTVision.detect.builder import DetectBuilder
+from OTVision.detect.detected_frame_buffer import FlushEvent
+from OTVision.detect.video_input_source import VideoSource
+from OTVision.domain.input_source_detect import InputSourceDetect
+
+
+class FileBasedDetectBuilder(DetectBuilder):
+    @cached_property
+    def input_source(self) -> InputSourceDetect:
+        return VideoSource(
+            subject=Subject[FlushEvent](),
+            get_current_config=self.get_current_config,
+            frame_rotator=self.frame_rotator,
+            timestamper_factory=self.timestamper_factory,
+            save_path_provider=self.detection_file_save_path_provider,
+        )

OTVision/detect/otdet.py

@@ -102,7 +102,7 @@ class OtdetBuilder:
             dataformat.ACTUAL_FPS: self.config.actual_fps,
             dataformat.NUMBER_OF_FRAMES: number_of_frames,
             dataformat.RECORDED_START_DATE: self.config.recorded_start_date.timestamp(),
-            dataformat.LENGTH: str(self.config.actual_duration),
+            dataformat.LENGTH: serialize_video_length(self.config.actual_duration),
         }
         if self.config.expected_duration is not None:
             video_config[dataformat.EXPECTED_DURATION] = int(
@@ -127,3 +127,56 @@ class OtdetBuilder:
             dataformat.DETECT_START: self.config.detect_start,
             dataformat.DETECT_END: self.config.detect_end,
         }
+
+
+def serialize_video_length(video_length: timedelta) -> str:
+    """Serialize a timedelta object to a video length string in 'H+:MM:SS' format.
+
+    Args:
+        video_length (timedelta): The video length to serialize.
+
+    Returns:
+        str: The video length represented in 'H+:MM:SS' format.
+    """
+    seconds_per_hour = 3600
+    seconds_per_minute = 60
+
+    total_seconds = int(video_length.total_seconds())
+    hours = total_seconds // seconds_per_hour
+    minutes = (total_seconds % seconds_per_hour) // seconds_per_minute
+    seconds = total_seconds % seconds_per_minute
+    return f"{hours}:{minutes:02}:{seconds:02}"
+
+
+class VideoLengthParseError(Exception):
+    """Exception raised for errors in parsing video length strings."""
+
+    pass
+
+
+def parse_video_length(video_length: str) -> timedelta:
+    """Parse a video length string that is in either 'H+:MM:SS' or 'H+:MM:SS.mmmuuu'
+    format into a timedelta object ignoring milliseconds and microseconds.
+
+    Args:
+        video_length (str): A string representing the video length in or
+            'H+:MM:SS.mmmuuu' or 'H+:MM:SS.mmmuuu' format.
+
+    Returns:
+        timedelta: A timedelta object representing the parsed video length ignoring
+            milliseconds and microseconds.
+
+    Raises:
+        VideoLengthParseError: If the input string is not in the expected format.
+    """
+
+    try:
+        hours, minutes, seconds = video_length.strip().split(":")
+        return timedelta(
+            hours=int(hours), minutes=int(minutes), seconds=int(float(seconds))
+        )
+    except ValueError as cause:
+        raise VideoLengthParseError(
+            f"Could not parse video length '{video_length}'. "
+            "Expected format 'HH:MM:SS'."
+        ) from cause

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()
@@ -72,7 +72,7 @@ class OtdetFileWriter:
             OtdetBuilderConfig(
                 conf=detect_config.confidence,
                 iou=detect_config.iou,
-                source=source_metadata.source,
+                source=source_metadata.output,
                 video_width=source_metadata.width,
                 video_height=source_metadata.height,
                 expected_duration=expected_duration,
@@ -92,7 +92,8 @@ class OtdetFileWriter:
             )
         ).build(event.frames)
 
-        detections_file = self._save_path_provider.provide(source_metadata.source)
+        detections_file = self._save_path_provider.provide(source_metadata.output)
+        detections_file.parent.mkdir(parents=True, exist_ok=True)
         write_json(
             otdet,
             file=detections_file,

OTVision/detect/rtsp_based_detect_builder.py

@@ -0,0 +1,37 @@
+from functools import cached_property
+
+from OTVision.abstraction.observer import Subject
+from OTVision.application.config import StreamConfig
+from OTVision.detect.builder import DetectBuilder
+from OTVision.detect.detected_frame_buffer import FlushEvent
+from OTVision.detect.rtsp_input_source import Counter, RtspInputSource
+from OTVision.domain.input_source_detect import InputSourceDetect
+from OTVision.domain.time import CurrentDatetimeProvider, DatetimeProvider
+
+FLUSH_BUFFER_SIZE = 18000
+FLUSH_BUFFER_SIZE = 1200
+
+
+class RtspBasedDetectBuilder(DetectBuilder):
+    @property
+    def stream_config(self) -> StreamConfig:
+        config = self.get_current_config.get()
+        if config.stream is None:
+            raise ValueError(
+                "Stream config is not provided. "
+                "Running OTVision in streaming mode requires stream config"
+            )
+        return config.stream
+
+    @cached_property
+    def input_source(self) -> InputSourceDetect:
+        return RtspInputSource(
+            subject=Subject[FlushEvent](),
+            datetime_provider=self.datetime_provider,
+            frame_counter=Counter(),
+            get_current_config=self.get_current_config,
+        )
+
+    @cached_property
+    def datetime_provider(self) -> DatetimeProvider:
+        return CurrentDatetimeProvider()

OTVision/detect/rtsp_input_source.py

@@ -0,0 +1,207 @@
+from datetime import datetime, timedelta
+from time import sleep
+from typing import Generator
+
+from cv2 import (
+    CAP_PROP_FRAME_HEIGHT,
+    CAP_PROP_FRAME_WIDTH,
+    COLOR_BGR2RGB,
+    VideoCapture,
+    cvtColor,
+)
+from numpy import ndarray
+
+from OTVision.abstraction.observer import Subject
+from OTVision.application.config import (
+    DATETIME_FORMAT,
+    Config,
+    DetectConfig,
+    StreamConfig,
+)
+from OTVision.application.configure_logger import logger
+from OTVision.application.get_current_config import GetCurrentConfig
+from OTVision.detect.detected_frame_buffer import FlushEvent
+from OTVision.domain.frame import Frame
+from OTVision.domain.input_source_detect import InputSourceDetect
+from OTVision.domain.time import DatetimeProvider
+
+RTSP_URL = "rtsp://127.0.0.1:8554/test"
+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:
+        self.__counter += 1
+
+    def get(self) -> int:
+        return self.__counter
+
+    def reset(self) -> None:
+        self.__counter = self._start_value
+
+
+class RtspInputSource(InputSourceDetect):
+
+    @property
+    def current_frame_number(self) -> int:
+        return self._frame_counter.get()
+
+    @property
+    def config(self) -> Config:
+        return self._get_current_config.get()
+
+    @property
+    def detect_config(self) -> DetectConfig:
+        return self.config.detect
+
+    @property
+    def stream_config(self) -> StreamConfig:
+        if stream_config := self.config.stream:
+            return stream_config
+        raise ValueError("Stream config not found in config")
+
+    @property
+    def rtsp_url(self) -> str:
+        return self.stream_config.source
+
+    @property
+    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],
+        datetime_provider: DatetimeProvider,
+        frame_counter: Counter,
+        get_current_config: GetCurrentConfig,
+    ) -> None:
+        super().__init__(subject)
+        self._datetime_provider = datetime_provider
+        self._stop_capture = False
+        self._frame_counter = frame_counter
+        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:
+        # Property is moved below __init__ otherwise mypy is somehow unable to determine
+        # types of self._current_stream and self._current_video_capture
+        new_source = self.stream_config.source
+        if (
+            self._current_stream is not None
+            and self._current_stream == new_source
+            and self._current_video_capture
+        ):
+            # current source has not changed
+            return self._current_video_capture
+
+        # Stream changed or has not been initialized
+        if self._current_video_capture is not None:
+            # If the stream changed and there's an existing capture, release it
+            self._current_video_capture.release()
+
+        self._current_stream = new_source
+        self._current_video_capture = self._init_video_capture(self._current_stream)
+        return self._current_video_capture
+
+    def produce(self) -> Generator[Frame, None, None]:
+        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,
+                    output=self.create_output(),
+                    occurrence=occurrence,
+                )
+                if self.flush_condition_met():
+                    self._notify()
+                    self._outdated = True
+                    self._frame_counter.reset()
+
+        self._notify()
+
+    def _init_video_capture(self, source: str) -> VideoCapture:
+        cap = VideoCapture(source)
+        while not self.should_stop() and not cap.isOpened():
+            logger().warning(
+                f"Couldn't open the RTSP stream: {source}. "
+                f"Trying again in {RETRY_SECONDS}s..."
+            )
+            sleep(RETRY_SECONDS)
+            cap.release()
+            cap = VideoCapture(source)
+        return cap
+
+    def _read_next_frame(self) -> ndarray | None:
+        successful, frame = self._video_capture.read()
+        if successful:
+            return frame
+        logger().debug("Failed to grab frame")
+        return None
+
+    def should_stop(self) -> bool:
+        return self._stop_capture
+
+    def stop(self) -> None:
+        self._stop_capture = True
+
+    def start(self) -> None:
+        self._stop_capture = False
+
+    def flush_condition_met(self) -> bool:
+        return self.current_frame_number % self.flush_buffer_size == 0
+
+    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))
+        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 / self.fps))
+        output = self.create_output()
+        self._subject.notify(
+            FlushEvent.create(
+                source=self.rtsp_url,
+                output=output,
+                duration=duration,
+                source_width=frame_width,
+                source_height=frame_height,
+                source_fps=self.fps,
+                start_time=self._current_video_start_time,
+            )
+        )
+
+    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:
+    return cvtColor(frame, COLOR_BGR2RGB)

OTVision/detect/timestamper.py

@@ -2,10 +2,10 @@ import re
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
 
+from OTVision.application.config import DATETIME_FORMAT
 from OTVision.application.detect.timestamper import Timestamper
 from OTVision.application.frame_count_provider import FrameCountProvider
 from OTVision.application.get_current_config import GetCurrentConfig
-from OTVision.config import DATETIME_FORMAT
 from OTVision.dataformat import FRAME
 from OTVision.domain.frame import Frame, FrameKeys
 from OTVision.helpers.date import parse_date_string_to_utc_datime
@@ -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/detect/video_input_source.py

@@ -7,12 +7,12 @@ import av
 from tqdm import tqdm
 
 from OTVision.abstraction.observer import Subject
+from OTVision.application.config import DATETIME_FORMAT, Config
 from OTVision.application.detect.detection_file_save_path_provider import (
     DetectionFileSavePathProvider,
 )
 from OTVision.application.detect.timestamper import Timestamper
 from OTVision.application.get_current_config import GetCurrentConfig
-from OTVision.config import DATETIME_FORMAT, Config
 from OTVision.detect.detected_frame_buffer import FlushEvent
 from OTVision.detect.plugin_av.rotate_frame import AvVideoFrameRotator
 from OTVision.detect.timestamper import TimestamperFactory, parse_start_time_from
@@ -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
@@ -181,6 +183,7 @@ class VideoSource(InputSourceDetect):
         self._subject.notify(
             FlushEvent.create(
                 source=str(current_video_file),
+                output=str(current_video_file),
                 duration=duration,
                 source_height=height,
                 source_width=width,
@@ -205,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/detect/yolo.py

@@ -30,9 +30,9 @@ from ultralytics import YOLO
 from ultralytics.engine.results import Boxes
 
 from OTVision.abstraction.pipes_and_filter import Filter
+from OTVision.application.config import DetectConfig
 from OTVision.application.detect.detected_frame_factory import DetectedFrameFactory
 from OTVision.application.get_current_config import GetCurrentConfig
-from OTVision.config import DetectConfig
 from OTVision.domain.detection import Detection
 from OTVision.domain.frame import DetectedFrame, Frame, FrameKeys
 from OTVision.domain.object_detection import ObjectDetector, ObjectDetectorFactory
@@ -184,6 +184,22 @@ class YoloDetector(ObjectDetector, Filter[Frame, DetectedFrame]):
         """Create a DetectedFrame with no detections."""
         return self._detected_frame_factory.create(frame, detections=[])
 
+    def preload(self) -> None:
+        model_name = Path(self.config.weights).name
+        log.info(f"Preloading YOLO model '{model_name}...'")
+        self._model.predict(
+            source=None,
+            conf=self.config.confidence,
+            iou=self.config.iou,
+            half=self.config.half_precision,
+            imgsz=self.config.img_size,
+            device=0 if torch.cuda.is_available() else "cpu",
+            stream=False,
+            verbose=False,
+            agnostic_nms=True,
+        )
+        log.info(f"YOLO model '{model_name}' loaded and ready for inference.'")
+
 
 class YoloFactory(ObjectDetectorFactory):
     """

OTVision/domain/cli.py

@@ -17,7 +17,7 @@ class CliParseError(Exception):
 @dataclass
 class DetectCliArgs(CliArgs):
     expected_duration: timedelta | None
-    paths: list[Path] | None
+    paths: list[str] | None
     config_file: Path | None
     logfile: Path
     logfile_overwrite: bool
@@ -41,3 +41,33 @@ class DetectCliParser(ABC):
     @abstractmethod
     def parse(self) -> DetectCliArgs:
         raise NotImplementedError
+
+
+@dataclass
+class TrackCliArgs(CliArgs):
+    paths: list[str] | None
+    config_file: Path | None
+    logfile: Path
+    logfile_overwrite: bool
+    log_level_console: str | None
+    log_level_file: str | None
+    overwrite: bool | None = None
+    sigma_l: float | None = None
+    sigma_h: float | None = None
+    sigma_iou: float | None = None
+    t_min: int | None = None
+    t_miss_max: int | None = None
+
+    def get_config_file(self) -> Path | None:
+        return self.config_file
+
+
+class TrackCliParser(ABC):
+    @abstractmethod
+    def parse(self) -> TrackCliArgs:
+        """Parse track CLI arguments.
+
+        Returns:
+            TrackCliArgs: the parsed track CLI arguments.
+        """
+        raise NotImplementedError

OTVision/domain/current_config.py

@@ -1,4 +1,4 @@
-from OTVision.config import Config
+from OTVision.application.config import Config
 
 
 class CurrentConfig: