OTVision 0.6.8__py3-none-any.whl → 0.6.10__py3-none-any.whl

OTVision/detect/otdet.py

@@ -1,3 +1,4 @@
+import re
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 from pathlib import Path
@@ -6,6 +7,14 @@ from typing import Self
 from OTVision import dataformat, version
 from OTVision.domain.detection import Detection
 from OTVision.domain.frame import DetectedFrame
+from OTVision.helpers.date import parse_datetime
+from OTVision.helpers.files import (
+    FULL_FILE_NAME_PATTERN,
+    HOSTNAME,
+    InproperFormattedFilename,
+)
+
+MISSING_START_DATE = datetime(1900, 1, 1)
 
 
 @dataclass
@@ -35,7 +44,7 @@ class OtdetBuilderError(Exception):
     pass
 
 
-class OtdetBuilder:
+class OtdetMetadataBuilder:
     @property
     def config(self) -> OtdetBuilderConfig:
         if self._config is None:
@@ -45,51 +54,14 @@ class OtdetBuilder:
     def __init__(self) -> None:
         self._config: OtdetBuilderConfig | None = None
 
-    def add_config(self, config: OtdetBuilderConfig) -> Self:
-        self._config = config
-        return self
-
-    def reset(self) -> Self:
-        self._config = None
-        return self
-
-    def build(self, detections: list[DetectedFrame]) -> dict:
-        number_of_frames = len(detections)
+    def build(self, number_of_frames: int) -> dict:
         result = {
-            dataformat.METADATA: self._build_metadata(number_of_frames),
-            dataformat.DATA: self._build_data(detections),
-        }
-        self.reset()
-        return result
-
-    def _build_metadata(self, number_of_frames: int) -> dict:
-        return {
             dataformat.OTDET_VERSION: version.otdet_version(),
             dataformat.VIDEO: self._build_video_config(number_of_frames),
             dataformat.DETECTION: self._build_detection_config(),
         }
-
-    def _build_data(self, frames: list[DetectedFrame]) -> dict:
-        data = {}
-        for frame in frames:
-            converted_detections = [
-                self.__convert_detection(detection) for detection in frame.detections
-            ]
-            data[str(frame.no)] = {
-                dataformat.DETECTIONS: converted_detections,
-                dataformat.OCCURRENCE: frame.occurrence.timestamp(),
-            }
-        return data
-
-    def __convert_detection(self, detection: Detection) -> dict:
-        return {
-            dataformat.CLASS: detection.label,
-            dataformat.CONFIDENCE: detection.conf,
-            dataformat.X: detection.x,
-            dataformat.Y: detection.y,
-            dataformat.W: detection.w,
-            dataformat.H: detection.h,
-        }
+        self.reset()
+        return result
 
     def _build_video_config(self, number_of_frames: int) -> dict:
         source = Path(self.config.source)
@@ -128,6 +100,69 @@ class OtdetBuilder:
             dataformat.DETECT_END: self.config.detect_end,
         }
 
