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

OTVision/application/config_parser.py

@@ -0,0 +1,280 @@
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from OTVision.application.config import (
+    COL_WIDTH,
+    CONF,
+    CONVERT,
+    DATETIME_FORMAT,
+    DEFAULT_FILETYPE,
+    DELETE_INPUT,
+    DETECT,
+    DETECT_END,
+    DETECT_START,
+    EXPECTED_DURATION,
+    FLUSH_BUFFER_SIZE,
+    FONT,
+    FONT_SIZE,
+    FPS_FROM_FILENAME,
+    FRAME_WIDTH,
+    GUI,
+    HALF_PRECISION,
+    IMG,
+    IMG_SIZE,
+    INPUT_FPS,
+    IOU,
+    LOCATION_X,
+    LOCATION_Y,
+    LOG,
+    LOG_LEVEL_CONSOLE,
+    LOG_LEVEL_FILE,
+    NORMALIZED,
+    OUTPUT_FILETYPE,
+    OUTPUT_FPS,
+    OVERWRITE,
+    PATHS,
+    REFPTS,
+    ROTATION,
+    RUN_CHAINED,
+    SEARCH_SUBDIRS,
+    SIGMA_H,
+    SIGMA_IOU,
+    SIGMA_L,
+    START_TIME,
+    STREAM,
+    STREAM_NAME,
+    STREAM_SAVE_DIR,
+    STREAM_SOURCE,
+    T_MIN,
+    T_MISS_MAX,
+    TRACK,
+    TRANSFORM,
+    UNDISTORT,
+    VID,
+    WEIGHTS,
+    WINDOW,
+    YOLO,
+    Config,
+    ConvertConfig,
+    DetectConfig,
+    StreamConfig,
+    TrackConfig,
+    YoloConfig,
+    _DefaultFiletype,
+    _GuiConfig,
+    _GuiWindowConfig,
+    _LogConfig,
+    _TrackIouConfig,
+    _TransformConfig,
+    _UndistortConfig,
+)
+from OTVision.domain.serialization import Deserializer
+
+
+class ConfigParser:
+
+    def __init__(self, deserializer: Deserializer) -> None:
+        self._deserialize = deserializer
+
+    def parse(self, file: Path) -> Config:
+        data = self._deserialize.deserialize(file)
+        return self.parse_from_dict(data)
+
+    def parse_from_dict(self, d: dict) -> Config:
+        log_dict = d.get(LOG)
+        default_filtetype_dict = d.get(DEFAULT_FILETYPE)
+        convert_dict = d.get(CONVERT)
+        detect_dict = d.get(DETECT)
+        track_dict = d.get(TRACK)
+        undistort_dict = d.get(UNDISTORT)
+        transform_dict = d.get(TRANSFORM)
+        gui_dict = d.get(GUI)
+        stream_config_dict = d.get(STREAM)
+
+        log_config = self.parse_log_config(log_dict) if log_dict else Config.log
+        default_filetype = (
+            self.parse_default_filetype(default_filtetype_dict)
+            if default_filtetype_dict
+            else Config.default_filetype
+        )
+        convert_config = (
+            self.parse_convert_config(convert_dict) if convert_dict else Config.convert
+        )
+        detect_config = (
+            self.parse_detect_config(detect_dict) if detect_dict else Config.detect
+        )
+        track_config = (
+            self.parse_track_config(track_dict) if track_dict else Config.track
+        )
+        undistort_config = (
+            self.parse_undistort_config(undistort_dict)
+            if undistort_dict
+            else Config.undistort
+        )
+        transform_config = (
+            self.parse_transform_config(transform_dict)
+            if transform_dict
+            else Config.transform
+        )
+        gui_config = self.parse_gui_config(gui_dict) if gui_dict else Config.gui
+        stream_config = None
+        if stream_config_dict is not None:
+            stream_config = self.parse_stream_config(stream_config_dict)
+
+        return Config(
+            log=log_config,
+            search_subdirs=d.get(SEARCH_SUBDIRS, Config.search_subdirs),
+            default_filetype=default_filetype,
+            convert=convert_config,
+            detect=detect_config,
+            track=track_config,
+            undistort=undistort_config,
+            transform=transform_config,
+            gui=gui_config,
+            stream=stream_config,
+        )
+
+    def parse_log_config(self, data: dict) -> _LogConfig:
+        return _LogConfig(
+            data.get(LOG_LEVEL_CONSOLE, _LogConfig.log_level_console),
+            data.get(LOG_LEVEL_FILE, _LogConfig.log_level_file),
+        )
+
+    def parse_default_filetype(self, data: dict) -> _DefaultFiletype:
+        return _DefaultFiletype(
+            data.get(VID, _DefaultFiletype.video),
+            data.get(IMG, _DefaultFiletype.image),
+            data.get(DETECT, _DefaultFiletype.detect),
+            data.get(TRACK, _DefaultFiletype.track),
+            data.get(REFPTS, _DefaultFiletype.refpts),
+        )
+
+    def parse_convert_config(self, data: dict) -> ConvertConfig:
+        sources = self.parse_sources(data.get(PATHS, []))
+        return ConvertConfig(
+            sources,
+            data.get(RUN_CHAINED, ConvertConfig.run_chained),
+            data.get(OUTPUT_FILETYPE, ConvertConfig.output_filetype),
+            data.get(INPUT_FPS, ConvertConfig.input_fps),
+            data.get(OUTPUT_FPS, ConvertConfig.output_fps),
+            data.get(FPS_FROM_FILENAME, ConvertConfig.fps_from_filename),
+            data.get(DELETE_INPUT, ConvertConfig.delete_input),
+            data.get(ROTATION, ConvertConfig.rotation),
+            data.get(OVERWRITE, ConvertConfig.overwrite),
+        )
+
+    def parse_sources(self, sources: list[str]) -> list[str]:
+        return [str(Path(source).expanduser()) for source in sources]
+
+    def parse_detect_config(self, data: dict) -> DetectConfig:
+        yolo_config_dict = data.get(YOLO)
+        yolo_config = (
+            self.parse_yolo_config(yolo_config_dict)
+            if yolo_config_dict
+            else DetectConfig.yolo_config
+        )
+        sources = self.parse_sources(data.get(PATHS, []))
+
+        expected_duration = data.get(EXPECTED_DURATION, None)
+        if expected_duration is not None:
+            expected_duration = timedelta(seconds=int(expected_duration))
+
+        start_time = self._parse_start_time(data)
+        return DetectConfig(
+            sources,
+            data.get(RUN_CHAINED, DetectConfig.run_chained),
+            yolo_config,
+            expected_duration,
+            data.get(OVERWRITE, DetectConfig.overwrite),
+            data.get(HALF_PRECISION, DetectConfig.half_precision),
+            start_time,
+            data.get(DETECT_START, DetectConfig.detect_start),
+            data.get(DETECT_END, DetectConfig.detect_end),
+        )
+
+    def parse_yolo_config(self, data: dict) -> YoloConfig:
+        return YoloConfig(
+            weights=data.get(WEIGHTS, YoloConfig.weights),
+            conf=data.get(CONF, YoloConfig.conf),
+            iou=data.get(IOU, YoloConfig.iou),
+            img_size=data.get(IMG_SIZE, YoloConfig.img_size),
+            normalized=data.get(NORMALIZED, YoloConfig.normalized),
+        )
+
+    @staticmethod
+    def _parse_start_time(d: dict) -> datetime | None:
+        if start_time := d.get(START_TIME, DetectConfig.start_time):
+            return datetime.strptime(start_time, DATETIME_FORMAT)
+        return start_time
+
+    def parse_track_config(self, data: dict) -> TrackConfig:
+        iou_config_dict = data.get(IOU)
+        iou_config = (
+            self.parse_track_iou_config(iou_config_dict)
+            if iou_config_dict
+            else TrackConfig.iou
+        )
+        sources = self.parse_sources(data.get(PATHS, []))
+
+        return TrackConfig(
+            sources,
+            data.get(RUN_CHAINED, TrackConfig.run_chained),
+            iou_config,
+            data.get(OVERWRITE, TrackConfig.overwrite),
+        )
+
+    def parse_track_iou_config(self, data: dict) -> _TrackIouConfig:
+        return _TrackIouConfig(
+            data.get(SIGMA_L, _TrackIouConfig.sigma_l),
+            data.get(SIGMA_H, _TrackIouConfig.sigma_h),
+            data.get(SIGMA_IOU, _TrackIouConfig.sigma_iou),
+            data.get(T_MIN, _TrackIouConfig.t_min),
+            data.get(T_MISS_MAX, _TrackIouConfig.t_miss_max),
+        )
+
+    def parse_undistort_config(self, data: dict) -> _UndistortConfig:
+        return _UndistortConfig(
+            data.get(OVERWRITE, _UndistortConfig.overwrite),
+        )
+
+    def parse_transform_config(self, d: dict) -> _TransformConfig:
+        sources = self.parse_sources(d.get(PATHS, []))
+        return _TransformConfig(
+            sources,
+            d.get(RUN_CHAINED, _TransformConfig.run_chained),
+            d.get(OVERWRITE, _TransformConfig.overwrite),
+        )
+
+    def parse_gui_config(self, data: dict) -> _GuiConfig:
+        window_config_dict = data.get(WINDOW)
+        window_config = (
+            self.parse_gui_window_config(window_config_dict)
+            if window_config_dict
+            else _GuiConfig.window_config
+        )
+
+        return _GuiConfig(
+            font=data.get(FONT, _GuiConfig.font),
+            font_size=data.get(FONT_SIZE, _GuiConfig.font_size),
+            window_config=window_config,
+            frame_width=data.get(FRAME_WIDTH, _GuiConfig.frame_width),
+            col_width=data.get(COL_WIDTH, _GuiConfig.col_width),
+        )
+
+    def parse_gui_window_config(self, data: dict) -> _GuiWindowConfig:
+        return _GuiWindowConfig(
+            data.get(LOCATION_X, _GuiWindowConfig.location_x),
+            data.get(LOCATION_Y, _GuiWindowConfig.location_y),
+        )
+
+    def parse_stream_config(self, data: dict) -> StreamConfig:
+        name = data[STREAM_NAME]
+        source = data[STREAM_SOURCE]
+        save_dir = Path(data[STREAM_SAVE_DIR])
+        flush_buffer_size = int(data[FLUSH_BUFFER_SIZE])
+        return StreamConfig(
+            name=name,
+            source=source,
+            save_dir=save_dir,
+            flush_buffer_size=flush_buffer_size,
+        )

