OTVision 0.6.17__py3-none-any.whl → 0.7.0__py3-none-any.whl

OTVision/abstraction/observer.py

@@ -1,7 +1,12 @@
-from typing import Callable, TypeVar
+import asyncio
+import logging
+from typing import Awaitable, Callable, TypeVar
+
+from OTVision.helpers.log import LOGGER_NAME
 
 VALUE = TypeVar("VALUE")
 type Observer[T] = Callable[[T], None]
+type AsyncObserver[T] = Callable[[T], Awaitable[None]]
 
 
 class Subject[T]:
@@ -41,3 +46,87 @@ class Observable[T]:
 
     def register(self, observer: Observer[T]) -> None:
         self._subject.register(observer)
+
+
+class AsyncSubject[T]:
+    """Generic async subject class to handle and notify async 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. Observers are executed as fire-and-forget background tasks for
+    non-blocking notifications.
+    """
+
+    def __init__(self) -> None:
+        self._observers: list[AsyncObserver[T]] = []
+        self._pending_tasks: set[asyncio.Task[None]] = set()
+
+    def register(self, observer: AsyncObserver[T]) -> None:
+        """Listen to changes of subject.
+
+        Args:
+            observer (AsyncObserver[T]): the observer to be registered. This must be an
+                async `Callable` that returns an `Awaitable`.
+        """
+        new_observers = self._observers.copy()
+        new_observers.append(observer)
+        self._observers = list(dict.fromkeys(new_observers))
+
+    async def notify(self, value: T) -> None:
+        """Notifies observers about the value asynchronously.
+
+        All observers are notified as fire-and-forget background tasks,
+        allowing the event loop to continue processing while observers execute.
+        Each observer runs independently; exceptions are caught and logged
+        without affecting other observers or blocking the caller.
+
+        Args:
+            value (T): value to notify the observer with.
+        """
+        log = logging.getLogger(LOGGER_NAME)
+
+        async def _safe_observer_call(observer: AsyncObserver[T], value: T) -> None:
+            """Wrapper to safely call an observer and log any exceptions."""
+            try:
+                await observer(value)
+            except Exception as e:
+                observer_name = (
+                    observer.__name__
+                    if hasattr(observer, "__name__")
+                    else repr(observer)
+                )
+                log.error(
+                    f"Exception in async observer {observer_name}: {e}",
+                    exc_info=True,
+                )
+
+        for observer in self._observers:
+            task = asyncio.create_task(_safe_observer_call(observer, value))
+            self._pending_tasks.add(task)
+            task.add_done_callback(self._pending_tasks.discard)
+
+    async def wait_for_all_observers(self) -> None:
+        """Wait for all pending observer tasks to complete.
+
+        This method can be used when you need to ensure all observers have
+        finished processing before proceeding. Useful in tests or when
+        synchronization is required.
+        """
+        if self._pending_tasks:
+            await asyncio.gather(*self._pending_tasks, return_exceptions=True)
+
+
+class AsyncObservable[T]:
+    def __init__(self, subject: AsyncSubject[T]) -> None:
+        self._subject = subject
+
+    def register(self, observer: AsyncObserver[T]) -> None:
+        self._subject.register(observer)
+
+    async def wait_for_all_observers(self) -> None:
+        """Wait for all pending observer tasks to complete.
+
+        This method delegates to the subject's wait_for_all_observers method.
+        """
+        await self._subject.wait_for_all_observers()

OTVision/abstraction/pipes_and_filter.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Iterator
+from typing import AsyncIterator
 
 
 class Filter[IN, OUT](ABC):
@@ -14,14 +14,14 @@ class Filter[IN, OUT](ABC):
     """
 
     @abstractmethod
-    def filter(self, pipe: Iterator[IN]) -> Iterator[OUT]:
+    def filter(self, pipe: AsyncIterator[IN]) -> AsyncIterator[OUT]:
         """Process elements from the input pipe and produce output elements.
 
         Args:
-            pipe (Iterator[IN]): Input stream of elements to be processed.
+            pipe (AsyncIterator[IN]): Input stream of elements to be processed.
 
         Returns:
