model-compose 0.4.96__tar.gz → 0.4.97__tar.gz

{model_compose-0.4.96 → model_compose-0.4.97}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.96
+Version: 0.4.97
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.4.96 → model_compose-0.4.97}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.96"
+version = "0.4.97"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.4.96 → model_compose-0.4.97}/src/mindor/core/component/services/model/tasks/face_tracking/common.py

@@ -81,7 +81,7 @@ class FaceTrackingTaskAction(ComponentAction):
         return_tracks            = await context.render_scalar(self.config.return_tracks, bool)
         return_track_image       = await context.render_scalar(self.config.return_track_image, bool)
         return_embedding         = await context.render_scalar(self.config.return_embedding, bool)
-        return_frames            = await context.render_scalar(self.config.return_frames, bool)
+        return_detections        = await context.render_scalar(self.config.return_detections, bool)
         return_frame_image       = await context.render_scalar(self.config.return_frame_image, bool)
         return_metadata          = await context.render_scalar(self.config.return_metadata, bool)
         bounding_box_padding     = await context.render_scalar(self.config.bounding_box_padding, float)
@@ -98,11 +98,11 @@ class FaceTrackingTaskAction(ComponentAction):
         if bounding_box_padding < 0.0:
             raise ValueError(f"'bounding_box_padding' must be >= 0.0, got {bounding_box_padding}")
 
-        if not return_tracks and not return_frames:
-            raise ValueError("Either 'return_tracks' or 'return_frames' must be true.")
+        if not return_tracks and not return_detections:
+            raise ValueError("Either 'return_tracks' or 'return_detections' must be true.")
 
-        if return_frame_image and not return_frames:
-            raise ValueError("'return_frame_image' requires 'return_frames' to be true.")
+        if return_frame_image and not return_detections:
+            raise ValueError("'return_frame_image' requires 'return_detections' to be true.")
 
         return {
             "similarity_threshold":     similarity_threshold,
@@ -114,7 +114,7 @@ class FaceTrackingTaskAction(ComponentAction):
             "return_tracks":            return_tracks,
             "return_track_image":       return_track_image,
             "return_embedding":         return_embedding,
-            "return_frames":            return_frames,
+            "return_detections":        return_detections,
             "return_frame_image":       return_frame_image,
             "return_metadata":          return_metadata,
             "bounding_box_padding":     bounding_box_padding,

{model_compose-0.4.96 → model_compose-0.4.97}/src/mindor/core/component/services/model/tasks/face_tracking/custom/insightface.py

@@ -131,10 +131,10 @@ class InsightfaceFaceTrackingTaskAction(FaceTrackingTaskAction):
             tracked_frame = await self._run_in_executor(_track_frame, image, timestamp)
             frame_count += 1
 
-            if params["return_frames"]:
+            if params["return_detections"]:
                 tracked_frames.append(tracked_frame)
 
-        if params["return_frames"]:
+        if params["return_detections"]:
             self._interpolate_missing_faces(tracked_frames, frame_rate, params["merge_gap"] or 0.0, params["max_track_distance"] or 0.0)
 
         # Flush any still-open `current` segment so every segment is
@@ -230,7 +230,7 @@ class InsightfaceFaceTrackingTaskAction(FaceTrackingTaskAction):
             # and had a prior detection within `merge_gap`. The prior/current
             # pair anchors the linear interpolation across the pending frames
             # in between.
-            if params["return_frames"]:
+            if params["return_detections"]:
                 for face, cluster_id in tracked_frame["tracked_faces"]:
                     last_face = last_face_by_cluster.get(cluster_id)
                     if last_face is not None:
@@ -253,7 +253,7 @@ class InsightfaceFaceTrackingTaskAction(FaceTrackingTaskAction):
                 pending_frames.append(tracked_frame)
 
                 for ready_frame in _flush_ready_frames(force=False):
-                    yield self._build_frame_chunk(ready_frame, params)
+                    yield self._build_detection_chunk(ready_frame, params)
 
             if params["return_tracks"]:
                 for cluster_id, segment in tracked_frame["tracked_segments"]:
@@ -270,9 +270,9 @@ class InsightfaceFaceTrackingTaskAction(FaceTrackingTaskAction):
                         yield segment_chunk
                     yield track_chunk
 
-        if params["return_frames"]:
+        if params["return_detections"]:
             for ready_frame in _flush_ready_frames(force=True):
-                yield self._build_frame_chunk(ready_frame, params)
+                yield self._build_detection_chunk(ready_frame, params)
 
         # Final flush: seal every still-open segment and emit any track that
         # hasn't been announced yet (including clusters that never went idle).
@@ -813,9 +813,6 @@ class InsightfaceFaceTrackingTaskAction(FaceTrackingTaskAction):
     ) -> Dict[str, Any]:
         result: Dict[str, Any] = {}
 
