OTVision 0.5.5__py3-none-any.whl → 0.6.0__py3-none-any.whl

OTVision/abstraction/observer.py

@@ -0,0 +1,43 @@
+from typing import Callable, TypeVar
+
+VALUE = TypeVar("VALUE")
+type Observer[T] = Callable[[T], None]
+
+
+class Subject[T]:
+    """Generic subject class to handle and notify observers.
+
+    This class ensures that no duplicate observers can be registered.
+    The order that registered observers are notified is dictated by the order they have
+    been registered. Meaning, first to be registered is first to be notified.
+    """
+
+    def __init__(self) -> None:
+        self._observers: list[Observer[T]] = []
+
+    def register(self, observer: Observer[T]) -> None:
+        """Listen to changes of subject.
+
+        Args:
+            observer (OBSERVER): the observer to be registered. This must be a
+                `Callable`.
+        """
+        new_observers = self._observers.copy()
+        new_observers.append(observer)
+        self._observers = list(dict.fromkeys(new_observers))
+
+    def notify(self, value: T) -> None:
+        """Notifies observers about the list of tracks.
+
+        Args:
+            value (VALUE): value to notify the observer with.
+        """
+        [notify_observer(value) for notify_observer in self._observers]
+
+
+class Observable[T]:
+    def __init__(self, subject: Subject[T]) -> None:
+        self._subject = subject
+
+    def register(self, observer: Observer[T]) -> None:
+        self._subject.register(observer)

OTVision/abstraction/pipes_and_filter.py

@@ -0,0 +1,28 @@
+from abc import ABC, abstractmethod
+from typing import Generator
+
+
+class Filter[IN, OUT](ABC):
+    """Abstract base class for implementing pipe-and-filter pattern filters.
+
+    A filter processes a stream of input elements and produces a stream of output
+    elements. This class defines the interface for all concrete filter implementations.
+
+    Type Parameters:
+        IN: The type of elements that the filter receives as input.
+        OUT: The type of elements that the filter produces as output.
+    """
+
+    @abstractmethod
+    def filter(self, pipe: Generator[IN, None, None]) -> Generator[OUT, None, None]:
+        """Process elements from the input pipe and produce output elements.
+
+        Args:
+            pipe (Generator[IN, None, None]): Input stream of elements to be processed.
+
+        Returns:
+            Generator[OUT, None, None]: Output stream of processed elements.
+
+        """
+
+        raise NotImplementedError

OTVision/application/buffer.py

@@ -0,0 +1,34 @@
+from abc import abstractmethod
+from typing import Generator
+
+from OTVision.abstraction.observer import Observable, Subject
+from OTVision.abstraction.pipes_and_filter import Filter
+
+
+class Buffer[T, SUBJECT_TYPE, OBSERVING_TYPE](Observable[SUBJECT_TYPE], Filter[T, T]):
+    def __init__(self, subject: Subject[SUBJECT_TYPE]) -> None:
+        super().__init__(subject)
+        self._buffer: list[T] = []
+
+    def filter(self, pipe: Generator[T, None, None]) -> Generator[T, None, None]:
+        for element in pipe:
+            self.buffer(element)
+            yield element
+
+    def buffer(self, to_buffer: T) -> None:
+        self._buffer.append(to_buffer)
+
+    def _get_buffered_elements(self) -> list[T]:
+        return self._buffer
+
+    def _reset_buffer(self) -> None:
+        self._buffer = []
+
+    def on_flush(self, event: OBSERVING_TYPE) -> None:
+        buffered_elements = self._get_buffered_elements()
+        self._notify_observers(buffered_elements, event)
+        self._reset_buffer()
+
+    @abstractmethod
+    def _notify_observers(self, elements: list[T], event: OBSERVING_TYPE) -> None:
+        raise NotImplementedError

OTVision/application/detect/current_object_detector.py

@@ -0,0 +1,40 @@
+from typing import Generator
+
+from OTVision.abstraction.pipes_and_filter import Filter
+from OTVision.application.get_current_config import GetCurrentConfig
+from OTVision.domain.detection import DetectedFrame
+from OTVision.domain.frame import Frame
+from OTVision.domain.object_detection import ObjectDetector, ObjectDetectorFactory
+
+
+class CurrentObjectDetector(Filter[Frame, DetectedFrame]):
+    """Use case to retrieve the currently used object detector.
+
+    Filter implementation for detecting objects in frames using current
+    configuration.
+
+    Args:
+        get_current_config (GetCurrentConfig): Provider of current configuration.
+        factory (ObjectDetectorFactory): Factory for creating object detector instances.
+    """
+
+    def __init__(
+        self, get_current_config: GetCurrentConfig, factory: ObjectDetectorFactory
+    ) -> None:
+        self._get_current_config = get_current_config
+        self._factory = factory
+
+    def get(self) -> ObjectDetector:
+        """Retrieve the currently used object detector.
+
+        Returns:
+            ObjectDetector: The object detector.
+
+        """
+        detect_config = self._get_current_config.get().detect
+        return self._factory.create(detect_config)
+
+    def filter(
+        self, pipe: Generator[Frame, None, None]
+    ) -> Generator[DetectedFrame, None, None]:
+        return self.get().detect(pipe)

