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

OTVision/detect/rtsp_based_detect_builder.py

@@ -2,11 +2,18 @@ from functools import cached_property
 
 from OTVision.abstraction.observer import Subject
 from OTVision.application.config import StreamConfig
+from OTVision.application.event.new_video_start import NewVideoStartEvent
 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
+from OTVision.domain.video_writer import VideoWriter
+from OTVision.plugin.ffmpeg_video_writer import (
+    FfmpegVideoWriter,
+    PixelFormat,
+    VideoFormat,
+    keep_original_save_location,
+)
 
 FLUSH_BUFFER_SIZE = 18000
 FLUSH_BUFFER_SIZE = 1200
@@ -24,9 +31,10 @@ class RtspBasedDetectBuilder(DetectBuilder):
         return config.stream
 
     @cached_property
-    def input_source(self) -> InputSourceDetect:
+    def input_source(self) -> RtspInputSource:
         return RtspInputSource(
-            subject=Subject[FlushEvent](),
+            subject_flush=Subject[FlushEvent](),
+            subject_new_video_start=Subject[NewVideoStartEvent](),
             datetime_provider=self.datetime_provider,
             frame_counter=Counter(),
             get_current_config=self.get_current_config,
@@ -35,3 +43,27 @@ class RtspBasedDetectBuilder(DetectBuilder):
     @cached_property
     def datetime_provider(self) -> DatetimeProvider:
         return CurrentDatetimeProvider()
+
+    @cached_property
+    def video_file_writer(self) -> VideoWriter:
+        return FfmpegVideoWriter(
+            save_location_strategy=keep_original_save_location,
+            encoding_speed=self.detect_config.encoding_speed,
+            input_format=VideoFormat.RAW,
+            output_format=VideoFormat.MP4,
+            input_pixel_format=PixelFormat.RGB24,
+            output_pixel_format=PixelFormat.YUV420P,
+            output_video_codec=self.detect_config.video_codec,
+            constant_rate_factor=self.detect_config.crf,
+        )
+
+    def register_observers(self) -> None:
+        if self.detect_config.write_video:
+            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
+            )
+        self.input_source.subject_flush.register(self.detected_frame_buffer.on_flush)
+        self.detected_frame_buffer.register(self.otdet_file_writer.write)

OTVision/detect/rtsp_input_source.py

@@ -1,6 +1,8 @@
+import socket
 from datetime import datetime, timedelta
 from time import sleep
-from typing import Generator
+from typing import Iterator
+from urllib.parse import urlparse
 
 from cv2 import (
     CAP_PROP_FRAME_HEIGHT,
@@ -19,6 +21,8 @@ from OTVision.application.config import (
     StreamConfig,
 )
 from OTVision.application.configure_logger import logger
+from OTVision.application.event.new_otvision_config import NewOtvisionConfigEvent
+from OTVision.application.event.new_video_start import NewVideoStartEvent
 from OTVision.application.get_current_config import GetCurrentConfig
 from OTVision.detect.detected_frame_buffer import FlushEvent
 from OTVision.domain.frame import Frame
@@ -26,10 +30,14 @@ 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
+RETRY_SECONDS = 5
 DEFAULT_READ_FAIL_THRESHOLD = 5
 
 
+class NoConfigurationFoundError(Exception):
+    """Raised when no configuration is found for the RTSP stream."""
+
+
 class Counter:
     def __init__(self, start_value: int = 0) -> None:
         self._start_value = start_value
@@ -63,7 +71,7 @@ class RtspInputSource(InputSourceDetect):
     def stream_config(self) -> StreamConfig:
         if stream_config := self.config.stream:
             return stream_config
-        raise ValueError("Stream config not found in config")
+        raise NoConfigurationFoundError("Stream config not found in config")
 
     @property
     def rtsp_url(self) -> str:
@@ -79,13 +87,16 @@ class RtspInputSource(InputSourceDetect):
 
     def __init__(
         self,
-        subject: Subject[FlushEvent],
+        subject_flush: Subject[FlushEvent],
+        subject_new_video_start: Subject[NewVideoStartEvent],
         datetime_provider: DatetimeProvider,
         frame_counter: Counter,
         get_current_config: GetCurrentConfig,
         read_fail_threshold: int = DEFAULT_READ_FAIL_THRESHOLD,
     ) -> None:
-        super().__init__(subject)
+
+        self.subject_flush = subject_flush
+        self.subject_new_video_start = subject_new_video_start
         self._datetime_provider = datetime_provider
         self._stop_capture = False
         self._frame_counter = frame_counter
@@ -120,44 +131,53 @@ class RtspInputSource(InputSourceDetect):
         self._current_video_capture = self._init_video_capture(self._current_stream)
         return self._current_video_capture
 
-    def produce(self) -> Generator[Frame, None, None]:
+    def produce(self) -> Iterator[Frame]:
         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()
+        try:
+            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
+                        self._notify_new_video_start_observers()
+
+                    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_flush_observers()
+                        self._outdated = True
+                        self._frame_counter.reset()
+            self._notify_flush_observers()
+        except InvalidRtspUrlError as cause:
+            logger().error(cause)
 
     def _init_video_capture(self, source: str) -> VideoCapture:
+        self._wait_for_connection(source)
+
         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()
+            self._wait_for_connection(source)
             cap = VideoCapture(source)
         return cap
 
+    def _wait_for_connection(self, connection: str) -> None:
+        while not self.should_stop() and not is_connection_available(connection):
+            logger().debug(
+                f"Couldn't open the RTSP stream: {connection}. "
+                f"Trying again in {RETRY_SECONDS}s..."
+            )
+            sleep(RETRY_SECONDS)
+
     def _read_next_frame(self) -> ndarray | None:
         successful, frame = self._video_capture.read()
         if successful:
@@ -189,9 +209,9 @@ class RtspInputSource(InputSourceDetect):
     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))