-            Iterator[OUT]: Output stream of processed elements.
+            AsyncIterator[OUT]: Output stream of processed elements.
 
         """
 

OTVision/application/buffer.py

@@ -1,5 +1,5 @@
 from abc import abstractmethod
-from typing import Iterator
+from typing import AsyncIterator
 
 from OTVision.abstraction.pipes_and_filter import Filter
 
@@ -8,12 +8,12 @@ class Buffer[T, OBSERVING_TYPE](Filter[T, T]):
     def __init__(self) -> None:
         self._buffer: list[T] = []
 
-    def filter(self, pipe: Iterator[T]) -> Iterator[T]:
-        for element in pipe:
-            self.buffer(element)
+    async def filter(self, pipe: AsyncIterator[T]) -> AsyncIterator[T]:
+        async for element in pipe:
+            await self.buffer(element)
             yield element
 
-    def buffer(self, to_buffer: T) -> None:
+    async def buffer(self, to_buffer: T) -> None:
         self._buffer.append(to_buffer)
 
     def _get_buffered_elements(self) -> list[T]:
@@ -24,5 +24,5 @@ class Buffer[T, OBSERVING_TYPE](Filter[T, T]):
         self._buffer = list()
 
     @abstractmethod
-    def on_flush(self, event: OBSERVING_TYPE) -> None:
+    async def on_flush(self, event: OBSERVING_TYPE) -> None:
         raise NotImplementedError

OTVision/application/detect/current_object_detector.py

@@ -1,4 +1,4 @@
-from typing import Iterator
+from typing import AsyncIterator
 
 from OTVision.abstraction.pipes_and_filter import Filter
 from OTVision.application.get_current_config import GetCurrentConfig
@@ -33,5 +33,6 @@ class CurrentObjectDetector(Filter[Frame, DetectedFrame]):
         detect_config = self._get_current_config.get().detect
         return self._factory.create(detect_config)
 
-    def filter(self, pipe: Iterator[Frame]) -> Iterator[DetectedFrame]:
-        return self.get().detect(pipe)
+    async def filter(self, pipe: AsyncIterator[Frame]) -> AsyncIterator[DetectedFrame]:
+        async for detected_frame in self.get().detect(pipe):
+            yield detected_frame

OTVision/application/video/generate_video.py

@@ -10,6 +10,6 @@ class GenerateVideo:
         self._input_source = input_source
         self._video_writer = video_writer
 
-    def generate(self) -> None:
-        for frame in self._video_writer.filter(self._input_source.produce()):
+    async def generate(self) -> None:
+        async for frame in self._video_writer.filter(self._input_source.produce()):
             pass

OTVision/detect/builder.py

@@ -2,7 +2,7 @@ from abc import ABC, abstractmethod
 from argparse import ArgumentParser
 from functools import cached_property
 
-from OTVision.abstraction.observer import Subject
+from OTVision.abstraction.observer import AsyncSubject
 from OTVision.application.config import Config, DetectConfig
 from OTVision.application.config_parser import ConfigParser
 from OTVision.application.configure_logger import ConfigureLogger
@@ -127,7 +127,7 @@ class DetectBuilder(ABC):
     @cached_property
     def otdet_file_writer(self) -> OtdetFileWriter:
         return OtdetFileWriter(
-            subject=Subject[OtdetFileWrittenEvent](),
+            subject=AsyncSubject[OtdetFileWrittenEvent](),
             builder=self.otdet_builder,
             get_current_config=self.get_current_config,
             current_object_detector_metadata=self.current_object_detector_metadata,
@@ -147,7 +147,7 @@ class DetectBuilder(ABC):
 
     @cached_property
     def detected_frame_buffer(self) -> DetectedFrameBuffer:
-        return DetectedFrameBuffer(subject=Subject[DetectedFrameBufferEvent]())
+        return DetectedFrameBuffer(subject=AsyncSubject[DetectedFrameBufferEvent]())
 
     @cached_property
     def detected_frame_producer(self) -> DetectedFrameProducer:

OTVision/detect/detect.py

@@ -30,10 +30,10 @@ class OTVisionVideoDetect(DetectedFrameConsumer):
     def __init__(self, producer: DetectedFrameProducer) -> None:
         self._producer = producer
 
-    def start(self) -> None:
+    async def start(self) -> None:
         """Starts the detection of objects in multiple videos and/or images."""
-        self.consume()
+        await self.consume()
 
-    def consume(self) -> None:
-        for _ in self._producer.produce():
+    async def consume(self) -> None:
+        async for _ in self._producer.produce():
             pass

OTVision/detect/detected_frame_buffer.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 
-from OTVision.abstraction.observer import Observable, Subject
+from OTVision.abstraction.observer import AsyncObservable, AsyncSubject
 from OTVision.application.buffer import Buffer
 from OTVision.domain.frame import DetectedFrame
 
@@ -51,25 +51,25 @@ class DetectedFrameBufferEvent:
 
 
 class DetectedFrameBuffer(
-    Buffer[DetectedFrame, FlushEvent], Observable[DetectedFrameBufferEvent]
+    Buffer[DetectedFrame, FlushEvent], AsyncObservable[DetectedFrameBufferEvent]
 ):
-    def __init__(self, subject: Subject[DetectedFrameBufferEvent]) -> None:
+    def __init__(self, subject: AsyncSubject[DetectedFrameBufferEvent]) -> None:
         Buffer.__init__(self)
-        Observable.__init__(self, subject)
+        AsyncObservable.__init__(self, subject)
 
-    def on_flush(self, event: FlushEvent) -> None:
+    async def on_flush(self, event: FlushEvent) -> None:
         buffered_elements = self._get_buffered_elements()
-        self._notify_observers(buffered_elements, event)
+        await self._notify_observers(buffered_elements, event)
         self._reset_buffer()
 
-    def _notify_observers(
+    async def _notify_observers(
         self, elements: list[DetectedFrame], event: FlushEvent
     ) -> None:
-        self._subject.notify(
+        await self._subject.notify(
             DetectedFrameBufferEvent(
                 source_metadata=event.source_metadata, frames=elements
             )
         )
 
-    def buffer(self, to_buffer: DetectedFrame) -> None:
+    async def buffer(self, to_buffer: DetectedFrame) -> None:
         self._buffer.append(to_buffer.without_image())

OTVision/detect/detected_frame_producer.py

@@ -1,4 +1,4 @@
-from typing import Iterator
+from typing import AsyncIterator
 
 from OTVision.detect.detected_frame_producer_factory import DetectedFrameProducerFactory
 from OTVision.domain.detect_producer_consumer import DetectedFrameProducer
@@ -10,5 +10,5 @@ class SimpleDetectedFrameProducer(DetectedFrameProducer):
     def __init__(self, producer_factory: DetectedFrameProducerFactory) -> None:
         self._producer_factory = producer_factory
 
-    def produce(self) -> Iterator[DetectedFrame]:
+    def produce(self) -> AsyncIterator[DetectedFrame]:
         return self._producer_factory.create()

OTVision/detect/detected_frame_producer_factory.py

@@ -1,4 +1,4 @@
-from typing import Iterator
+from typing import AsyncIterator
 
 from OTVision.abstraction.pipes_and_filter import Filter
 from OTVision.application.get_current_config import GetCurrentConfig
@@ -21,17 +21,17 @@ class DetectedFrameProducerFactory:
         self._detected_frame_buffer = detected_frame_buffer
         self._get_current_config = get_current_config
 
-    def create(self) -> Iterator[DetectedFrame]:
+    def create(self) -> AsyncIterator[DetectedFrame]:
         if self._get_current_config.get().detect.write_video:
             return self.__create_with_video_writer()
         return self.__create_without_video_writer()
 
-    def __create_without_video_writer(self) -> Iterator[DetectedFrame]:
+    def __create_without_video_writer(self) -> AsyncIterator[DetectedFrame]:
         return self._detected_frame_buffer.filter(
             self._detection_filter.filter(self._input_source.produce())
         )
 
-    def __create_with_video_writer(self) -> Iterator[DetectedFrame]:
+    def __create_with_video_writer(self) -> AsyncIterator[DetectedFrame]:
         return self._detected_frame_buffer.filter(
             self._detection_filter.filter(
                 self._video_writer_filter.filter(self._input_source.produce())

OTVision/detect/file_based_detect_builder.py

@@ -1,6 +1,6 @@
 from functools import cached_property
 
-from OTVision.abstraction.observer import Subject
+from OTVision.abstraction.observer import AsyncSubject, Subject
 from OTVision.application.event.new_video_start import NewVideoStartEvent
 from OTVision.detect.builder import DetectBuilder
 from OTVision.detect.detected_frame_buffer import FlushEvent
@@ -19,7 +19,7 @@ class FileBasedDetectBuilder(DetectBuilder):
     @cached_property
     def input_source(self) -> VideoSource:
         return VideoSource(
-            subject_flush=Subject[FlushEvent](),
+            subject_flush=AsyncSubject[FlushEvent](),
             subject_new_video_start=Subject[NewVideoStartEvent](),
             get_current_config=self.get_current_config,
             frame_rotator=self.frame_rotator,

OTVision/detect/otdet_file_writer.py

@@ -2,7 +2,7 @@ import logging
 from dataclasses import dataclass
 from pathlib import Path
 
-from OTVision.abstraction.observer import Observer, Subject
+from OTVision.abstraction.observer import AsyncObserver, AsyncSubject
 from OTVision.application.detect.current_object_detector_metadata import (
     CurrentObjectDetectorMetadata,
 )
@@ -45,7 +45,7 @@ class OtdetFileWriter:
 
     def __init__(
         self,
-        subject: Subject[OtdetFileWrittenEvent],
+        subject: AsyncSubject[OtdetFileWrittenEvent],
         builder: OtdetBuilder,
         get_current_config: GetCurrentConfig,
         current_object_detector_metadata: CurrentObjectDetectorMetadata,
@@ -57,7 +57,7 @@ class OtdetFileWriter:
         self._current_object_detector_metadata = current_object_detector_metadata
         self._save_path_provider = save_path_provider
 
-    def write(self, event: DetectedFrameBufferEvent) -> None:
+    async def write(self, event: DetectedFrameBufferEvent) -> None:
         """Writes detection results to a file in OTDET format.
 
         Processes the detected frames and associated metadata, builds the OTDET
@@ -118,16 +118,16 @@ class OtdetFileWriter:
 
         finished_msg = "Finished detection"
         log.info(finished_msg)