OTVision/application/detect/current_object_detector_metadata.py

@@ -0,0 +1,27 @@
+from OTVision.application.detect.current_object_detector import CurrentObjectDetector
+from OTVision.domain.object_detection import ObjectDetectorMetadata
+
+
+class CurrentObjectDetectorMetadata:
+    """Provider for metadata about the currently configured object detector.
+
+    This class serves as a wrapper to access metadata information about the
+    currently configured object detector.
+
+    Args:
+        current_object_detector (CurrentObjectDetector): The current object detector
+            instance from which to retrieve metadata.
+    """
+
+    def __init__(self, current_object_detector: CurrentObjectDetector) -> None:
+        self.current_object_detector = current_object_detector
+
+    def get(self) -> ObjectDetectorMetadata:
+        """Retrieve metadata about the currently configured object detector.
+
+        Returns:
+            ObjectDetectorMetadata: Metadata information about the current object
+                detector configuration.
+        """
+
+        return self.current_object_detector.get()

OTVision/application/detect/detected_frame_factory.py

@@ -0,0 +1,26 @@
+from OTVision.domain.detection import DetectedFrame, Detection
+from OTVision.domain.frame import Frame, FrameKeys
+
+
+class DetectedFrameFactory:
+    """Factory for creating DetectedFrame objects from Frame and Detection data."""
+
+    def create(self, frame: Frame, detections: list[Detection]) -> DetectedFrame:
+        """Creates a DetectedFrame object from a Frame and its detections.
+
+        Args:
+            frame (Frame): the frame object.
+            detections (list[Detection]): The detections to be associated with
+                the frame.
+
+        Returns:
+            DetectedFrame: A new DetectedFrame instance containing the combined frame
+                and detection information.
+        """
+
+        return DetectedFrame(
+            source=frame[FrameKeys.source],
+            frame_number=frame[FrameKeys.frame],
+            occurrence=frame[FrameKeys.occurrence],
+            detections=detections,
+        )

OTVision/application/detect/detected_frame_producer.py

@@ -0,0 +1,25 @@
+from typing import Generator
+
+from OTVision.abstraction.pipes_and_filter import Filter
+from OTVision.domain.detect_producer_consumer import DetectedFrameProducer
+from OTVision.domain.detection import DetectedFrame
+from OTVision.domain.frame import Frame
+from OTVision.domain.input_source_detect import InputSourceDetect
+
+
+class SimpleDetectedFrameProducer(DetectedFrameProducer):
+
+    def __init__(
+        self,
+        input_source: InputSourceDetect,
+        detection_filter: Filter[Frame, DetectedFrame],
+        detected_frame_buffer: Filter[DetectedFrame, DetectedFrame],
+    ) -> None:
+        self._input_source = input_source
+        self._detection_filter = detection_filter
+        self._detected_frame_buffer = detected_frame_buffer
+
+    def produce(self) -> Generator[DetectedFrame, None, None]:
+        return self._detected_frame_buffer.filter(
+            self._detection_filter.filter(self._input_source.produce())
+        )

OTVision/application/detect/detection_file_save_path_provider.py