+    def add_config(self, config: OtdetBuilderConfig) -> Self:
+        self._config = config
+        return self
+
+    def reset(self) -> Self:
+        self._config = None
+        return self
+
+
+class OtdetBuilder:
+    @property
+    def config(self) -> OtdetBuilderConfig:
+        if self._config is None:
+            raise OtdetBuilderError("Otdet builder config is not set")
+        return self._config
+
+    def __init__(self, metadata_builder: OtdetMetadataBuilder) -> None:
+        self._config: OtdetBuilderConfig | None = None
+        self._metadata_builder = metadata_builder
+
+    def add_config(self, config: OtdetBuilderConfig) -> Self:
+        self._config = config
+        self._metadata_builder.add_config(config)
+        return self
+
+    def reset(self) -> Self:
+        self._config = None
+        return self
+
+    def build(self, detections: list[DetectedFrame]) -> dict:
+        number_of_frames = len(detections)
+        result = {
+            dataformat.METADATA: self._build_metadata(number_of_frames),
+            dataformat.DATA: self._build_data(detections),
+        }
+        self.reset()
+        return result
+
+    def _build_metadata(self, number_of_frames: int) -> dict:
+        return self._metadata_builder.build(number_of_frames)
+
+    def _build_data(self, frames: list[DetectedFrame]) -> dict:
+        data = {}
+        for frame in frames:
+            converted_detections = [
+                self.__convert_detection(detection) for detection in frame.detections
+            ]
+            data[str(frame.no)] = {
+                dataformat.DETECTIONS: converted_detections,
+                dataformat.OCCURRENCE: frame.occurrence.timestamp(),
+            }
+        return data
+
+    def __convert_detection(self, detection: Detection) -> dict:
+        return {
+            dataformat.CLASS: detection.label,
+            dataformat.CONFIDENCE: detection.conf,
+            dataformat.X: detection.x,
+            dataformat.Y: detection.y,
+            dataformat.W: detection.w,
+            dataformat.H: detection.h,
+        }
+
 
 def serialize_video_length(video_length: timedelta) -> str:
     """Serialize a timedelta object to a video length string in 'H+:MM:SS' format.
@@ -180,3 +215,36 @@ def parse_video_length(video_length: str) -> timedelta:
             f"Could not parse video length '{video_length}'. "
             "Expected format 'HH:MM:SS'."
         ) from cause
+
+
+def extract_start_date_from_otdet(metadata: dict) -> datetime:
+    if dataformat.RECORDED_START_DATE in metadata[dataformat.VIDEO].keys():
+        recorded_start_date = metadata[dataformat.VIDEO][dataformat.RECORDED_START_DATE]
+        return parse_datetime(recorded_start_date)
+    return MISSING_START_DATE
+
+
+def extract_expected_duration_from_otdet(metadata: dict) -> timedelta:
+    if dataformat.EXPECTED_DURATION in metadata[dataformat.VIDEO].keys():
+        if expected_duration := metadata[dataformat.VIDEO][
+            dataformat.EXPECTED_DURATION
+        ]:
+            return timedelta(seconds=int(expected_duration))
+    return extract_otdet_video_length(metadata)
+
+
+def extract_otdet_video_length(metadata: dict) -> timedelta:
+    video_length = metadata[dataformat.VIDEO][dataformat.LENGTH]
+    return parse_video_length(video_length)
+
+
+def extract_hostname_from_otdet(metadata: dict) -> str:
+    video_name = Path(metadata[dataformat.VIDEO][dataformat.FILENAME]).name
+    match = re.search(
+        FULL_FILE_NAME_PATTERN,
+        video_name,
+    )
+    if match:
+        return match.group(HOSTNAME)
+
+    raise InproperFormattedFilename(f"Could not parse {video_name}.")

OTVision/detect/otdet_file_writer.py

@@ -1,12 +1,12 @@
 import logging
+from dataclasses import dataclass
 
+from OTVision.abstraction.observer import Observer, Subject
 from OTVision.application.detect.current_object_detector_metadata import (
     CurrentObjectDetectorMetadata,
 )
-from OTVision.application.detect.detection_file_save_path_provider import (
-    DetectionFileSavePathProvider,
-)
 from OTVision.application.get_current_config import GetCurrentConfig
+from OTVision.application.otvision_save_path_provider import OtvisionSavePathProvider
 from OTVision.detect.detected_frame_buffer import DetectedFrameBufferEvent
 from OTVision.detect.otdet import OtdetBuilder, OtdetBuilderConfig
 from OTVision.helpers.files import write_json
@@ -15,6 +15,14 @@ from OTVision.helpers.log import LOGGER_NAME
 log = logging.getLogger(LOGGER_NAME)
 
 
+@dataclass(frozen=True)
+class OtdetFileWrittenEvent:
+    """Event that is emitted when an OTDET file is written."""
+
+    otdet_builder_config: OtdetBuilderConfig
+    number_of_frames: int
+
+
 class OtdetFileWriter:
     """Handles writing object detection results to a file in OTDET format.
 
@@ -28,18 +36,20 @@ class OtdetFileWriter:
             settings.
         current_object_detector_metadata (CurrentObjectDetectorMetadata): Provides
             metadata about the current object detector.
