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

OTVision/helpers/files.py

@@ -24,7 +24,7 @@ import logging
 import shutil
 import time
 from pathlib import Path
-from typing import Iterable, Union
+from typing import Iterable, Sequence, Union
 
 import ijson
 import ujson
@@ -49,8 +49,8 @@ FULL_FILE_NAME_PATTERN = (
 
 
 def get_files(
-    paths: list[Path],
-    filetypes: Union[list[str], None] = None,
+    paths: Sequence[Path | str],
+    filetypes: list[str] | None = None,
     search_subdirs: bool = True,
 ) -> list[Path]:
     """
@@ -58,12 +58,11 @@ def get_files(
     (recursive) content of folders.
 
     Args:
-        paths (list[Path]): where to find the files.
-        filetype (list[str]): ending of files to find. Preceding "_" prevents adding a
-        '.'
-            If no filetype is given, filetypes of file paths given are used and
-            directories are ignored. Defaults to None.
-        search_subdirs (bool): Wheter or not to search subdirs of dirs given as paths.
+        paths (list[Path | str]): where to find the files.
+        filetypes (list[str] | None): ending of files to find. Preceding "_" prevents
+            adding a '.'. If no filetype is given, filetypes of file paths given are
+            used and directories are ignored. Defaults to None.
+        search_subdirs (bool): Whether to search subdirectories of dirs given as paths.
             Defaults to True.
 
     Raises:
@@ -76,9 +75,11 @@ def get_files(
     Returns:
         list[Path]: List of files
     """
+    if type(paths) is str:
+        paths = [paths]
     files = set()
-    if type(paths) is not list:
-        raise TypeError("Paths needs to be a list of pathlib.Path")
+    if not isinstance(paths, Sequence):
+        raise ValueError("Paths needs to be a sequence")
     if filetypes:
         if type(filetypes) is not list:
             raise TypeError("Filetypes needs to be a list of str")
@@ -89,9 +90,7 @@ def get_files(
                 if not filetype.startswith("."):
                     filetype = f".{filetype}"
                 filetypes[idx] = filetype.lower()
-    for path in paths:
-        if not isinstance(path, Path):
-            raise TypeError("Paths needs to be a list of pathlib.Path")
+    for path in map(Path, paths):
         if path.is_file():
             file = path
             if filetypes:
@@ -107,7 +106,7 @@ def get_files(
                         if file.is_file() and file.suffix.lower() == filetype:
                             files.add(file)
         else:
-            raise TypeError("Paths needs to be a list of pathlib.Path")
+            raise ValueError(f"{path} is neither a file nor a dir")
 
     return sorted(list(files))
 

OTVision/plugin/yaml_serialization.py

@@ -0,0 +1,20 @@
+import logging
+from pathlib import Path
+
+import yaml
+
+from OTVision.domain.serialization import Deserializer
+from OTVision.helpers.log import LOGGER_NAME
+
+log = logging.getLogger(LOGGER_NAME)
+
+
+class YamlDeserializer(Deserializer):
+    def deserialize(self, file: Path) -> dict:
+        with open(file, "r") as stream:
+            try:
+                yaml_config = yaml.safe_load(stream)
+            except yaml.YAMLError:
+                log.exception("Unable to parse user config. Using default config.")
+                raise
+        return yaml_config

OTVision/track/builder.py

@@ -0,0 +1,132 @@
+from argparse import ArgumentParser
+from functools import cached_property
+
+from OTVision.application.config import Config
+from OTVision.application.config_parser import ConfigParser
+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.update_current_track_config import (
+    UpdateCurrentTrackConfig,
+)
+from OTVision.application.track.update_track_config_with_cli_args import (
+    UpdateTrackConfigWithCliArgs,
+)
+from OTVision.application.update_current_config import UpdateCurrentConfig
+from OTVision.domain.cli import TrackCliParser
+from OTVision.domain.current_config import CurrentConfig
+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.model.filebased.frame_chunk import ChunkParser
+from OTVision.track.model.filebased.frame_group import FrameGroupParser
+from OTVision.track.model.track_exporter import FinishedTracksExporter
+from OTVision.track.parser.chunk_parser_plugins import JsonChunkParser
+from OTVision.track.parser.frame_group_parser_plugins import (
+    TimeThresholdFrameGroupParser,
+)
+from OTVision.track.track import OtvisionTrack
+from OTVision.track.tracker.filebased_tracking import (
+    GroupedFilesTracker,
+    UnfinishedChunksBuffer,
+)
+from OTVision.track.tracker.tracker_plugin_iou import IouTracker
+
+
+class TrackBuilder:
+    @cached_property
+    def get_config(self) -> GetConfig:
+        return GetConfig(self.config_parser)
+
+    @cached_property
+    def config_parser(self) -> ConfigParser:
+        return ConfigParser(self.yaml_deserializer)
+
+    @cached_property
+    def yaml_deserializer(self) -> Deserializer:
+        return YamlDeserializer()
+
+    @cached_property
+    def get_track_cli_args(self) -> GetTrackCliArgs:
+        return GetTrackCliArgs(self.track_cli_parser)
+
+    @cached_property
+    def track_cli_parser(self) -> TrackCliParser:
+        return ArgparseTrackCliParser(
+            parser=ArgumentParser("Track objects through detections"), argv=self.argv
+        )
+
+    @cached_property
+    def update_track_config_with_cli_args(self) -> UpdateTrackConfigWithCliArgs:
+        return UpdateTrackConfigWithCliArgs(self.get_track_cli_args)
+
+    @cached_property
+    def configure_logger(self) -> ConfigureLogger:
+        return ConfigureLogger()
+
+    @cached_property
+    def update_current_config(self) -> UpdateCurrentConfig:
+        return UpdateCurrentConfig(self.current_config)
+
+    @cached_property
+    def get_current_config(self) -> GetCurrentConfig:
+        return GetCurrentConfig(self.current_config)
+
+    @cached_property
+    def current_config(self) -> CurrentConfig:
+        return CurrentConfig(Config())
+
+    @cached_property
+    def chunk_parser(self) -> ChunkParser:
+        return JsonChunkParser()
+
+    @cached_property
+    def frame_group_parser(self) -> FrameGroupParser:
+        return TimeThresholdFrameGroupParser(self.get_current_config)
+
+    @cached_property
+    def tracker(self) -> GroupedFilesTracker:
+        tracker = IouTracker(get_current_config=self.get_current_config)
+        return GroupedFilesTracker(
+            tracker=tracker,
+            chunk_parser=self.chunk_parser,
+            frame_group_parser=self.frame_group_parser,
+            id_generator_factory=lambda _: track_id_generator(),
+        )
+
+    @cached_property
+    def unfinished_chunks_buffer(self) -> UnfinishedChunksBuffer:
+        return UnfinishedChunksBuffer(tracker=self.tracker, keep_discarded=True)
+
+    @cached_property
+    def track_exporter(self) -> FinishedTracksExporter:
+        return FinishedChunkTrackExporter()
+
+    @cached_property
+    def update_current_track_config(self) -> UpdateCurrentTrackConfig:
+        return UpdateCurrentTrackConfig(
+            get_current_config=self.get_current_config,
+            update_current_config=self.update_current_config,
+        )
+
+    @cached_property
+    def tracking_run_id_generator(self) -> StrIdGenerator:
+        return tracking_run_uuid_generator
+
+    def __init__(self, argv: list[str] | None = None) -> None:
+        self.argv = argv
+
+    def build(self) -> OtvisionTrack:
+        return OtvisionTrack(
+            get_current_config=self.get_current_config,
+            track_exporter=self.track_exporter,
+            unfinished_chunks_buffer=self.unfinished_chunks_buffer,
+            tracking_run_id_generator=self.tracking_run_id_generator,
+        )

OTVision/track/cli.py

@@ -0,0 +1,128 @@
+from argparse import ArgumentParser, BooleanOptionalAction, Namespace
+from pathlib import Path
+
+from OTVision.domain.cli import CliParseError, TrackCliArgs, TrackCliParser
+from OTVision.helpers.files import check_if_all_paths_exist
+from OTVision.helpers.log import DEFAULT_LOG_FILE, VALID_LOG_LEVELS
+
+
+class ArgparseTrackCliParser(TrackCliParser):
+    def __init__(
+        self,
+        parser: ArgumentParser,
+        argv: list[str] | None = None,
+    ) -> None:
+        self._parser = parser
+        self._argv = argv
+        self.__setup()
+
+    def __setup(self) -> None:
+        self._parser.add_argument(
+            "-p",
+            "--paths",
+            nargs="+",
+            type=str,
+            help="Path or list of paths to detections files",
+            required=False,
+        )
+        self._parser.add_argument(
+            "-c",
+            "--config",
+            type=str,
+            help="Path to custom user configuration yaml file.",
+            required=False,
+        )
+        self._parser.add_argument(
+            "-o",
+            "--overwrite",
+            action=BooleanOptionalAction,
+            help="Overwrite existing output files",
+        )
+        self._parser.add_argument(
+            "--sigma-l",
+            type=float,
+            help="Set sigma_l parameter for tracking",
+        )
+        self._parser.add_argument(
+            "--sigma-h",
+            type=float,
+            help="Set sigma_h parameter for tracking",
+        )
+        self._parser.add_argument(
+            "--sigma-iou",
+            type=float,
+            help="Set sigma_iou parameter for tracking",
+        )
+        self._parser.add_argument(
+            "--t-min",
+            type=int,
+            help="Set t_min parameter for tracking",
+        )
+        self._parser.add_argument(
+            "--t-miss-max",
+            type=int,
+            help="Set t_miss_max parameter for tracking",
+        )
+        self._parser.add_argument(
+            "--log-level-console",
+            type=str,
+            choices=VALID_LOG_LEVELS,
+            help="Log level for logging to the console",
+            required=False,
+        )
+        self._parser.add_argument(
+            "--log-level-file",
+            type=str,
+            choices=VALID_LOG_LEVELS,
+            help="Log level for logging to a log file",
+            required=False,
+        )
+        self._parser.add_argument(
+            "--logfile",
+            default=str(DEFAULT_LOG_FILE),
+            type=str,
+            help="Specify log file directory.",
+            required=False,
+        )
+        self._parser.add_argument(
+            "--logfile-overwrite",
+            action="store_true",
+            help="Overwrite log file if it already exists.",
+            required=False,
+        )
+
+    def parse(self) -> TrackCliArgs:
+        args = self._parser.parse_args(self._argv)
+        self.__assert_cli_args_valid(args)
+
+        return TrackCliArgs(
+            paths=self._parse_files(args.paths),
+            config_file=args.config,
+            overwrite=args.overwrite,
+            sigma_l=float(args.sigma_l) if args.sigma_l is not None else None,
+            sigma_h=float(args.sigma_h) if args.sigma_h is not None else None,
+            sigma_iou=float(args.sigma_iou) if args.sigma_iou is not None else None,
+            t_min=int(args.t_min) if args.t_min is not None else None,
+            t_miss_max=int(args.t_miss_max) if args.t_miss_max is not None else None,
+            logfile=Path(args.logfile),
+            log_level_console=args.log_level_console,
+            log_level_file=args.log_level_file,
+            logfile_overwrite=args.logfile_overwrite,
+        )
+
+    def __assert_cli_args_valid(self, args: Namespace) -> None:
+        if args.paths is None and args.config is None:
+            raise CliParseError(
+                (
+                    "No paths have been passed as command line args."
+                    "No user config has been passed as command line arg."
+                )
+            )
+
+    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 list(map(str, result))

OTVision/track/exporter/filebased_exporter.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 
-from OTVision.config import CONFIG, DEFAULT_FILETYPE, TRACK
+from OTVision.application.config import DEFAULT_FILETYPE, TRACK
+from OTVision.config import CONFIG
 from OTVision.track.model.filebased.frame_chunk import FinishedChunk
 from OTVision.track.model.filebased.frame_group import get_output_file
 from OTVision.track.model.track_exporter import FinishedTracksExporter

OTVision/track/id_generator.py

@@ -0,0 +1,15 @@
+import uuid
+from typing import Callable, Iterator
+
+StrIdGenerator = Callable[[], str]
+
+
+def tracking_run_uuid_generator() -> str:
+    return str(uuid.uuid4())
+
+
+def track_id_generator() -> Iterator[int]:
+    track_id: int = 0
+    while True:
+        track_id += 1
+        yield track_id

OTVision/track/model/track_exporter.py

@@ -5,7 +5,8 @@ from typing import Generic, Iterator, TypeVar
 
 from tqdm import tqdm
 
-from OTVision.config import CONFIG, DEFAULT_FILETYPE, TRACK
+from OTVision.application.config import DEFAULT_FILETYPE, TRACK
+from OTVision.config import CONFIG
 from OTVision.dataformat import (
     DATA,
     DETECTIONS,

OTVision/track/model/tracking_interfaces.py

@@ -10,7 +10,7 @@ from OTVision.domain.frame import (
     TrackedFrame,
 )
 
-ID_GENERATOR = Iterator[TrackId]
+IdGenerator = Iterator[TrackId]
 
 
 class Tracker(ABC):
@@ -23,7 +23,7 @@ class Tracker(ABC):
     """
 
     def track(
-        self, frames: Iterator[DetectedFrame], id_generator: ID_GENERATOR
+        self, frames: Iterator[DetectedFrame], id_generator: IdGenerator
     ) -> Iterator[TrackedFrame]:
         """Process the given stream of Frames,
         yielding TrackedFrames one by one as a lazy stream of TrackedFrames.
@@ -31,7 +31,7 @@ class Tracker(ABC):
         Args:
             frames (Iterator[DetectedFrame]): (lazy) stream of Frames
                 with untracked Detections.
-            id_generator (ID_GENERATOR): provider of new (unique) track ids.
+            id_generator (IdGenerator): provider of new (unique) track ids.
 
         Yields:
             Iterator[TrackedFrame]: (lazy) stream of TrackedFrames with
@@ -44,7 +44,7 @@ class Tracker(ABC):
     def track_frame(
         self,
         frame: DetectedFrame,
-        id_generator: ID_GENERATOR,
+        id_generator: IdGenerator,
     ) -> TrackedFrame:
         """Process single Frame with untracked Detections,
         by adding tracking information,
@@ -52,7 +52,7 @@ class Tracker(ABC):
 
         Args:
             frame (DetectedFrame): the Frame to be tracked.
-            id_generator (ID_GENERATOR): provider of new (unique) track ids.
+            id_generator (IdGenerator): provider of new (unique) track ids.
 
         Returns:
             TrackedFrame: TrackedFrame with TrackedDetections
@@ -270,7 +270,7 @@ class UnfinishedFramesBuffer(UnfinishedTracksBuffer[TrackedFrame, FinishedFrame]
         self._tracker = tracker
 
     def track(
-        self, frames: Iterator[DetectedFrame], id_generator: ID_GENERATOR
+        self, frames: Iterator[DetectedFrame], id_generator: IdGenerator
     ) -> Iterator[FinishedFrame]:
         tracked_frame_stream = self._tracker.track(frames, id_generator)
         return self.track_and_finish(tracked_frame_stream)

OTVision/track/parser/frame_group_parser_plugins.py

@@ -2,7 +2,9 @@ import re
 from datetime import datetime, timedelta
 from pathlib import Path
 
-from OTVision import version
+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,
@@ -16,6 +18,7 @@ from OTVision.dataformat import (
     TRACKING,
     VIDEO,
 )
+from OTVision.detect.otdet import parse_video_length
 from OTVision.helpers.files import (
     FULL_FILE_NAME_PATTERN,
     HOSTNAME,
@@ -30,12 +33,27 @@ MISSING_EXPECTED_DURATION = timedelta(minutes=15)
 
 
 class TimeThresholdFrameGroupParser(FrameGroupParser):
+    @property
+    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, tracker_data: dict, time_without_frames: timedelta = timedelta(minutes=1)
+        self,
+        get_current_config: GetCurrentConfig,
+        time_without_frames: timedelta = timedelta(minutes=1),
     ):
+        self._get_current_config = get_current_config
         self._time_without_frames = time_without_frames
-        self._tracker_data: dict = tracker_data
         self._id_count = 0
 
     def new_id(self) -> int:
@@ -86,8 +104,7 @@ class TimeThresholdFrameGroupParser(FrameGroupParser):
 
     def parse_video_length(self, metadata: dict) -> timedelta:
         video_length = metadata[VIDEO][LENGTH]
-        time = datetime.strptime(video_length, "%H:%M:%S")
-        return timedelta(hours=time.hour, minutes=time.minute, seconds=time.second)
+        return parse_video_length(video_length)
 
     def update_metadata(self, frame_group: FrameGroup) -> dict[Path, dict]:
         metadata_by_file = dict(frame_group.metadata_by_file)
@@ -125,3 +142,16 @@ 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,
+    }