@@ -0,0 +1,59 @@
+from pathlib import Path
+
+from OTVision.application.get_current_config import GetCurrentConfig
+
+
+class DetectionFileSavePathProvider:
+    """Provides a mechanism to generate file save paths for detections.
+
+    This class is responsible for deriving the appropriate filenames for
+    detection files based on the source and current configuration
+    settings. It utilizes a configuration provider to dynamically fetch
+    the required configuration values.
+
+    Args:
+        get_current_config (GetCurrentConfig): Retrieve the current application
+            configuration.
+    """
+
+    def __init__(self, get_current_config: GetCurrentConfig) -> None:
+        self._get_current_config = get_current_config
+
+    def provide(self, source: str) -> Path:
+        config = self._get_current_config.get()
+        return derive_filename(
+            video_file=Path(source),
+            detect_suffix=config.filetypes.detect,
+            detect_start=config.detect.detect_start,
+            detect_end=config.detect.detect_end,
+        )
+
+
+def derive_filename(
+    video_file: Path,
+    detect_suffix: str,
+    detect_start: int | None = None,
+    detect_end: int | None = None,
+) -> Path:
+    """
+    Generates a filename for detection files by appending specified start and end
+    markers and a suffix to the stem of the input video file.
+
+    Args:
+        video_file (Path): The input video file whose filename is to be modified.
+        detect_start (int | None): The starting marker to append to the filename.
+            If None, no starting marker will be appended.
+        detect_end (int | None): The ending marker to append to the filename. If None,
+            no ending marker will be appended.
+        detect_suffix (str): The file suffix to apply to the derived filename.
+
+    Returns:
+        Path: The modified video file path with the updated stem and suffix applied.
+    """
+    cutout = ""
+    if detect_start is not None:
+        cutout += f"_start_{detect_start}"
+    if detect_end is not None:
+        cutout += f"_end_{detect_end}"
+    new_stem = f"{video_file.stem}{cutout}"
+    return video_file.with_stem(new_stem).with_suffix(detect_suffix)

OTVision/application/detect/factory.py

@@ -0,0 +1,25 @@
+from OTVision.config import DetectConfig
+from OTVision.domain.object_detection import ObjectDetector, ObjectDetectorFactory
+
+
+class ObjectDetectorCachedFactory(ObjectDetectorFactory):
+
+    def __init__(self, other: ObjectDetectorFactory) -> None:
+        self._other = other
+        self.__cache: dict[str, ObjectDetector] = {}
+
+    def create(self, config: DetectConfig) -> ObjectDetector:
+        if cached_model := self.__cache.get(config.yolo_config.weights):
+            return cached_model
+        model = self._other.create(config)
+        self.__add_to_cache(model)
+        return model
+
+    def __add_to_cache(self, model: ObjectDetector) -> None:
+        weights = model.config.yolo_config.weights
+        if not self.__cache.get(weights):
+            self.__cache[weights] = model
+
+    def __remove_from_cache(self, weights: str) -> None:
+        if self.__cache.get(weights):
+            del self.__cache[weights]

OTVision/application/detect/timestamper.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+
+from OTVision.domain.frame import Frame
+
+
+class Timestamper(ABC):
+    """Interface for adding timestamps to frame data.
+
+    This class defines the interface for timestamp processors that convert raw frame
+    dictionaries into Frame objects with proper timestamp information.
+    """
+
+    @abstractmethod
+    def stamp(self, frame: dict) -> Frame:
+        """Add timestamp information to a frame.
+
+        Args:
+            frame (dict): Raw frame data dictionary to be processed.
+
+        Returns:
+            Frame: A Frame object with added timestamp information.
+
+        """
+
+        raise NotImplementedError

OTVision/application/detect/update_detect_config_with_cli_args.py

@@ -68,6 +68,11 @@ class UpdateDetectConfigWithCliArgs:
                 if cli_args.half is not None
                 else detect_config.half_precision
             ),