-        save_path_provider (DetectionFileSavePathProvider): determines the save path for
+        save_path_provider (OtvisionSavePathProvider): determines the save path for
             the otdet file to be written.
 
     """
 
     def __init__(
         self,
+        subject: Subject[OtdetFileWrittenEvent],
         builder: OtdetBuilder,
         get_current_config: GetCurrentConfig,
         current_object_detector_metadata: CurrentObjectDetectorMetadata,
-        save_path_provider: DetectionFileSavePathProvider,
+        save_path_provider: OtvisionSavePathProvider,
     ):
+        self._subject = subject
         self._builder = builder
         self._get_current_config = get_current_config
         self._current_object_detector_metadata = current_object_detector_metadata
@@ -68,31 +78,32 @@ class OtdetFileWriter:
             actual_fps = actual_frames / source_metadata.duration.total_seconds()
 
         class_mapping = self._current_object_detector_metadata.get().classifications
-        otdet = self._builder.add_config(
-            OtdetBuilderConfig(
-                conf=detect_config.confidence,
-                iou=detect_config.iou,
-                source=source_metadata.output,
-                video_width=source_metadata.width,
-                video_height=source_metadata.height,
-                expected_duration=expected_duration,
-                actual_duration=source_metadata.duration,
-                recorded_fps=source_metadata.fps,
-                recorded_start_date=source_metadata.start_time,
-                actual_fps=actual_fps,
-                actual_frames=actual_frames,
-                detection_img_size=detect_config.img_size,
-                normalized=detect_config.normalized,
-                detection_model=detect_config.weights,
-                half_precision=detect_config.half_precision,
-                chunksize=1,
-                classifications=class_mapping,
-                detect_start=detect_config.detect_start,
-                detect_end=detect_config.detect_end,
-            )
-        ).build(event.frames)
+        builder_config = OtdetBuilderConfig(
+            conf=detect_config.confidence,
+            iou=detect_config.iou,
+            source=source_metadata.output,
+            video_width=source_metadata.width,
+            video_height=source_metadata.height,
+            expected_duration=expected_duration,
+            actual_duration=source_metadata.duration,
+            recorded_fps=source_metadata.fps,
+            recorded_start_date=source_metadata.start_time,
+            actual_fps=actual_fps,
+            actual_frames=actual_frames,
+            detection_img_size=detect_config.img_size,
+            normalized=detect_config.normalized,
+            detection_model=detect_config.weights,
+            half_precision=detect_config.half_precision,
+            chunksize=1,
+            classifications=class_mapping,
+            detect_start=detect_config.detect_start,
+            detect_end=detect_config.detect_end,
+        )
+        otdet = self._builder.add_config(builder_config).build(event.frames)
 
-        detections_file = self._save_path_provider.provide(source_metadata.output)
+        detections_file = self._save_path_provider.provide(
+            source_metadata.output, config.filetypes.detect
+        )
         detections_file.parent.mkdir(parents=True, exist_ok=True)
         write_json(
             otdet,
@@ -105,3 +116,15 @@ class OtdetFileWriter:
 
         finished_msg = "Finished detection"
         log.info(finished_msg)
+        self.__notify(num_frames=actual_frames, builder_config=builder_config)
+
+    def __notify(self, num_frames: int, builder_config: OtdetBuilderConfig) -> None:
+        self._subject.notify(
+            OtdetFileWrittenEvent(
+                number_of_frames=num_frames, otdet_builder_config=builder_config
+            )
+        )
+
+    def register_observer(self, observer: Observer[OtdetFileWrittenEvent]) -> None:
+        """Register an observer to receive notifications about otdet file writes.."""
+        self._subject.register(observer)

OTVision/detect/rtsp_input_source.py

@@ -1,7 +1,7 @@
 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 (
@@ -21,6 +21,7 @@ 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
@@ -33,6 +34,10 @@ 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
@@ -66,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:
@@ -126,7 +131,7 @@ 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
         try:
@@ -248,6 +253,13 @@ 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)

OTVision/detect/video_input_source.py

@@ -1,7 +1,7 @@
 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
@@ -9,12 +9,10 @@ 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
@@ -47,7 +45,7 @@ class VideoSource(InputSourceDetect):
             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.
     """
 
@@ -66,7 +64,7 @@ class VideoSource(InputSourceDetect):
         get_current_config: GetCurrentConfig,
         frame_rotator: AvVideoFrameRotator,
         timestamper_factory: TimestamperFactory,
-        save_path_provider: DetectionFileSavePathProvider,
+        save_path_provider: OtvisionSavePathProvider,
     ) -> None:
         self.subject_flush = subject_flush
         self.subject_new_video_start = subject_new_video_start
@@ -76,7 +74,7 @@ class VideoSource(InputSourceDetect):
         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,