-        if params["return_metadata"]:
-            result["frame_count"] = frame_count
-
         if params["return_tracks"]:
             min_frame_count = params["min_frame_count"] or 1
             centroids: List[np.ndarray] = centroids_state["centroids"]
@@ -868,8 +865,11 @@ class InsightfaceFaceTrackingTaskAction(FaceTrackingTaskAction):
 
             result["tracks"] = tracks
 
-        if params["return_frames"]:
-            result["frames"] = [ self._serialize_tracked_frame(tracked_frame, params) for tracked_frame in tracked_frames ]
+        if params["return_detections"]:
+            result["detections"] = [ self._serialize_tracked_frame(tracked_frame, params) for tracked_frame in tracked_frames ]
+
+        if params["return_metadata"]:
+            result["frame_count"] = frame_count
 
         return result
 
@@ -932,9 +932,9 @@ class InsightfaceFaceTrackingTaskAction(FaceTrackingTaskAction):
             "segment":  segment,
         }
 
-    def _build_frame_chunk(self, tracked_frame: Dict[str, Any], params: Dict[str, Any]) -> Dict[str, Any]:
+    def _build_detection_chunk(self, tracked_frame: Dict[str, Any], params: Dict[str, Any]) -> Dict[str, Any]:
         chunk: Dict[str, Any] = {
-            "type":      "frame",
+            "type":      "detection",
             "number":    tracked_frame["number"],
             "timestamp": format_timecode(tracked_frame["timestamp"]),
             "faces":     [ self._serialize_tracked_face(tracked_face, cluster_id, params) for tracked_face, cluster_id in tracked_frame["tracked_faces"] ],

model_compose-0.4.97/src/mindor/core/component/services/model/tasks/object_tracking/common.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from typing import Optional, Union, Dict, List, Any
+from collections.abc import AsyncIterable, AsyncIterator
+from abc import abstractmethod
+from mindor.dsl.schema.action import ObjectTrackingModelActionConfig
+from mindor.core.foundation.variable.image import ImageArrayValue
+from mindor.core.foundation.streaming.iterators import StreamIterator, StreamChunkIterator
+from mindor.core.foundation.cancellation import CancellationToken
+from mindor.core.utils.iterators import BatchSourceIterator
+from .....action.base import ComponentAction
+from ...base import ComponentActionContext
+
+class ObjectTrackingTaskAction(ComponentAction):
+    def __init__(self, config: ObjectTrackingModelActionConfig):
+        self.config: ObjectTrackingModelActionConfig = config
+
+    async def run(self, context: ComponentActionContext) -> Any:
+        frames      = await context.render_image_array(self.config.frames)
+        frame_rate  = await context.render_scalar(self.config.frame_rate, float)
+        time_offset = await context.render_time(self.config.time_offset, 0.0)
+        batch_size  = await context.render_variable(self.config.batch_size)
+        streaming   = await context.render_scalar(self.config.streaming, bool)
+
+        if not frame_rate or frame_rate <= 0:
+            raise ValueError(f"'frame_rate' must be > 0, got {frame_rate}")
+
+        params = await self._resolve_params(context)
+
+        is_single_input  = isinstance(frames, ImageArrayValue)
+        is_direct_output = not self.config.output or self.config.output == "${result}"
+
+        if isinstance(frames, (StreamIterator, AsyncIterator)):
+            async def _stream_output_generator():
+                async for batch_frames, batch_offsets in BatchSourceIterator((frames, time_offset), batch_size=batch_size or 1):
+                    batch_results = await self._track_batch(batch_frames, batch_offsets, frame_rate, streaming, params, context.cancellation_token)
+                    for result in batch_results:
+                        if streaming:
+                            async def _stream_chunk_generator(result=result, scope=f"stream:{id(result)}"):
+                                async for chunk in result:
+                                    context.register_source("result[]", chunk, scope=scope)
+                                    yield (await context.render_variable(self.config.output, scope=scope)) if not is_direct_output else chunk
+
+                            yield StreamChunkIterator(_stream_chunk_generator(), is_fragmented=True)
+                        else:
+                            yield result
+
+            return _stream_output_generator()
+        else:
+            results: List[Any] = []
+            async for batch_frames, batch_offsets in BatchSourceIterator((frames, time_offset), batch_size=batch_size or 1):
+                batch_results = await self._track_batch(batch_frames, batch_offsets, frame_rate, streaming, params, context.cancellation_token)
+                for result in batch_results:
+                    if streaming:
+                        async def _stream_chunk_generator(result=result, scope=f"stream:{id(result)}"):
+                            async for chunk in result:
+                                context.register_source("result[]", chunk, scope=scope)
+                                yield (await context.render_variable(self.config.output, scope=scope)) if not is_direct_output else chunk
+
+                        results.append(StreamChunkIterator(_stream_chunk_generator(), is_fragmented=True))
+                    else:
+                        results.append(result)
+
+            result = results[0] if is_single_input else results
+            context.register_source("result", result)
+
+            return (await context.render_variable(self.config.output)) if not streaming and not is_direct_output else result
+
+    async def _resolve_params(self, context: ComponentActionContext) -> Dict[str, Any]:
+        labels                     = await context.render_variable(self.config.labels)
+        min_confidence             = await context.render_scalar(self.config.params.min_confidence, float)
+        iou_threshold              = await context.render_scalar(self.config.params.iou_threshold, float)
+        agnostic_nms               = await context.render_scalar(self.config.params.agnostic_nms, bool)
+        min_object_size            = await context.render_scalar(self.config.params.min_object_size, int)
+        min_frame_count            = await context.render_scalar(self.config.params.min_frame_count, int)
+        max_object_count_per_frame = await context.render_scalar(self.config.params.max_object_count_per_frame, int)
+        merge_gap                  = await context.render_scalar(self.config.params.merge_gap, float)
+        bounding_box_padding       = await context.render_scalar(self.config.bounding_box_padding, float)
+        return_tracks              = await context.render_scalar(self.config.return_tracks, bool)
+        return_track_image         = await context.render_scalar(self.config.return_track_image, bool)
+        return_detections          = await context.render_scalar(self.config.return_detections, bool)
+        return_frame_image         = await context.render_scalar(self.config.return_frame_image, bool)
+        return_metadata            = await context.render_scalar(self.config.return_metadata, bool)
+
+        if not 0.0 <= min_confidence <= 1.0:
+            raise ValueError(f"'min_confidence' must be between 0.0 and 1.0, got {min_confidence}")
+
+        if not 0.0 <= iou_threshold <= 1.0:
+            raise ValueError(f"'iou_threshold' must be between 0.0 and 1.0, got {iou_threshold}")
+
+        if merge_gap < 0.0:
+            raise ValueError(f"'merge_gap' must be >= 0.0, got {merge_gap}")
+
+        if bounding_box_padding < 0.0:
+            raise ValueError(f"'bounding_box_padding' must be >= 0.0, got {bounding_box_padding}")
+
+        if not return_tracks and not return_detections:
+            raise ValueError("Either 'return_tracks' or 'return_detections' must be true.")
+
+        if return_frame_image and not return_detections:
+            raise ValueError("'return_frame_image' requires 'return_detections' to be true.")
+
+        if labels is not None and not isinstance(labels, list):
+            labels = [ labels ]
+
+        return {
+            "labels":                     [ str(label) for label in labels ] if labels else None,
+            "min_confidence":             min_confidence,
+            "iou_threshold":              iou_threshold,
+            "agnostic_nms":               agnostic_nms,
+            "min_object_size":            min_object_size,
+            "min_frame_count":            min_frame_count,
+            "max_object_count_per_frame": max_object_count_per_frame,
+            "merge_gap":                  merge_gap,
+            "bounding_box_padding":       bounding_box_padding,
+            "return_tracks":              return_tracks,
+            "return_track_image":         return_track_image,
+            "return_detections":          return_detections,
+            "return_frame_image":         return_frame_image,
+            "return_metadata":            return_metadata,
+        }
+
+    @abstractmethod
+    async def _track_batch(
+        self,
+        frames_batch: List[ImageArrayValue],
+        offsets_batch: List[float],
+        frame_rate: float,
+        streaming: bool,
+        params: Dict[str, Any],
+        cancellation_token: Optional[CancellationToken] = None,
+    ) -> List[Union[Dict[str, Any], AsyncIterable[Dict[str, Any]]]]:
+        """Run tracking on a batch of independent frame sequences. Each item in
+        `frames_batch` is one video's ordered frames as an ImageArrayValue; the
+        matching offset in `offsets_batch` is that video's timestamp for its
+        first frame. Returns one item per input video: a tracking result dict
+        when `streaming` is false, or an async iterator yielding per-frame and
+        per-segment events (with a final done event carrying whatever wasn't
+        already streamed) when it is true. The base class wraps the iterator
+        as a StreamChunkIterator and applies per-chunk output rendering."""
+        pass

model_compose-0.4.97/src/mindor/core/component/services/model/tasks/object_tracking/custom/custom.py

@@ -0,0 +1,11 @@
+from mindor.dsl.schema.component import ModelComponentConfig, ObjectTrackingModelFamily
+from ....base import ModelTaskType, ModelDriver, register_model_task_service
+
+@register_model_task_service(ModelTaskType.OBJECT_TRACKING, ModelDriver.CUSTOM)
+class CustomObjectTrackingTaskService:
+    def __new__(cls, id: str, config: ModelComponentConfig, daemon: bool):
+        if config.family == ObjectTrackingModelFamily.YOLO:
+            from .yolo import YoloObjectTrackingTaskService
+            return YoloObjectTrackingTaskService(id, config, daemon)
+
+        raise ValueError(f"Unknown family: {config.family}")