+            start_time=(
+                cli_args.start_time
+                if cli_args.start_time is not None
+                else detect_config.start_time
+            ),
             detect_start=(
                 cli_args.detect_start
                 if cli_args.detect_start is not None

OTVision/application/frame_count_provider.py

@@ -0,0 +1,23 @@
+from abc import ABC
+from pathlib import Path
+
+
+class FrameCountProvider(ABC):
+    """Abstract base class for retrieving the total number of frames in a video file.
+
+    This interface defines the contract for components that can determine the frame
+    count of video files. Implementations might use different methods or libraries
+    to calculate the total number of frames.
+    """
+
+    def provide(self, video_file: Path) -> int:
+        """Get the total number of frames in a video file.
+
+        Args:
+            video_file (Path): Path to the video file to analyze.
+
+        Returns:
+            int: Total number of frames in the video.
+
+        """
+        raise NotImplementedError

OTVision/application/get_current_config.py

@@ -0,0 +1,10 @@
+from OTVision.config import Config
+from OTVision.domain.current_config import CurrentConfig
+
+
+class GetCurrentConfig:
+    def __init__(self, current_config: CurrentConfig) -> None:
+        self._current_config = current_config
+
+    def get(self) -> Config:
+        return self._current_config.get()

OTVision/application/update_current_config.py

@@ -0,0 +1,10 @@
+from OTVision.config import Config
+from OTVision.domain.current_config import CurrentConfig
+
+
+class UpdateCurrentConfig:
+    def __init__(self, current_config: CurrentConfig) -> None:
+        self._current_config = current_config
+
+    def update(self, config: Config) -> None:
+        self._current_config.update(config)

OTVision/config.py

@@ -22,7 +22,7 @@ OTVision config module for setting default values
 
 import logging
 from dataclasses import dataclass, field
-from datetime import timedelta
+from datetime import datetime, timedelta
 from pathlib import Path
 
 import yaml
@@ -85,9 +85,12 @@ LOG = "LOG"
 LOG_LEVEL_CONSOLE = "LOG_LEVEL_CONSOLE"
 LOG_LEVEL_FILE = "LOG_LEVEL_FILE"
 LOG_DIR = "LOG_DIR"
+START_TIME = "START_TIME"
 DETECT_END = "DETECT_END"
 DETECT_START = "DETECT_START"
 
+DATETIME_FORMAT = "%Y-%m-%d_%H-%M-%S"
+
 """Default length of a video is 15 minutes."""
 DEFAULT_EXPECTED_DURATION: timedelta = timedelta(minutes=15)
 
@@ -260,6 +263,18 @@ class _YoloWeights:
 
 @dataclass(frozen=True)
 class YoloConfig:
+    """Represents the configuration for the YOLO model.
+
+    Attributes:
+        weights (str): Path to YOLO model weights.
+        available_weights (_YoloWeights): List of available default YOLO model weights.
+        conf (float): Confidence threshold.
+        iou (float): Intersection over union threshold.
+        img_size (int): Size of the input image.
+        chunk_size (int): Chunk size for processing.
+        normalized (bool): Whether to normalize the bounding boxes.
+    """
+
     weights: str = _YoloWeights.yolov8s
     available_weights: _YoloWeights = _YoloWeights()
     conf: float = 0.25
@@ -291,12 +306,55 @@ class YoloConfig:
 
 @dataclass(frozen=True)
 class DetectConfig:
+    """Represents the configuration for the `detect` command.
+
+    Attributes:
+        paths (list[Path]): List of  files to be processed.
+        run_chained (bool): Whether to run chained commands.
+        yolo_config (YoloConfig): Configuration for the YOLO model.
+        expected_duration (timedelta | None): Expected duration of the video.
+            `None` if unknown.
+        overwrite (bool): Whether to overwrite existing files.
+        half_precision (bool): Whether to use half precision.
+        detect_start (int | None): Start frame for detection expressed in seconds.
+            Value `None` marks the start of the video.
+        detect_end (int | None): End frame for detection expressed in seconds.
+            Value `None` marks the end of the video.
+
+    """
+
+    @property
+    def confidence(self) -> float:
+        """Gets the confidence level set in the YOLO configuration.
+
+        Returns:
+            float: The intersection over union threshold value.
+        """
+        return self.yolo_config.conf
+
+    @property
+    def weights(self) -> str:
+        return self.yolo_config.weights
+
+    @property
+    def iou(self) -> float:
+        return self.yolo_config.iou
+
+    @property
+    def img_size(self) -> int:
+        return self.yolo_config.img_size
+
+    @property
+    def normalized(self) -> bool:
+        return self.yolo_config.normalized
+
     paths: list[Path] = field(default_factory=list)
     run_chained: bool = True
     yolo_config: YoloConfig = YoloConfig()
     expected_duration: timedelta | None = None
     overwrite: bool = True
     half_precision: bool = False
+    start_time: datetime | None = None
     detect_start: int | None = None
     detect_end: int | None = None
 
@@ -314,6 +372,7 @@ class DetectConfig:
         if expected_duration is not None:
             expected_duration = timedelta(seconds=int(expected_duration))
 
+        start_time = DetectConfig._parse_start_time(d)
         return DetectConfig(
             files,
             d.get(RUN_CHAINED, DetectConfig.run_chained),
@@ -321,10 +380,17 @@ class DetectConfig:
             expected_duration,
             d.get(OVERWRITE, DetectConfig.overwrite),
             d.get(HALF_PRECISION, DetectConfig.half_precision),
+            start_time,
             d.get(DETECT_START, DetectConfig.detect_start),
             d.get(DETECT_END, DetectConfig.detect_end),
         )
 
+    @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 to_dict(self) -> dict:
         expected_duration = (
             int(self.expected_duration.total_seconds())
@@ -338,6 +404,9 @@ class DetectConfig:
             EXPECTED_DURATION: expected_duration,
             OVERWRITE: self.overwrite,
             HALF_PRECISION: self.half_precision,
+            START_TIME: self.start_time,
+            DETECT_START: self.detect_start,
+            DETECT_END: self.detect_end,
         }