+    def _notify_flush_observers(self) -> None:
+        frame_width = self._get_width()
+        frame_height = self._get_height()
         frames = (
             self.flush_buffer_size
             if self.current_frame_number % self.flush_buffer_size == 0
@@ -199,7 +219,7 @@ class RtspInputSource(InputSourceDetect):
         )
         duration = timedelta(seconds=round(frames / self.fps))
         output = self.create_output()
-        self._subject.notify(
+        self.subject_flush.notify(
             FlushEvent.create(
                 source=self.rtsp_url,
                 output=output,
@@ -211,6 +231,21 @@ class RtspInputSource(InputSourceDetect):
             )
         )
 
+    def _get_width(self) -> int:
+        return int(self._video_capture.get(CAP_PROP_FRAME_WIDTH))
+
+    def _get_height(self) -> int:
+        return int(self._video_capture.get(CAP_PROP_FRAME_HEIGHT))
+
+    def _notify_new_video_start_observers(self) -> None:
+        event = NewVideoStartEvent(
+            output=self.create_output(),
+            width=self._get_width(),
+            height=self._get_height(),
+            fps=self.fps,
+        )
+        self.subject_new_video_start.notify(event)
+
     def create_output(self) -> str:
         output_filename = (
             f"{self.stream_config.name}_FR{round(self.fps)}"
@@ -218,6 +253,68 @@ class RtspInputSource(InputSourceDetect):
         )
         return str(self.stream_config.save_dir / output_filename)
 
+    def notify_new_config(self, config: NewOtvisionConfigEvent) -> None:
+        try:
+            logger().debug("New OTVision config detected. Flushing buffers...")
+            self._notify_flush_observers()
+        except NoConfigurationFoundError:
+            logger().info("No configuration found for RTSP stream. Skipping flushing.")
+
 
 def convert_frame_to_rgb(frame: ndarray) -> ndarray:
     return cvtColor(frame, COLOR_BGR2RGB)
+
+
+class InvalidRtspUrlError(Exception):
+    """Raised when the RTSP URL is invalid."""
+
+
+def is_connection_available(rtsp_url: str) -> bool:
+    """
+    Check if RTSP connection is available by sending a DESCRIBE request.
+
+    Args:
+        rtsp_url: The RTSP URL to check
+
+    Returns:
+        bool: True if stream is available, False otherwise
+    """
+    try:
+        parsed = urlparse(rtsp_url)
+        if parsed.hostname is None and parsed.port is None:
+            raise InvalidRtspUrlError(
+                f"Invalid RTSP URL: {rtsp_url}. Missing hostname or port."
+            )
+
+        host = parsed.hostname
+        port = parsed.port
+
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.settimeout(5)
+
+        if sock.connect_ex((host, port)) != 0:
+            sock.close()
+            return False
+
+        # Send RTSP DESCRIBE request to get stream info
+        rtsp_request = (
+            f"DESCRIBE {rtsp_url} RTSP/1.0\r\n"
+            f"CSeq: 1\r\n"
+            f"Accept: application/sdp\r\n\r\n"
+        )
+        sock.send(rtsp_request.encode())
+
+        # Read response
+        response = sock.recv(4096).decode()
+        sock.close()
+
+        # Check if we got a valid RTSP response with SDP content
+        return (
+            response.startswith("RTSP/1.0 200 OK")
+            and "application/sdp" in response
+            and "m=video" in response
+        )
+    except InvalidRtspUrlError:
+        raise
+    except Exception:
+        return False

OTVision/detect/video_input_source.py

@@ -1,18 +1,18 @@
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Generator
+from typing import Iterator
 
 import av
+from av.container.input import InputContainer
 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.event.new_video_start import NewVideoStartEvent
 from OTVision.application.get_current_config import GetCurrentConfig
+from OTVision.application.otvision_save_path_provider import OtvisionSavePathProvider
 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
@@ -38,11 +38,14 @@ class VideoSource(InputSourceDetect):
     and selective frame processing based on configuration parameters.
 
     Args:
+        subject_flush: (Subject[FlushEvent]): Subject for notifying about flush events.
+        subject_new_video_start (Subject[NewVideoStartEvent): Subject for notifying
+            about new video start events.
         get_current_config (GetCurrentConfig): Use case to retrieve current
             configuration.
         frame_rotator (AvVideoFrameRotator): Use to rotate video frames.
         timestamper_factory (Timestamper): Factory for creating timestamp generators.
-        save_path_provider (DetectionFileSavePathProvider): Provider for detection
+        save_path_provider (OtvisionSavePathProvider): Provider for detection
             output paths.
     """
 
@@ -56,20 +59,22 @@ class VideoSource(InputSourceDetect):
 
     def __init__(
         self,
-        subject: Subject[FlushEvent],
+        subject_flush: Subject[FlushEvent],
+        subject_new_video_start: Subject[NewVideoStartEvent],
         get_current_config: GetCurrentConfig,
         frame_rotator: AvVideoFrameRotator,
         timestamper_factory: TimestamperFactory,
-        save_path_provider: DetectionFileSavePathProvider,
+        save_path_provider: OtvisionSavePathProvider,
     ) -> None:
-        super().__init__(subject)
+        self.subject_flush = subject_flush
+        self.subject_new_video_start = subject_new_video_start
         self._frame_rotator = frame_rotator
         self._get_current_config = get_current_config
         self._timestamper_factory = timestamper_factory
         self._save_path_provider = save_path_provider
         self.__should_flush = False
 
-    def produce(self) -> Generator[Frame, None, None]:
+    def produce(self) -> Iterator[Frame]:
         """Generate frames from video files that meet detection requirements.
 
         Yields frames from valid video files while managing rotation, timestamping,
@@ -86,7 +91,9 @@ class VideoSource(InputSourceDetect):
         print(start_msg)
 
         for video_file in tqdm(video_files, desc="Detected video files", unit=" files"):
-            detections_file = self._save_path_provider.provide(str(video_file))
+            detections_file = self._save_path_provider.provide(
+                str(video_file), self._current_config.filetypes.detect
+            )
 
             if not self.__detection_requirements_are_met(video_file, detections_file):
                 continue
@@ -97,13 +104,14 @@ class VideoSource(InputSourceDetect):
                 expected_duration=self._current_config.detect.expected_duration,
             )
             video_fps = get_fps(video_file)
+            self.notify_new_video_start_observers(video_file, video_fps)
             detect_start = self.__get_detect_start_in_frames(video_fps)
             detect_end = self.__get_detect_end_in_frames(video_fps)
             counter = 0
             try:
                 with av.open(str(video_file.absolute())) as container:
                     container.streams.video[0].thread_type = "AUTO"
-                    side_data = container.streams.video[0].side_data
+                    side_data = self._extract_side_data(container)
                     for frame_number, frame in enumerate(
                         container.decode(video=0), start=1
                     ):
@@ -129,10 +137,20 @@ class VideoSource(InputSourceDetect):
                                 }
                             )
                         counter += 1