@@ -93,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

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,14 +134,10 @@ 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]:
+    def detect(self, frames: Iterator[Frame]) -> Iterator[DetectedFrame]:
         for frame in tqdm(
             frames,
             desc="Detected frames",

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,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Generator
+from typing import Iterator
 
 from OTVision.domain.frame import Frame
 
@@ -14,7 +14,7 @@ class InputSourceDetect(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,
@@ -22,7 +22,7 @@ class InputSourceDetect(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/helpers/date.py

@@ -1,5 +1,7 @@
 from datetime import datetime, timezone
 
+from OTVision.dataformat import DATE_FORMAT
+
 
 def parse_date_string_to_utc_datime(date_string: str, date_format: str) -> datetime:
     """Parse a date string to a datetime object with UTC set as timezone.
@@ -24,3 +26,17 @@ def parse_timestamp_string_to_utc_datetime(timestamp: str | float) -> datetime:
         datetime: the datetime object with UTC as set timezone
     """
     return datetime.fromtimestamp(float(timestamp), timezone.utc)
+
+
+def parse_datetime(date: str | float) -> datetime:
+    """Parse a date string or timestamp to a datetime with UTC as timezone.
+
+    Args:
+        date (str | float): the date to parse
+
+    Returns:
+        datetime: the parsed datetime object with UTC set as timezone
+    """
+    if isinstance(date, str) and ("-" in date):
+        return parse_date_string_to_utc_datime(date, DATE_FORMAT)
+    return parse_timestamp_string_to_utc_datetime(date)

OTVision/plugin/ffmpeg_video_writer.py

@@ -3,7 +3,7 @@ from enum import IntEnum, StrEnum
 from pathlib import Path
 from subprocess import PIPE, Popen, TimeoutExpired
 from threading import Thread
-from typing import Callable, Generator
+from typing import Callable, Iterator
 
 import ffmpeg
 from numpy import ndarray
@@ -282,9 +282,7 @@ class FfmpegVideoWriter(VideoWriter):
         log.info(f"Writing new video file to '{save_file}'.")
         return process
 
-    def filter(
-        self, pipe: Generator[Frame, None, None]
-    ) -> Generator[Frame, None, None]:
+    def filter(self, pipe: Iterator[Frame]) -> Iterator[Frame]:
         for frame in pipe:
             if (image := frame.get(FrameKeys.data)) is not None:
                 self.write(image)

OTVision/track/builder.py

@@ -7,6 +7,7 @@ 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.tracking_run_id import StrIdGenerator
 from OTVision.application.track.update_current_track_config import (
     UpdateCurrentTrackConfig,
 )
@@ -20,11 +21,7 @@ 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.id_generator import 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

OTVision/track/id_generator.py

@@ -1,7 +1,5 @@
 import uuid
-from typing import Callable, Iterator
-
-StrIdGenerator = Callable[[], str]
+from typing import Iterator
 
 
 def tracking_run_uuid_generator() -> str:

OTVision/track/parser/chunk_parser_plugins.py

@@ -8,7 +8,6 @@ from OTVision.dataformat import (
     CLASS,
     CONFIDENCE,
     DATA,
-    DATE_FORMAT,
     DETECTIONS,
     OCCURRENCE,
     H,
@@ -18,10 +17,7 @@ from OTVision.dataformat import (
 )
 from OTVision.domain.detection import Detection
 from OTVision.domain.frame import DetectedFrame
-from OTVision.helpers.date import (
-    parse_date_string_to_utc_datime,
-    parse_timestamp_string_to_utc_datetime,
-)
+from OTVision.helpers.date import parse_datetime
 from OTVision.helpers.files import denormalize_bbox, read_json
 from OTVision.track.model.filebased.frame_chunk import ChunkParser, FrameChunk
 from OTVision.track.model.filebased.frame_group import FrameGroup
@@ -84,17 +80,3 @@ class DetectionParser:
             )
             detections.append(detected_item)
         return detections
-
-
-def parse_datetime(date: str | float) -> datetime:
-    """Parse a date string or timestamp to a datetime with UTC as timezone.
-
-    Args:
-        date (str | float): the date to parse
-
-    Returns:
-        datetime: the parsed datetime object with UTC set as timezone
-    """
-    if isinstance(date, str) and ("-" in date):
-        return parse_date_string_to_utc_datime(date, DATE_FORMAT)
-    return parse_timestamp_string_to_utc_datetime(date)