-        self.__notify(
+        await self.__notify(
             num_frames=actual_frames,
             builder_config=builder_config,
             save_location=detections_file,
         )
 
-    def __notify(
+    async def __notify(
         self, num_frames: int, builder_config: OtdetBuilderConfig, save_location: Path
     ) -> None:
-        self._subject.notify(
+        await self._subject.notify(
             OtdetFileWrittenEvent(
                 number_of_frames=num_frames,
                 otdet_builder_config=builder_config,
@@ -135,6 +135,6 @@ class OtdetFileWriter:
             )
         )
 
-    def register_observer(self, observer: Observer[OtdetFileWrittenEvent]) -> None:
+    def register_observer(self, observer: AsyncObserver[OtdetFileWrittenEvent]) -> None:
         """Register an observer to receive notifications about otdet file writes.."""
         self._subject.register(observer)

OTVision/detect/rtsp_based_detect_builder.py

@@ -1,6 +1,6 @@
 from functools import cached_property
 
-from OTVision.abstraction.observer import Subject
+from OTVision.abstraction.observer import AsyncSubject, Subject
 from OTVision.application.config import StreamConfig
 from OTVision.application.event.new_video_start import NewVideoStartEvent
 from OTVision.detect.builder import DetectBuilder
@@ -33,7 +33,7 @@ class RtspBasedDetectBuilder(DetectBuilder):
     @cached_property
     def input_source(self) -> RtspInputSource:
         return RtspInputSource(
-            subject_flush=Subject[FlushEvent](),
+            subject_flush=AsyncSubject[FlushEvent](),
             subject_new_video_start=Subject[NewVideoStartEvent](),
             datetime_provider=self.datetime_provider,
             frame_counter=Counter(),

OTVision/detect/rtsp_input_source.py

@@ -1,7 +1,8 @@
+import asyncio
 import socket
 from datetime import datetime, timedelta
 from time import sleep
-from typing import Iterator
+from typing import AsyncIterator
 from urllib.parse import urlparse
 
 from cv2 import (
@@ -13,7 +14,7 @@ from cv2 import (
 )
 from numpy import ndarray
 
-from OTVision.abstraction.observer import Subject
+from OTVision.abstraction.observer import AsyncSubject, Subject
 from OTVision.application.config import (
     DATETIME_FORMAT,
     Config,
@@ -87,7 +88,7 @@ class RtspInputSource(InputSourceDetect):
 
     def __init__(
         self,
-        subject_flush: Subject[FlushEvent],
+        subject_flush: AsyncSubject[FlushEvent],
         subject_new_video_start: Subject[NewVideoStartEvent],
         datetime_provider: DatetimeProvider,
         frame_counter: Counter,
@@ -131,7 +132,7 @@ class RtspInputSource(InputSourceDetect):
         self._current_video_capture = self._init_video_capture(self._current_stream)
         return self._current_video_capture
 
-    def produce(self) -> Iterator[Frame]:
+    async def produce(self) -> AsyncIterator[Frame]:
         self._stream_start_time = self._datetime_provider.provide()
         self._current_video_start_time = self._stream_start_time
         try:
@@ -153,10 +154,10 @@ class RtspInputSource(InputSourceDetect):
                         occurrence=occurrence,
                     )
                     if self.flush_condition_met():
-                        self._notify_flush_observers()
+                        await self._notify_flush_observers()
                         self._outdated = True
                         self._frame_counter.reset()
-            self._notify_flush_observers()
+            await self._notify_flush_observers()
         except InvalidRtspUrlError as cause:
             logger().error(cause)
 
@@ -209,7 +210,7 @@ class RtspInputSource(InputSourceDetect):
     def flush_condition_met(self) -> bool:
         return self.current_frame_number % self.flush_buffer_size == 0
 
-    def _notify_flush_observers(self) -> None:
+    async def _notify_flush_observers(self) -> None:
         frame_width = self._get_width()
         frame_height = self._get_height()
         frames = (
@@ -219,7 +220,7 @@ class RtspInputSource(InputSourceDetect):
         )
         duration = timedelta(seconds=round(frames / self.fps))
         output = self.create_output()
-        self.subject_flush.notify(
+        await self.subject_flush.notify(
             FlushEvent.create(
                 source=self.rtsp_url,
                 output=output,
@@ -256,7 +257,9 @@ class RtspInputSource(InputSourceDetect):
     def notify_new_config(self, config: NewOtvisionConfigEvent) -> None:
         try:
             logger().debug("New OTVision config detected. Flushing buffers...")
-            self._notify_flush_observers()
+
+            # Create task to handle async flush notification
+            asyncio.create_task(self._notify_flush_observers())
         except NoConfigurationFoundError:
             logger().info("No configuration found for RTSP stream. Skipping flushing.")
 

OTVision/detect/video_input_source.py

@@ -1,13 +1,13 @@
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Iterable, Iterator
+from typing import AsyncIterator, Iterable
 
 import av
 from av.container.input import InputContainer
-from tqdm import tqdm
+from tqdm.asyncio import tqdm
 
-from OTVision.abstraction.observer import Subject
+from OTVision.abstraction.observer import AsyncSubject, Subject
 from OTVision.application.config import DATETIME_FORMAT, Config
 from OTVision.application.detect.timestamper import Timestamper
 from OTVision.application.event.new_video_start import NewVideoStartEvent
@@ -59,7 +59,7 @@ class VideoSource(InputSourceDetect):
 
     def __init__(
         self,
-        subject_flush: Subject[FlushEvent],
+        subject_flush: AsyncSubject[FlushEvent],
         subject_new_video_start: Subject[NewVideoStartEvent],
         get_current_config: GetCurrentConfig,
         frame_rotator: AvVideoFrameRotator,
@@ -74,7 +74,7 @@ class VideoSource(InputSourceDetect):
         self._save_path_provider = save_path_provider
         self.__should_flush = False
 
-    def produce(self) -> Iterator[Frame]:
+    async def produce(self) -> AsyncIterator[Frame]:
         """Generate frames from video files that meet detection requirements.
 
         Yields frames from valid video files while managing rotation, timestamping,
@@ -84,11 +84,13 @@ class VideoSource(InputSourceDetect):
             Frame: Processed video frames ready for detection.
         """
 
-        video_files = self._collect_files_to_detect()
+        video_files = await self._collect_files_to_detect()
 
         log.info("Start detection of video files")
 
-        for video_file in tqdm(video_files, desc="Detected video files", unit=" files"):
+        async for video_file in tqdm(
+            video_files, desc="Detected video files", unit=" files"
+        ):
             detections_file = self._save_path_provider.provide(
                 str(video_file), self._current_config.filetypes.detect
             )
@@ -135,11 +137,15 @@ class VideoSource(InputSourceDetect):
                                 }
                             )
                         counter += 1
-                self.notify_flush_event_observers(video_file, video_fps)
+                await self.notify_flush_event_observers(video_file, video_fps)
                 self._on_video_finished(video_file)
             except Exception as e:
                 log.error(f"Error processing {video_file}", exc_info=e)
 
+        # Wait for all flush event observers to complete their work
+        # (e.g., file writing) before this method returns
+        await self.subject_flush.wait_for_all_observers()
+
     def _on_video_finished(self, video_file: Path) -> None:
         """Hook for handling video processing completion."""
         pass
@@ -154,7 +160,7 @@ class VideoSource(InputSourceDetect):
             )
             return {}
 
-    def _collect_files_to_detect(self) -> Iterable[Path]:
+    async def _collect_files_to_detect(self) -> Iterable[Path]:
         filetypes = self._current_config.filetypes.video_filetypes.to_list()
         video_files = get_files(
             paths=self._current_config.detect.paths, filetypes=filetypes
@@ -190,7 +196,7 @@ class VideoSource(InputSourceDetect):
             return False
         return True
 
-    def notify_flush_event_observers(
+    async def notify_flush_event_observers(
         self, current_video_file: Path, video_fps: float
     ) -> None:
         if expected_duration := self._current_config.detect.expected_duration:
@@ -203,7 +209,7 @@ class VideoSource(InputSourceDetect):
             current_video_file, start_time=self._start_time
         )
 
-        self.subject_flush.notify(
+        await self.subject_flush.notify(
             FlushEvent.create(
                 source=str(current_video_file),
                 output=str(current_video_file),

OTVision/detect/yolo.py

@@ -22,10 +22,10 @@ OTVision module to detect objects using yolov5
 import logging
 from pathlib import Path
 from time import perf_counter
-from typing import Iterator
+from typing import AsyncIterator
 
 import torch
-from tqdm import tqdm
+from tqdm.asyncio import tqdm
 from ultralytics import YOLO
 from ultralytics.engine.results import Boxes
 
@@ -134,11 +134,14 @@ class YoloDetector(ObjectDetector, Filter[Frame, DetectedFrame]):
         self._detection_converter = detection_converter
         self._detected_frame_factory = detected_frame_factory
 
-    def filter(self, pipe: Iterator[Frame]) -> Iterator[DetectedFrame]:
-        return self.detect(pipe)
+    async def filter(self, pipe: AsyncIterator[Frame]) -> AsyncIterator[DetectedFrame]:
+        async for detected_frame in self.detect(pipe):
+            yield detected_frame
 
-    def detect(self, frames: Iterator[Frame]) -> Iterator[DetectedFrame]:
-        for frame in tqdm(
+    async def detect(
+        self, frames: AsyncIterator[Frame]
+    ) -> AsyncIterator[DetectedFrame]:
+        async for frame in tqdm(
             frames,
             desc="Detected frames",
             unit=" frames",

OTVision/domain/detect_producer_consumer.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Iterator
+from typing import AsyncIterator
 
 from OTVision.domain.frame import DetectedFrame
 
@@ -8,7 +8,7 @@ class DetectedFrameConsumer(ABC):
     """Interface for components that consume detected frames."""
 
     @abstractmethod
-    def consume(self) -> None:
+    async def consume(self) -> None:
         """Consume detected frames."""
         raise NotImplementedError
 
@@ -21,10 +21,10 @@ class DetectedFrameProducer(ABC):
     """
 
     @abstractmethod
-    def produce(self) -> Iterator[DetectedFrame]:
+    def produce(self) -> AsyncIterator[DetectedFrame]:
         """Generate a stream of detected frames.
 
         Returns:
-            Iterator[DetectedFrame, None, None]: A stream of detected frames.
+            AsyncIterator[DetectedFrame ]: A stream of detected frames.
         """
-        raise NotImplementedError
+        ...

OTVision/domain/input_source_detect.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Iterator
+from typing import AsyncIterator
 
 from OTVision.domain.frame import Frame
 
@@ -14,7 +14,7 @@ class InputSourceDetect(ABC):
     """
 
     @abstractmethod
-    def produce(self) -> Iterator[Frame]:
+    def produce(self) -> AsyncIterator[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:
-            Iterator [Frame]: A generator yielding Frame objects
+            AsyncIterator[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 Iterator
+from typing import AsyncIterator
 
 from OTVision.application.config import DetectConfig
 from OTVision.domain.frame import DetectedFrame, Frame
@@ -25,17 +25,17 @@ class ObjectDetectorMetadata(ABC):
 class ObjectDetector(ObjectDetectorMetadata):
 
     @abstractmethod
-    def detect(self, frames: Iterator[Frame]) -> Iterator[DetectedFrame]:
+    def detect(self, frames: AsyncIterator[Frame]) -> AsyncIterator[DetectedFrame]:
         """Runs object detection on a video.
 
         Args:
-            frames (Iterator[Frame]): the source to read frames from.
+            frames (AsyncIterator[Frame]): the source to read frames from.
 
         Returns:
-            Iterator[DetectedFrame]: nested list of detections.
+            AsyncIterator[DetectedFrame]: nested list of detections.
                 First level is frames, second level is detections within frame.
         """
-        raise NotImplementedError
+        ...
 
     @abstractmethod
     def preload(self) -> None:

OTVision/domain/video_writer.py

@@ -22,7 +22,7 @@ class VideoWriter(Filter[Frame, Frame], ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def notify_on_flush_event(self, event: FlushEvent) -> None:
+    async def notify_on_flush_event(self, event: FlushEvent) -> None:
         raise NotImplementedError
 
     @abstractmethod

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, Iterator
+from typing import AsyncIterator, Callable
 
 import ffmpeg
 from numpy import ndarray
@@ -242,7 +242,7 @@ class FfmpegVideoWriter(VideoWriter):
 
         self.__current_video_metadata = None
 
-    def notify_on_flush_event(self, event: FlushEvent) -> None:
+    async def notify_on_flush_event(self, event: FlushEvent) -> None:
         self.close()
 
     def notify_on_new_video_start(self, event: NewVideoStartEvent) -> None:
@@ -282,8 +282,8 @@ class FfmpegVideoWriter(VideoWriter):
         log.info(f"Writing new video file to '{save_file}'.")
         return process
 
-    def filter(self, pipe: Iterator[Frame]) -> Iterator[Frame]:
-        for frame in pipe:
+    async def filter(self, pipe: AsyncIterator[Frame]) -> AsyncIterator[Frame]:
+        async for frame in pipe:
             if (image := frame.get(FrameKeys.data)) is not None:
                 self.write(image)
             yield frame

OTVision/track/model/track_exporter.py

@@ -1,7 +1,7 @@
 import logging
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Generic, Iterator, TypeVar
+from typing import AsyncIterator, Generic, TypeVar
 
 from tqdm import tqdm
 
@@ -48,10 +48,10 @@ class FinishedTracksExporter(ABC, Generic[F]):
     def get_frame_group_id(self, container: F) -> int:
         pass
 
-    def export(
-        self, tracking_run_id: str, stream: Iterator[F], overwrite: bool
+    async def export(
+        self, tracking_run_id: str, stream: AsyncIterator[F], overwrite: bool
     ) -> None:
-        for container in stream:
+        async for container in stream:
             self.export_frames(container, tracking_run_id, overwrite)
 
     def export_frames(

OTVision/track/model/tracking_interfaces.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Generic, Iterator, TypeVar
+from typing import AsyncIterator, Generic, Iterator, TypeVar
 
 from OTVision.domain.detection import TrackId
 from OTVision.domain.frame import (
@@ -22,22 +22,22 @@ class Tracker(ABC):
     track_frame for processing a single frame.
     """
 
-    def track(
-        self, frames: Iterator[DetectedFrame], id_generator: IdGenerator
-    ) -> Iterator[TrackedFrame]:
+    async def track(
+        self, frames: AsyncIterator[DetectedFrame], id_generator: IdGenerator
+    ) -> AsyncIterator[TrackedFrame]:
         """Process the given stream of Frames,
         yielding TrackedFrames one by one as a lazy stream of TrackedFrames.
 
         Args:
-            frames (Iterator[DetectedFrame]): (lazy) stream of Frames
+            frames (AsyncIterator[DetectedFrame]): (lazy) stream of Frames
                 with untracked Detections.
             id_generator (IdGenerator): provider of new (unique) track ids.
 
         Yields:
-            Iterator[TrackedFrame]: (lazy) stream of TrackedFrames with
+            AsyncIterator[TrackedFrame]: (lazy) stream of TrackedFrames with
                 TrackedDetections
         """
-        for frame in frames:
+        async for frame in frames:
             yield self.track_frame(frame, id_generator)
 
     @abstractmethod
@@ -182,10 +182,10 @@ class UnfinishedTracksBuffer(ABC, Generic[C, F]):
         """
         pass
 
-    def track_and_finish(self, containers: Iterator[C]) -> Iterator[F]:
+    async def track_and_finish(self, containers: AsyncIterator[C]) -> AsyncIterator[F]:
         # TODO template method to obtain containers?
 
-        for container in containers:
+        async for container in containers:
 
             # if track is observed in current iteration, update its last observed frame
             new_last_track_frames = self._get_last_track_frames(container)
@@ -215,7 +215,8 @@ class UnfinishedTracksBuffer(ABC, Generic[C, F]):
             ]
 
             finished_containers: list[F] = self._finish_containers(ready_containers)
-            yield from finished_containers
+            for finished_container in finished_containers:
+                yield finished_container
 
         # finish remaining containers with pending tracks
         remaining_containers = [c for c, _ in self._unfinished_containers]
@@ -223,7 +224,8 @@ class UnfinishedTracksBuffer(ABC, Generic[C, F]):
 
         finished_containers = self._finish_containers(remaining_containers)
         self._merged_last_track_frame = dict()
-        yield from finished_containers
+        for finished_container in finished_containers:
+            yield finished_container
 
     def _finish_containers(self, containers: list[C]) -> list[F]:
         if len(containers) == 0:
@@ -269,11 +271,12 @@ class UnfinishedFramesBuffer(UnfinishedTracksBuffer[TrackedFrame, FinishedFrame]
         super().__init__(keep_discarded)
         self._tracker = tracker
 
-    def track(
-        self, frames: Iterator[DetectedFrame], id_generator: IdGenerator
-    ) -> Iterator[FinishedFrame]:
+    async def track(
+        self, frames: AsyncIterator[DetectedFrame], id_generator: IdGenerator
+    ) -> AsyncIterator[FinishedFrame]:
         tracked_frame_stream = self._tracker.track(frames, id_generator)
-        return self.track_and_finish(tracked_frame_stream)
+        async for finished_frame in self.track_and_finish(tracked_frame_stream):
+            yield finished_frame
 
     def _get_last_track_frames(self, container: TrackedFrame) -> dict[TrackId, int]:
         return {o: container.no for o in container.observed_tracks}

OTVision/track/stream_ottrk_file_writer.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from OTVision.abstraction.observer import Observer, Subject
+from OTVision.abstraction.observer import AsyncObserver, AsyncSubject
 from OTVision.application.buffer import Buffer
 from OTVision.application.config import Config, TrackConfig
 from OTVision.application.configure_logger import logger
@@ -45,7 +45,7 @@ class StreamOttrkFileWriter(Buffer[TrackedFrame, OtdetFileWrittenEvent]):
 
     def __init__(
         self,
-        subject: Subject[OttrkFileWrittenEvent],
+        subject: AsyncSubject[OttrkFileWrittenEvent],
         builder: OttrkBuilder,
         get_current_config: GetCurrentConfig,
         get_current_tracking_run_id: GetCurrentTrackingRunId,
@@ -62,7 +62,7 @@ class StreamOttrkFileWriter(Buffer[TrackedFrame, OtdetFileWrittenEvent]):
         self._ottrk_unfinished_tracks: set[TrackId] = set()
         self._current_output_file: Path | None = None
 
-    def on_flush(self, event: OtdetFileWrittenEvent) -> None:
+    async def on_flush(self, event: OtdetFileWrittenEvent) -> None:
         tracked_frames = self._get_buffered_elements()
         if not tracked_frames:
             return
@@ -100,7 +100,7 @@ class StreamOttrkFileWriter(Buffer[TrackedFrame, OtdetFileWrittenEvent]):
     def reset(self) -> None:
         self._reset_buffer()
 
-    def buffer(self, to_buffer: TrackedFrame) -> None:
+    async def buffer(self, to_buffer: TrackedFrame) -> None:
         self._buffer.append(to_buffer.without_image())
 
         if self._in_writing_state:
@@ -113,11 +113,11 @@ class StreamOttrkFileWriter(Buffer[TrackedFrame, OtdetFileWrittenEvent]):
             )
             logger().warning(f"Unfinished tracks: {self._ottrk_unfinished_tracks}")
             if self.build_condition_fulfilled:
-                self._create_ottrk()
+                await self._create_ottrk()
 
-    def _create_ottrk(self) -> None:
+    async def _create_ottrk(self) -> None:
         ottrk_data = self._builder.build()
-        self.write(ottrk_data)
+        await self.write(ottrk_data)
         self.full_reset()
 
     def full_reset(self) -> None:
@@ -126,7 +126,7 @@ class StreamOttrkFileWriter(Buffer[TrackedFrame, OtdetFileWrittenEvent]):
         self._ottrk_unfinished_tracks = set()
         self._current_output_file = None
 
-    def write(self, ottrk: dict) -> None:
+    async def write(self, ottrk: dict) -> None:
         current_output_file = self.current_output_file
         write_json(
             dict_to_write=ottrk,
@@ -134,13 +134,15 @@ class StreamOttrkFileWriter(Buffer[TrackedFrame, OtdetFileWrittenEvent]):
             filetype=self.config.filetypes.track,
             overwrite=True,
         )
-        self._notify_ottrk_file_written(save_location=current_output_file)
+        await self._notify_ottrk_file_written(save_location=current_output_file)
 
-    def force_flush(self, _: Any) -> None:
-        self._create_ottrk()
+    async def force_flush(self, _: Any) -> None:
+        await self._create_ottrk()
 
-    def register_observers(self, observer: Observer[OttrkFileWrittenEvent]) -> None:
+    def register_observers(
+        self, observer: AsyncObserver[OttrkFileWrittenEvent]
+    ) -> None:
         self._subject.register(observer)
 
-    def _notify_ottrk_file_written(self, save_location: Path) -> None:
-        self._subject.notify(OttrkFileWrittenEvent(save_location=save_location))
+    async def _notify_ottrk_file_written(self, save_location: Path) -> None:
+        await self._subject.notify(OttrkFileWrittenEvent(save_location=save_location))

OTVision/track/track.py

@@ -1,6 +1,6 @@
 import logging
 
-from tqdm import tqdm
+from tqdm.asyncio import tqdm
 
 from OTVision.application.config import Config
 from OTVision.application.get_current_config import GetCurrentConfig
@@ -32,7 +32,7 @@ class OtvisionTrack:
         self._buffer = unfinished_chunks_buffer
         self._tracking_run_id_generator = tracking_run_id_generator
 
-    def start(self) -> None:
+    async def start(self) -> None:
         check_types(
             self.config.track.sigma_l,
             self.config.track.sigma_h,
@@ -61,6 +61,6 @@ class OtvisionTrack:
         finished_chunk_progress = tqdm(
             finished_chunk_stream, desc="export FrameChunk", total=len(detections_files)
         )
-        self._track_exporter.export(
-            tracking_run_id, iter(finished_chunk_progress), self.config.track.overwrite
+        await self._track_exporter.export(
+            tracking_run_id, finished_chunk_progress, self.config.track.overwrite
         )

OTVision/track/tracker/filebased_tracking.py

@@ -1,9 +1,9 @@
 import logging
 from pathlib import Path
-from typing import Callable, Iterator
+from typing import AsyncIterator, Callable
 
 from more_itertools import peekable
-from tqdm import tqdm
+from tqdm.asyncio import tqdm
 
 from OTVision.application.config import DEFAULT_FILETYPE, OVERWRITE, TRACK
 from OTVision.config import CONFIG
@@ -40,7 +40,7 @@ class ChunkBasedTracker(Tracker):
     ) -> TrackedFrame:
         return self._tracker.track_frame(frames, id_generator)
 
-    def track_chunk(
+    async def track_chunk(
         self,
         chunk: FrameChunk,
         is_last_chunk: bool,
@@ -50,16 +50,16 @@ class ChunkBasedTracker(Tracker):
             chunk.frames, desc="track Frame", total=len(chunk.frames), leave=False
         )
 
-        tracked_frames = self.track(iter(frames_progress), id_generator)
+        tracked_frames = self.track(frames_progress, id_generator)
         return TrackedChunk(
             file=chunk.file,
-            frames=list(tracked_frames),
+            frames=[frame async for frame in tracked_frames],
             metadata=chunk.metadata,
             is_last_chunk=is_last_chunk,
             frame_group_id=chunk.frame_group_id,
         )
 
-    def track_file(
+    async def track_file(
         self,
         file: Path,
         frame_group: FrameGroup,
@@ -68,7 +68,7 @@ class ChunkBasedTracker(Tracker):
         frame_offset: int = 0,
     ) -> TrackedChunk:
         chunk = self._chunk_parser.parse(file, frame_group, frame_offset)
-        return self.track_chunk(chunk, is_last_file, id_generator)
+        return await self.track_chunk(chunk, is_last_file, id_generator)
 
 
 IdGeneratorFactory = Callable[[FrameGroup], IdGenerator]
@@ -91,10 +91,12 @@ class GroupedFilesTracker(ChunkBasedTracker):
         self._overwrite = overwrite
         self._file_type = file_type
 
-    def track_group(self, group: FrameGroup) -> Iterator[TrackedChunk]:
+    async def track_group(self, group: FrameGroup) -> AsyncIterator[TrackedChunk]:
         if self.check_skip_due_to_existing_output_files(group):
             log.warning(f"Skip FrameGroup {group.id}")
-            yield from []  # TODO how to create empty generator stream?
+            empty: list[TrackedChunk] = []
+            for item in empty:
+                yield item
 
         frame_offset = 0  # frame no starts a 0 for each frame group
         id_generator = self._id_generator_of(group)  # new id generator per group
@@ -113,17 +115,20 @@ class GroupedFilesTracker(ChunkBasedTracker):
             chunk = self._chunk_parser.parse(file, group, frame_offset)
             frame_offset = chunk.frames[-1].no + 1  # assuming frames are sorted by no
 
-            tracked_chunk = self.track_chunk(chunk, is_last, id_generator)
+            tracked_chunk = await self.track_chunk(chunk, is_last, id_generator)
             yield tracked_chunk
 
-    def group_and_track_files(self, files: list[Path]) -> Iterator[TrackedChunk]:
+    async def group_and_track_files(
+        self, files: list[Path]
+    ) -> AsyncIterator[TrackedChunk]:
         processed = self._group_parser.process_all(files)
 
         processed_progress = tqdm(
             processed, desc="track FrameGroup", total=len(processed), leave=False
         )
         for group in processed_progress:
-            yield from self.track_group(group)
+            async for tracked_chunk in self.track_group(group):
+                yield tracked_chunk
 
     def check_skip_due_to_existing_output_files(self, group: FrameGroup) -> bool:
         if not self._overwrite and group.check_any_output_file_exists(self._file_type):
@@ -151,18 +156,20 @@ class UnfinishedChunksBuffer(UnfinishedTracksBuffer[TrackedChunk, FinishedChunk]
         super().__init__(keep_discarded)
         self.tracker = tracker
 
-    def group_and_track(self, files: list[Path]) -> Iterator[FinishedChunk]:
+    async def group_and_track(self, files: list[Path]) -> AsyncIterator[FinishedChunk]:
         processed = self.tracker._group_parser.process_all(files)
 
         processed_progress = tqdm(
             processed, desc="track FrameGroup", total=len(processed), leave=False
         )
         for group in processed_progress:
-            yield from self.track_group(group)
+            async for finished_chunk in self.track_group(group):
+                yield finished_chunk
 
-    def track_group(self, group: FrameGroup) -> Iterator[FinishedChunk]:
+    async def track_group(self, group: FrameGroup) -> AsyncIterator[FinishedChunk]:
         tracked_chunk_stream = self.tracker.track_group(group)
-        return self.track_and_finish(tracked_chunk_stream)
+        async for finished_chunk in self.track_and_finish(tracked_chunk_stream):
+            yield finished_chunk
 
     def _get_last_track_frames(self, container: TrackedChunk) -> dict[TrackId, FrameNo]:
         return container.last_track_frame

OTVision/version.py

@@ -1,4 +1,4 @@
-__version__ = "v0.6.17"
+__version__ = "v0.7.0"
 
 
 def otdet_version() -> str:

{otvision-0.6.17.dist-info → otvision-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OTVision
-Version: 0.6.17
+Version: 0.7.0
 Summary: OTVision is a core module of the OpenTrafficCam framework to perform object detection and tracking.
 Project-URL: Homepage, https://opentrafficcam.org/
 Project-URL: Documentation, https://opentrafficcam.org/overview/

{otvision-0.6.17.dist-info → otvision-0.7.0.dist-info}/RECORD

@@ -1,13 +1,13 @@
 OTVision/__init__.py,sha256=CLnfgTlVHM4_nzDacvy06Z_Crc3hU6usd0mUyEvBf24,781
 OTVision/config.py,sha256=D4NIio27JG9hZk7yHI6kNKiMxKeKa_MGfrKNDdEH370,5389
 OTVision/dataformat.py,sha256=BHF7qHzyNb80hI1EKfwcdJ9bgG_X4bp_hCXzdg7_MSA,1941
-OTVision/version.py,sha256=Ay8_qdo-wXxrm9e-GbKoT9-hDKLEXS2tzcLHFDgMULk,176
+OTVision/version.py,sha256=5PMTXzldADFnUA2b0NQMVkS5UT5BpP9hvh9U611A_Uk,175
 OTVision/abstraction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/abstraction/defaults.py,sha256=ftETDe25gmr563RPSbG6flcEiNiHnRb0iXK1Zj_zdNg,442
-OTVision/abstraction/observer.py,sha256=ZFGxUUjI3wUpf5ogXg2yDe-QjCcXre6SxH5zOogOx2U,1350
-OTVision/abstraction/pipes_and_filter.py,sha256=pzK80ZV03_n6V-bZ9_Etu-aLqZACHgBbhTBZRnhz71M,887
+OTVision/abstraction/observer.py,sha256=jCNtp1_b9VzEDtdjbZQmOX6yXuQQxzYB-NvTgwzjRNk,4751
+OTVision/abstraction/pipes_and_filter.py,sha256=aU28pDf4zJBOcghinPhywBQidhPf0lgpyqaAG_dQ9eo,912
 OTVision/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/application/buffer.py,sha256=qJQlNBQtriN2pqC1kfpOKk222_YHG0HNRzwC2DKBJQ0,743
+OTVision/application/buffer.py,sha256=LVRimNWZupcvncZ-UecrnAUtTsaEhVsBPUPjMeZQCKQ,788
 OTVision/application/config.py,sha256=tTFVo2iJt3zCJ_p06FCeQOJ_NbuwmPd60ttrh-6fANI,13670
 OTVision/application/config_parser.py,sha256=EVFEnrNs5xd1bWa023s_PPoxAxpLEaWbFoGjsS8PM8U,11920
 OTVision/application/configure_logger.py,sha256=1TzHB-zm7vGTPtUp7m28ne4WxOyiUYeChLZU-ZPyOVQ,623
@@ -17,7 +17,7 @@ OTVision/application/get_current_config.py,sha256=iqtY10FRpn2FgLsasejjlyPFP3NrQJ
 OTVision/application/otvision_save_path_provider.py,sha256=lUzjQ92Qjvxf9sbaZX591FuEaUW5gFAq4GpgmN1k_tM,2179
 OTVision/application/update_current_config.py,sha256=iW1rpCClTHn8tnmVSpLVxdEB0nh1O_JCyxEqog0r0NU,333
 OTVision/application/detect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/application/detect/current_object_detector.py,sha256=P8BqThQGVBUMDzJ3WdNrOCEkB9h-wXqannZ9g_PYZXM,1302
+OTVision/application/detect/current_object_detector.py,sha256=jow7-h0D6FziHduBiihzcML4rt3bjxk7SOmPGwLyD6Y,1378
 OTVision/application/detect/current_object_detector_metadata.py,sha256=xai0UBEzxr-rxXCc8mTmNDECds7mdsw2sem5HZxvQ4Q,1017
 OTVision/application/detect/detected_frame_factory.py,sha256=sW_l0xaPz44_lPEmCPKz4Xg1Mv4ZGKN9CyBCG_iN8dQ,1007
 OTVision/application/detect/factory.py,sha256=UCnLtgpWdNqwwjW0v2yzKF9Gacx6gewjTyy43wXs2Jg,938
@@ -34,38 +34,38 @@ OTVision/application/track/tracking_run_id.py,sha256=9_RgQSHR-IMgAM4LawtJWxNcVyw
 OTVision/application/track/update_current_track_config.py,sha256=pCFNuGl6rqpsUUGm2i1kjLSuuITVXv2R79Xf81n45as,1667
 OTVision/application/track/update_track_config_with_cli_args.py,sha256=5MDr2ih4xHzZ0kI6TSQ2C4mcWsPXW2PB80kA22-M_5I,2273
 OTVision/application/video/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/application/video/generate_video.py,sha256=4zazQoRdwefF_R-sUcnbP-23NTWgn_aYdQJrhtJ5Ni4,513
+OTVision/application/video/generate_video.py,sha256=uv7cJPhWLZV53plkP4rCr6VqsGBQixSQ9NHViq3SiQM,525
 OTVision/convert/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/convert/convert.py,sha256=UUfzpbtMlxlJgKE6XeT5nyNqK26-K02bQDhq3o7KrXE,11050
 OTVision/detect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/detect/builder.py,sha256=uHiAfPjQLtedkSdBe7J3mxjcefr3OIItUNq-TKCeWX8,8047
+OTVision/detect/builder.py,sha256=oVVGj9iPO8IqZOB98E3759WdJS2rtn34Ye64Krvu_tE,8062
 OTVision/detect/cli.py,sha256=3yf0G_B9cVm2CAz7AFzG10Cctv4ogMOxRHWEg8SZHss,7562
-OTVision/detect/detect.py,sha256=YaVS-DJXdEmh-OzwE31UPNl2uk7mcFyO_CKKTgMeiuM,1328
-OTVision/detect/detected_frame_buffer.py,sha256=zZZZBcpNcKApPMX4xoLeq7xszDCvxA3eOF_umrwo0N4,1931
-OTVision/detect/detected_frame_producer.py,sha256=thMg5nZNiArUpQI7ctGTQy8A2jxsZs5MJFJpkBPAzNk,530
-OTVision/detect/detected_frame_producer_factory.py,sha256=HiFAHWTvilwyibDrzMv9skwu901d9QW3zvjc3q4Pp80,1576
-OTVision/detect/file_based_detect_builder.py,sha256=G72GFhF2BCXO3fwfC9pXkbJPhRFfU6RphLRQs3ugCUQ,2315
+OTVision/detect/detect.py,sha256=cBMw-sFCyXfd6vzl3zEa-5kVHZ5uW1FpOmtf1GZrw8o,1352
+OTVision/detect/detected_frame_buffer.py,sha256=D_W4ZNyQxWd8ncm7tTvDmQMmRJLCW_EBuKBYfIcAz1k,1986
+OTVision/detect/detected_frame_producer.py,sha256=RkAiw3RRUJmk05XQWR3Z-gEYkz7tbwhh8hEnRJpeSHI,540
+OTVision/detect/detected_frame_producer_factory.py,sha256=eS9ekU2mI8MGjGq_UT-ejxuZDBp6-tauxLAd5i0lSBM,1596
+OTVision/detect/file_based_detect_builder.py,sha256=jz8if-1_vUJSsqHRcyC_7ed_iuXqC9cJxysTFYWkGDw,2334
 OTVision/detect/otdet.py,sha256=cIwCBVFYWma7oJynoaT0eyIAZw-M2iH1xkvjy6-TwEM,8475
-OTVision/detect/otdet_file_writer.py,sha256=0FezBon_R-ve0oYMWMCDytNHIMuOEQqFOWVU7Dr9iTo,5388
+OTVision/detect/otdet_file_writer.py,sha256=N9oQ9ddFpzVjH9mNX_EIHwcH6izJIvGlqPO2D4lrQMA,5432
 OTVision/detect/pyav_frame_count_provider.py,sha256=w7p9iM3F2fljV8SD7q491gQhIHANbVczqtalcUiKj-E,453
-OTVision/detect/rtsp_based_detect_builder.py,sha256=P47nKU2C1PJQmokgacv04DzJ-7eG6CUbqqg3bdQhXTQ,2662
-OTVision/detect/rtsp_input_source.py,sha256=nF7AyRcbZlvYwPghvi3QbRPCHU9KTtcgtWiUdAAR4Jg,10806
+OTVision/detect/rtsp_based_detect_builder.py,sha256=CiMAKCtNojvm7DLuAdrrDMOUPlrZXIwWiW8CoJ6fa9M,2681
+OTVision/detect/rtsp_input_source.py,sha256=8lErJm18wFWCU0yyF2VK6VaDPaTPOdeblAOTlF-Y8d4,10963
 OTVision/detect/timestamper.py,sha256=VvDTzHu9fTI7qQL9x775Gc27r47R8D5Pb040ffwO04k,5288
-OTVision/detect/video_input_source.py,sha256=yosHCK5e737AmBk-AgF3sL9rs45w0AIwup0-hU3mf1A,10248
-OTVision/detect/yolo.py,sha256=JDnnPO-YO30tu61sw80K9qJS6_aYqdR2dQHAhtJ3tl0,10551
+OTVision/detect/video_input_source.py,sha256=vjQcy9YWphTOBgCDz73fE-ukN7k1e6noMf6XOIKCRKE,10534
+OTVision/detect/yolo.py,sha256=N68U8N7eiBFruIjWy391W7cvkV_WRvvJYUO0QTW-ZQI,10671
 OTVision/detect/plugin_av/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/detect/plugin_av/rotate_frame.py,sha256=4wJqTYI2HRlfa4p2Ffap33vLmKIzE_EwFvQraEkQ4R8,1055
 OTVision/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/domain/cli.py,sha256=INiw1dxQNO4XI6GGCIMhX2G08ig68FNS04fdtMt3gNs,2061
 OTVision/domain/current_config.py,sha256=Q38NCktoGNU1Z_miXNoJXLH8-NDbVszwVOMGR1aAwWM,286
-OTVision/domain/detect_producer_consumer.py,sha256=z2N4aXv0mlH-EZxoNUxKYyn7o4aB638YZMbExz9NgZI,840
+OTVision/domain/detect_producer_consumer.py,sha256=MHnBuF39YnmUn6blnPqtiWp3kYqCpsCt_rsz6RwFqrw,828
 OTVision/domain/detection.py,sha256=SZLP-87XE3NcTkeYz7GTqp4oPMiqI1P5gILp1_yHtxY,3761
 OTVision/domain/frame.py,sha256=1H0Cqg_LvO9BEwzGRkvRyJm6AauR_yS6kq0PHujonZk,6791
-OTVision/domain/input_source_detect.py,sha256=pdFnQ2xG1P4-KFWMS7a2-blx0hmR6N8Zza8GSMq4CDo,1081
-OTVision/domain/object_detection.py,sha256=oCazkbarKPBMzvQ3VeY2HQpWMUOgLeJBxXT52kl1syM,1327
+OTVision/domain/input_source_detect.py,sha256=zUZZycqlkJpEqCnyOo188P12K2i9Os4QUQm2wVje0s8,1095
+OTVision/domain/object_detection.py,sha256=BKwHo80u9w1Cn9Xpca3kqfBZC9JEj8iDRLYfonbxxRU,1330
 OTVision/domain/serialization.py,sha256=S7gb648z_W8U3Fb6TSk7hVU4qHlGwOZ7D6FeYSLXQwM,257
 OTVision/domain/time.py,sha256=_6a4zDbhXU7DmK7PdBYWRrrO2yQ4D68qtSYLTwnwWMQ,302
-OTVision/domain/video_writer.py,sha256=iYt-QXu8jaNSIwdbpEjc5hsEtHveUgqbmxme7iZNVLA,910
+OTVision/domain/video_writer.py,sha256=hq67zMahLXAtHv57booORputnexhmUMu3XQk8n1Na-U,916
 OTVision/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/helpers/date.py,sha256=L99CFQ7u34RwGDisFlrQoopZnkOOggQGDehWUi8kLiY,1347
 OTVision/helpers/files.py,sha256=G7zoOHzWIYrMmkjgHJHkZbh2hcGtnwZomuspthG2GsE,18444
@@ -75,20 +75,20 @@ OTVision/helpers/log.py,sha256=fOSMTXQRQ3_3zzYL8pDlx85IXPwyDsI2WGpK-V_R47Q,4985
 OTVision/helpers/machine.py,sha256=8Bz_Eg7PS0IL4riOVeJcEIi5D9E8Ju8-JomTkW975p8,2166
 OTVision/helpers/video.py,sha256=xyI35CiWXqoeGd3HeLhZUPxrLz8GccWyzHusxoweJr4,1480
 OTVision/plugin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/plugin/ffmpeg_video_writer.py,sha256=Q-exHN7aRoGEXAMyab-EGOqoKDL8ccwpB9IZhr1tjag,10428
+OTVision/plugin/ffmpeg_video_writer.py,sha256=rtzYjk74Vd0ydO2duY4B_AggM6fZwCvKCmGA3GmUx2g,10461
 OTVision/plugin/generate_video.py,sha256=Jxk8iQBP8YhobRIRJ535yW3gx0h4d7H8oz0rULRPgcc,840
 OTVision/plugin/yaml_serialization.py,sha256=LjJ_QLJPClRwsaw7ooagWT7LBW08OvSb527jbex1qIQ,557
 OTVision/track/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/track/builder.py,sha256=iDq9-QxU8c3CQQd5HDPzT2qkXWIyFl0fk658KQ7Soh0,4905
 OTVision/track/cli.py,sha256=Lzmij9vMuaArB8MerDcGlaefwKMgRWNWov1YLGWA6SI,4294
 OTVision/track/id_generator.py,sha256=2Lkegjhz8T2FXiK1HaiS_FbNZrJjIWzHi407-IoKAHg,241
-OTVision/track/stream_ottrk_file_writer.py,sha256=4t8O5-DS2LXdgQHM5yn4s2ypdr0ACAsmzg4U6QZW1hU,5495
-OTVision/track/track.py,sha256=iMOaukcHnPhRiU1eEccaeGEKLzBQoilaUPRVmkmt0rk,2357
+OTVision/track/stream_ottrk_file_writer.py,sha256=hncE6msUU4lHmYLP9JSv2VUKCJxnqQcX-DJQ0_fCQBg,5595
+OTVision/track/track.py,sha256=wdb8krQGiSxFtZ0kGZkrUkgMElmTvKkQRpPzD7INeCI,2371
 OTVision/track/exporter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/track/exporter/filebased_exporter.py,sha256=sdaWY4CxjawyeEKG329T92Bodf1E8wjnXuXocv0Ppgo,986
 OTVision/track/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/track/model/track_exporter.py,sha256=ZzpQJB6e599tapRB-vTbhCltflnPVdgmLwCELRRV9Z8,3267
-OTVision/track/model/tracking_interfaces.py,sha256=wZONk_wHn72RRYBgcetGX7NzN_lfVuoa8BJ7RANF6N4,10779
+OTVision/track/model/track_exporter.py,sha256=D3aU1qX-4Z_YNt21UJWq5PS8T_o1fX4wBJaM4JS93Mo,3289
+OTVision/track/model/tracking_interfaces.py,sha256=Q2b2XUh4R4frJ1kfru9SK_9IsryACxOmaM7TqOIVYdM,11029
 OTVision/track/model/filebased/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/track/model/filebased/frame_chunk.py,sha256=rXhQCHXWGJbePy5ZW3JZCdltGz5mZxFdcrW0mgez-2k,6771
 OTVision/track/model/filebased/frame_group.py,sha256=f-hXS1Vc5U_qf2cgNbYVeSTZ3dg5NUJhasOEHuuX1HE,2977
@@ -96,7 +96,7 @@ OTVision/track/parser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 OTVision/track/parser/chunk_parser_plugins.py,sha256=iHAuxnoBQvwQ2j6RYfLZgk-EmsBgU0q29bYnf4kAJIM,2607
 OTVision/track/parser/frame_group_parser_plugins.py,sha256=CMl_muqSKl4scIm4URluGZtPbQmMk1JfbJm3d5Yod9g,3815
 OTVision/track/tracker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-OTVision/track/tracker/filebased_tracking.py,sha256=H3WYbsSca-67898diBoixpLjBqQDnOSiqnbvvySE6fc,6576
+OTVision/track/tracker/filebased_tracking.py,sha256=HKJouBDCCHZdUoZzongdiipB4IS0I9xwuqur4On7-LE,6878
 OTVision/track/tracker/tracker_plugin_iou.py,sha256=AecE4CXRf4qUdN3_AvSFcsW4so-zDUGAVXqzfjSb-i0,7517
 OTVision/transform/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 OTVision/transform/get_homography.py,sha256=29waW61uzCCB7tlBAS2zck9sliAxZqnjjOa4jOOHHIc,5970
@@ -110,7 +110,7 @@ OTVision/view/view_helpers.py,sha256=a5yV_6ZxO5bxsSymOmxdHqzOEv0VFq4wFBopVRGuVRo
 OTVision/view/view_track.py,sha256=vmfMqpbUfnzg_EsWiL-IIKNOApVF09dzSojHpUfYY6M,5393
 OTVision/view/view_transform.py,sha256=HvRd8g8geKRy0OoiZUDn_oC3SJC5nuXhZf3uZelfGKg,5473
 OTVision/view/helpers/OTC.ico,sha256=G9kwlDtgBXmXO3yxW6Z-xVFV2q4nUGuz9E1VPHSu_I8,21662
-otvision-0.6.17.dist-info/METADATA,sha256=jHEqrFDQ7_q4medQTUzqTnm_6p_CvI3KvlK8rgi2WKQ,6944
-otvision-0.6.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-otvision-0.6.17.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-otvision-0.6.17.dist-info/RECORD,,
+otvision-0.7.0.dist-info/METADATA,sha256=kcjT_0BZjW8ANZMATLEOkFQ9h4fC0ywdIgHsk_rOIOg,6943
+otvision-0.7.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+otvision-0.7.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+otvision-0.7.0.dist-info/RECORD,,

{otvision-0.6.17.dist-info → otvision-0.7.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any