-                self.notify_observers(video_file, video_fps)
+                self.notify_flush_event_observers(video_file, video_fps)
             except Exception as e:
                 log.error(f"Error processing {video_file}", exc_info=e)
 
+    def _extract_side_data(self, container: InputContainer) -> dict:
+        try:
+            return container.streams.video[0].side_data
+        except AttributeError:
+            log.warning(
+                "No side_data found in video stream. "
+                "Existing rotation will not be applied."
+            )
+            return {}
+
     def __collect_files_to_detect(self) -> list[Path]:
         filetypes = self._current_config.filetypes.video_filetypes.to_list()
         video_files = get_files(
@@ -169,7 +187,9 @@ class VideoSource(InputSourceDetect):
             return False
         return True
 
-    def notify_observers(self, current_video_file: Path, video_fps: float) -> None:
+    def notify_flush_event_observers(
+        self, current_video_file: Path, video_fps: float
+    ) -> None:
         if expected_duration := self._current_config.detect.expected_duration:
             duration = expected_duration
         else:
@@ -180,7 +200,7 @@ class VideoSource(InputSourceDetect):
             current_video_file, start_time=self._start_time
         )
 
-        self._subject.notify(
+        self.subject_flush.notify(
             FlushEvent.create(
                 source=str(current_video_file),
                 output=str(current_video_file),
@@ -192,6 +212,18 @@ class VideoSource(InputSourceDetect):
             )
         )
 
+    def notify_new_video_start_observers(
+        self, current_video_file: Path, video_fps: float
+    ) -> None:
+        width, height = get_video_dimensions(current_video_file)
+        event = NewVideoStartEvent(
+            output=str(current_video_file),
+            width=width,
+            height=height,
+            fps=video_fps,
+        )
+        self.subject_new_video_start.notify(event)
+
     def __get_detect_start_in_frames(self, video_fps: float) -> int:
         detect_start = convert_seconds_to_frames(
             self._current_config.detect.detect_start, video_fps

OTVision/detect/yolo.py

@@ -22,7 +22,7 @@ OTVision module to detect objects using yolov5
 import logging
 from pathlib import Path
 from time import perf_counter
-from typing import Generator
+from typing import Iterator
 
 import torch
 from tqdm import tqdm
@@ -134,17 +134,21 @@ class YoloDetector(ObjectDetector, Filter[Frame, DetectedFrame]):
         self._detection_converter = detection_converter
         self._detected_frame_factory = detected_frame_factory
 
-    def filter(
-        self, pipe: Generator[Frame, None, None]
-    ) -> Generator[DetectedFrame, None, None]:
+    def filter(self, pipe: Iterator[Frame]) -> Iterator[DetectedFrame]:
         return self.detect(pipe)
 
-    def detect(
-        self, frames: Generator[Frame, None, None]
-    ) -> Generator[DetectedFrame, None, None]:
-        for frame in tqdm(frames, desc="Detected frames", unit=" frames"):
+    def detect(self, frames: Iterator[Frame]) -> Iterator[DetectedFrame]:
+        for frame in tqdm(
+            frames,
+            desc="Detected frames",
+            unit=" frames",
+            disable=self.disable_tqdm_logging(),
+        ):
             yield self._predict(frame)
 
+    def disable_tqdm_logging(self) -> bool:
+        return log.level > logging.INFO
+
     def _predict(self, frame: Frame) -> DetectedFrame:
         if frame[FrameKeys.data] is None:
             return self._create_empty_detection(frame)

OTVision/domain/cli.py

@@ -3,6 +3,12 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta
 from pathlib import Path
 
+from OTVision.plugin.ffmpeg_video_writer import (
+    ConstantRateFactor,
+    EncodingSpeed,
+    VideoCodec,
+)
+
 
 class CliArgs(ABC):
     @abstractmethod
@@ -32,6 +38,10 @@ class DetectCliArgs(CliArgs):
     start_time: datetime | None = None
     detect_start: int | None = None
     detect_end: int | None = None
+    write_video: bool | None = None
+    video_codec: VideoCodec | None = None
+    encoding_speed: EncodingSpeed | None = None
+    crf: ConstantRateFactor | None = None
 
     def get_config_file(self) -> Path | None:
         return self.config_file

OTVision/domain/detect_producer_consumer.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Generator
+from typing import Iterator
 
 from OTVision.domain.frame import DetectedFrame
 
@@ -21,10 +21,10 @@ class DetectedFrameProducer(ABC):
     """
 
     @abstractmethod
-    def produce(self) -> Generator[DetectedFrame, None, None]:
+    def produce(self) -> Iterator[DetectedFrame]:
         """Generate a stream of detected frames.
 
         Returns:
-            Generator[DetectedFrame, None, None]: A stream of detected frames.
+            Iterator[DetectedFrame, None, None]: A stream of detected frames.
         """
         raise NotImplementedError

OTVision/domain/frame.py

@@ -165,6 +165,18 @@ class TrackedFrame(DetectedFrame):
             discarded_tracks=discarded_tracks,
         )
 
+    def without_image(self) -> "TrackedFrame":
+        return TrackedFrame(
+            no=self.no,
+            occurrence=self.occurrence,
+            source=self.source,
+            output=self.output,
+            image=None,
+            detections=self.detections,
+            finished_tracks=self.finished_tracks,
+            discarded_tracks=self.discarded_tracks,
+        )
+
 
 @dataclass(frozen=True, kw_only=True)
 class FinishedFrame(TrackedFrame):

OTVision/domain/input_source_detect.py

@@ -1,12 +1,10 @@
 from abc import ABC, abstractmethod
-from typing import Generator
+from typing import Iterator
 
-from OTVision.abstraction.observer import Observable
-from OTVision.detect.detected_frame_buffer import FlushEvent
 from OTVision.domain.frame import Frame
 
 
-class InputSourceDetect(Observable[FlushEvent], ABC):
+class InputSourceDetect(ABC):
     """Interface for input sources that generate frames and notify about flush events.
 
     This class combines the Observable pattern for flush events with frame generation
@@ -16,7 +14,7 @@ class InputSourceDetect(Observable[FlushEvent], ABC):
     """
 
     @abstractmethod
-    def produce(self) -> Generator[Frame, None, None]:
+    def produce(self) -> Iterator[Frame]:
         """Generate a stream of frames from the input source.
 
         Implementations should yield Frame objects one at a time from the source,
@@ -24,7 +22,7 @@ class InputSourceDetect(Observable[FlushEvent], ABC):
         at appropriate points (e.g., end of video segments or buffer boundaries).
 
         Returns:
-            Generator[Frame, None, None]: A generator yielding Frame objects
+            Iterator [Frame]: A generator yielding Frame objects
                 sequentially from the input source.
         """
 

OTVision/domain/object_detection.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Generator
+from typing import Iterator
 
 from OTVision.application.config import DetectConfig
 from OTVision.domain.frame import DetectedFrame, Frame
@@ -25,16 +25,14 @@ class ObjectDetectorMetadata(ABC):
 class ObjectDetector(ObjectDetectorMetadata):
 
     @abstractmethod
-    def detect(
-        self, frames: Generator[Frame, None, None]
-    ) -> Generator[DetectedFrame, None, None]:
+    def detect(self, frames: Iterator[Frame]) -> Iterator[DetectedFrame]:
         """Runs object detection on a video.
 
         Args:
-            frames (Generator[Frame, None, None]): the source to read frames from.
+            frames (Iterator[Frame]): the source to read frames from.
 
         Returns:
-            Generator[DetectedFrame, None, None]: nested list of detections.
+            Iterator[DetectedFrame]: nested list of detections.
                 First level is frames, second level is detections within frame.
         """
         raise NotImplementedError

OTVision/domain/time.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from datetime import datetime, timezone
+from datetime import datetime
 
 
 class DatetimeProvider(ABC):
@@ -10,4 +10,4 @@ class DatetimeProvider(ABC):
 
 class CurrentDatetimeProvider(DatetimeProvider):
     def provide(self) -> datetime:
-        return datetime.now(tz=timezone.utc)
+        return datetime.now()

OTVision/domain/video_writer.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+
+from numpy import ndarray
+
+from OTVision.abstraction.pipes_and_filter import Filter
+from OTVision.application.event.new_video_start import NewVideoStartEvent
+from OTVision.detect.detected_frame_buffer import FlushEvent
+from OTVision.domain.frame import Frame
+
+
+class VideoWriter(Filter[Frame, Frame], ABC):
+    @abstractmethod
+    def write(self, image: ndarray) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def open(self, output: str, width: int, height: int, fps: float) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def close(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def notify_on_flush_event(self, event: FlushEvent) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def notify_on_new_video_start(self, event: NewVideoStartEvent) -> None:
+        raise NotImplementedError