OTVision/application/configure_logger.py

@@ -2,7 +2,7 @@ import logging
 from logging import Logger
 from pathlib import Path
 
-from OTVision.config import Config
+from OTVision.application.config import Config
 from OTVision.helpers.log import LOGGER_NAME, log
 
 

OTVision/application/detect/factory.py

@@ -1,4 +1,4 @@
-from OTVision.config import DetectConfig
+from OTVision.application.config import DetectConfig
 from OTVision.domain.object_detection import ObjectDetector, ObjectDetectorFactory
 
 

OTVision/application/detect/update_detect_config_with_cli_args.py

@@ -1,5 +1,5 @@
+from OTVision.application.config import Config, DetectConfig, YoloConfig, _LogConfig
 from OTVision.application.detect.get_detect_cli_args import GetDetectCliArgs
-from OTVision.config import Config, DetectConfig, YoloConfig, _LogConfig
 from OTVision.domain.cli import DetectCliArgs
 
 
@@ -20,6 +20,7 @@ class UpdateDetectConfigWithCliArgs:
             undistort=config.undistort,
             transform=config.transform,
             gui=config.gui,
+            stream=config.stream,
         )
 
     def _update_detect_config(

OTVision/application/get_config.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 
-from OTVision.config import Config, ConfigParser
+from OTVision.application.config import Config
+from OTVision.application.config_parser import ConfigParser
 from OTVision.domain.cli import CliArgs
 
 DEFAULT_USER_CONFIG = "user_config.otvision.yaml"

OTVision/application/get_current_config.py

@@ -1,4 +1,4 @@
-from OTVision.config import Config
+from OTVision.application.config import Config
 from OTVision.domain.current_config import CurrentConfig
 
 

OTVision/application/track/get_track_cli_args.py

@@ -0,0 +1,20 @@
+from OTVision.domain.cli import TrackCliArgs, TrackCliParser
+
+
+class GetTrackCliArgs:
+    """Use case to retrieve the CLI arguments for OTVision track.
+
+    Args:
+        cli_parser (TrackCliParser): the CLI parser to parse the track CLI arguments.
+    """
+
+    def __init__(self, cli_parser: TrackCliParser) -> None:
+        self._cli_parser = cli_parser
+
+    def get(self) -> TrackCliArgs:
+        """Get the track CLI arguments.
+
+        Returns:
+            TrackCliArgs: the track CLI arguments.
+        """
+        return self._cli_parser.parse()

OTVision/application/track/update_current_track_config.py

@@ -0,0 +1,42 @@
+from OTVision.application.config import Config, TrackConfig
+from OTVision.application.get_current_config import GetCurrentConfig
+from OTVision.application.update_current_config import UpdateCurrentConfig
+
+
+class UpdateCurrentTrackConfig:
+    """Use case to update the current track configuration with a TrackConfig object"""
+
+    def __init__(
+        self,
+        get_current_config: GetCurrentConfig,
+        update_current_config: UpdateCurrentConfig,
+    ) -> None:
+        self._get_current_config = get_current_config
+        self._update_current_config = update_current_config
+
+    def update(self, track_config: TrackConfig) -> None:
+        """Update current configuration with a TrackConfig object.
+
+        Args:
+            track_config (TrackConfig): TrackConfig object to update current
+                configuration with.
+        """
+        updated_config = self._update_with(track_config)
+        self._update_current_config.update(updated_config)
+
+    def _update_with(self, track_config: TrackConfig) -> Config:
+        current_config = self._get_current_config.get()
+        return Config(
+            log=current_config.log,
+            search_subdirs=current_config.search_subdirs,
+            default_filetype=current_config.default_filetype,
+            filetypes=current_config.filetypes,
+            last_paths=current_config.last_paths,
+            convert=current_config.convert,
+            detect=current_config.detect,
+            track=track_config,
+            undistort=current_config.undistort,
+            transform=current_config.transform,
+            gui=current_config.gui,
+            stream=current_config.stream,
+        )

OTVision/application/track/update_track_config_with_cli_args.py

@@ -0,0 +1,52 @@
+from OTVision.abstraction.defaults import value_or_default
+from OTVision.application.config import Config, TrackConfig, _LogConfig, _TrackIouConfig
+from OTVision.application.track.get_track_cli_args import GetTrackCliArgs
+from OTVision.domain.cli import TrackCliArgs
+
+
+class UpdateTrackConfigWithCliArgs:
+    def __init__(self, get_detect_cli_args: GetTrackCliArgs) -> None:
+        self._get_track_cli_args = get_detect_cli_args
+
+    def update(self, config: Config) -> Config:
+        cli_args = self._get_track_cli_args.get()
+        return Config(
+            log=self._update_log_config(config, cli_args),
+            search_subdirs=config.search_subdirs,
+            default_filetype=config.default_filetype,
+            last_paths=config.last_paths,
+            convert=config.convert,
+            detect=config.detect,
+            track=self._update_track_config(config.track, cli_args),
+            undistort=config.undistort,
+            transform=config.transform,
+            gui=config.gui,
+            stream=config.stream,
+        )
+
+    def _update_track_config(
+        self, track_config: TrackConfig, cli_args: TrackCliArgs
+    ) -> TrackConfig:
+        iou_config = _TrackIouConfig(
+            sigma_l=value_or_default(cli_args.sigma_l, track_config.sigma_l),
+            sigma_h=value_or_default(cli_args.sigma_h, track_config.sigma_h),
+            sigma_iou=value_or_default(cli_args.sigma_iou, track_config.sigma_iou),
+            t_min=value_or_default(cli_args.t_min, track_config.t_min),
+            t_miss_max=value_or_default(cli_args.t_miss_max, track_config.t_miss_max),
+        )
+        return TrackConfig(
+            paths=value_or_default(cli_args.paths, track_config.paths),
+            run_chained=track_config.run_chained,
+            iou=iou_config,
+            overwrite=value_or_default(cli_args.overwrite, track_config.overwrite),
+        )
+
+    def _update_log_config(self, config: Config, cli_args: TrackCliArgs) -> _LogConfig:
+        return _LogConfig(
+            log_level_console=value_or_default(
+                cli_args.log_level_console, config.log.log_level_console
+            ),
+            log_level_file=value_or_default(
+                cli_args.log_level_file, config.log.log_level_file
+            ),
+        )

OTVision/application/update_current_config.py

@@ -1,4 +1,4 @@
-from OTVision.config import Config
+from OTVision.application.config import Config
 from OTVision.domain.current_config import CurrentConfig