roboflow-workflows 0.2.12__tar.gz → 0.2.13__tar.gz

{roboflow_workflows-0.2.12/roboflow_workflows.egg-info → roboflow_workflows-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roboflow-workflows
-Version: 0.2.12
+Version: 0.2.13
 Summary: Roboflow Workflows execution engine and block library
 License: LICENSE.core (Apache 2.0) applies to all files in this repository
         except for files in or under any directory that contains a superseding
@@ -29,8 +29,8 @@ Requires-Dist: requests<3.0.0,>=2.33.0
 Requires-Dist: urllib3<3.0.0,>=2.7.0
 Requires-Dist: torch<3.0.0,>=2.0.1
 Requires-Dist: torchvision
-Requires-Dist: inference-models>=0.39.5rc1
-Requires-Dist: inference-sdk>=1.8.0
+Requires-Dist: inference-models>=0.39.5
+Requires-Dist: inference-sdk>=1.8.1
 Requires-Dist: aiohttp~=3.14.4
 Requires-Dist: msgpack
 Requires-Dist: websocket-client~=1.9.0

{roboflow_workflows-0.2.12 → roboflow_workflows-0.2.13}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "roboflow-workflows"
-version = "0.2.12"
+version = "0.2.13"
 description = "Roboflow Workflows execution engine and block library"
 readme = "README.md"
 license = {file = "LICENSE"}
@@ -23,8 +23,8 @@ dependencies = [
   "urllib3>=2.7.0,<3.0.0",
   "torch>=2.0.1,<3.0.0",
   "torchvision",
-  "inference-models>=0.39.5rc1",
-  "inference-sdk>=1.8.0",
+  "inference-models>=0.39.5",
+  "inference-sdk>=1.8.1",
   "aiohttp~=3.14.4",
   "msgpack",
   "websocket-client~=1.9.0",

{roboflow_workflows-0.2.12 → roboflow_workflows-0.2.13}/roboflow_workflows/core_steps/common/query_language/operations/detections/base.py

@@ -77,6 +77,21 @@ PROPERTIES_EXTRACTORS = {
 }
 
 
+def _missing_property_error(
+    property_name: DetectionsProperty, execution_context: str
+) -> OperationError:
+    # Shared by the numpy and tensor-native siblings so the same misconfiguration
+    # reads the same under either representation flag.
+    error = OperationError(
+        public_message=f"Executing extract_detections_property(...) in context "
+        f"{execution_context}, property `{property_name.value}` is not available "
+        f"on these detections. Connect an upstream block that supplies this "
+        f"property before extracting it.",
+        context=f"step_execution | roboflow_query_language_evaluation | {execution_context}",
+    )
+    return error
+
+
 def _extract_detections_property(
     detections: Any,
     property_name: DetectionsProperty,
@@ -90,12 +105,31 @@ def _extract_detections_property(
             f"expected sv.Detections object as value, got {value_as_str} of type {type(detections)}",
             context=f"step_execution | roboflow_query_language_evaluation | {execution_context}",
         )
+
+    if len(detections) == 0:
+        return []
+
+    # `sv.Detections.tracker_id` is the system of record for tracker IDs: every
+    # tracker block and `sv.Detections.from_inference` write the native field and
+    # nothing in the repo writes `data["tracker_id"]`, so the native field wins.
     if (
-        property_name.value not in PROPERTIES_EXTRACTORS
-        and property_name.value in detections.data
+        property_name == DetectionsProperty.TRACKER_ID
+        and detections.tracker_id is not None
     ):
-        return detections.data[property_name.value].tolist()
-    return PROPERTIES_EXTRACTORS[property_name](detections)
+        result = detections.tracker_id.tolist()
+        return result
+
+    if property_name.value in detections.data:
+        result = detections.data[property_name.value].tolist()
+        return result
+
+    if property_name not in PROPERTIES_EXTRACTORS:
+        raise _missing_property_error(
+            property_name=property_name, execution_context=execution_context
+        )
+
+    result = PROPERTIES_EXTRACTORS[property_name](detections)
+    return result
 
 
 def _filter_detections(
@@ -884,15 +918,17 @@ def _extract_detections_property_tensor_native(
             operation_name="extract_detections_property",
             execution_context=execution_context,
         )
+
+    # Must run after the keypoint split: `len()` of the unsplit tuple is 2.
+    if _detections_count(detections) == 0:
+        return []
+
     if property_name not in PROPERTIES_EXTRACTORS_TENSOR_NATIVE:
         bboxes_metadata = _bboxes_metadata_list(detections)
         if any(property_name.value in data for data in bboxes_metadata):
             return [data.get(property_name.value) for data in bboxes_metadata]
-        raise OperationError(
-            public_message=f"Executing extract_detections_property(...) in context "
-            f"{execution_context}, property `{property_name.value}` is neither "
-            f"natively supported nor present in `bboxes_metadata` of the detections.",
-            context=f"step_execution | roboflow_query_language_evaluation | {execution_context}",
+        raise _missing_property_error(
+            property_name=property_name, execution_context=execution_context
         )
     return PROPERTIES_EXTRACTORS_TENSOR_NATIVE[property_name](detections)
 

{roboflow_workflows-0.2.12 → roboflow_workflows-0.2.13}/roboflow_workflows/core_steps/fusion/buffer/v1.py

@@ -167,6 +167,7 @@ class BufferBlockV1(WorkflowBlock):
         return BlockManifest
 
     def run(self, data: Any, length: int, pad: bool) -> BlockResult:
+        """Append a value and return a snapshot of the buffer entries."""
         self.buffer.insert(0, data)
         if len(self.buffer) > length:
             self.buffer = self.buffer[:length]
@@ -175,4 +176,4 @@ class BufferBlockV1(WorkflowBlock):
             while len(self.buffer) < length:
                 self.buffer.append(None)
 
-        return {"output": self.buffer}
+        return {"output": self.buffer.copy()}

{roboflow_workflows-0.2.12 → roboflow_workflows-0.2.13}/roboflow_workflows/core_steps/fusion/detections_stitch/v1.py

@@ -212,17 +212,12 @@ class DetectionsStitchBlockV1(WorkflowBlock):
         reference_height, reference_width = reference_image.numpy_image.shape[:2]
         resolution_wh = (reference_width, reference_height)
 
-        # Masks travel separately from the rest of the detections, as
-        # crop-scoped CompactMask (RLE of each mask's bounding box), and only
-        # the detections that survive overlap filtering are materialised at
-        # reference resolution. Moving every crop mask to a full-size dense
-        # array first costs N x H x W bytes before any filtering: a 1080p
-        # frame sliced 12 ways with ~25 masks per slice took ~3 GiB inside
-        # this block and OOM-killed an 8 GiB video worker (2026-09-28).
-        # merge / NMS / NMM run on the compact form, so peak memory is
-        # bounded by the survivors.
+        overlap_filter = choose_overlap_filter_strategy(
+            overlap_filtering_strategy=overlap_filtering_strategy,
+        )
         re_aligned_predictions = []
-        crop_masks: List[CompactMask] = []
+        crop_masks: List[Tuple[Union[np.ndarray, CompactMask], np.ndarray]] = []
+        compact_crop_masks: List[CompactMask] = []
         masks_seen = False
         masks_missing = False
         for detections in predictions:
@@ -243,15 +238,15 @@ class DetectionsStitchBlockV1(WorkflowBlock):
             if mask is None:
                 masks_missing = True
                 continue
-
             masks_seen = True
-            crop_masks.append(
-                compact_mask_for_crop(
-                    np.asarray(mask),
-                    offset=offset,
-                    resolution_wh=resolution_wh,
+            if overlap_filter is OverlapFilter.NONE:
+                crop_masks.append((mask, offset))
+            else:
+                compact_crop_masks.append(
+                    compact_mask_for_crop(
+                        np.asarray(mask), offset=offset, resolution_wh=resolution_wh
+                    )
                 )
-            )
         if masks_seen and masks_missing:
             raise ValueError(
                 "Detections Stitch block received a mix of predictions with and "
@@ -259,15 +254,17 @@ class DetectionsStitchBlockV1(WorkflowBlock):
                 "masks, or none may."
             )
 
-        overlap_filter = choose_overlap_filter_strategy(
-            overlap_filtering_strategy=overlap_filtering_strategy,
-        )
         merged = sv.Detections.merge(detections_list=re_aligned_predictions)
-        if crop_masks:
-            merged.mask = CompactMask.merge(crop_masks)
         if overlap_filter is OverlapFilter.NONE:
-            filtered = merged
-        elif overlap_filter is OverlapFilter.NON_MAX_SUPPRESSION:
+            if crop_masks:
+                merged.mask = stitch_masks_dense(
+                    crop_masks=crop_masks, resolution_wh=resolution_wh
+                )
+            return {"predictions": merged}
+
+        if compact_crop_masks:
+            merged.mask = CompactMask.merge(compact_crop_masks)
+        if overlap_filter is OverlapFilter.NON_MAX_SUPPRESSION:
             filtered = merged.with_nms(threshold=iou_threshold)
         else:
             filtered = merged.with_nmm(threshold=iou_threshold)
@@ -284,6 +281,99 @@ def _copy_without_mask(detections: sv.Detections) -> sv.Detections:
     return detections_copy
 
 
+def visible_crop_region(
+    crop_shape: Tuple[int, int],
+    *,
+    offset: np.ndarray,
+    resolution_wh: Tuple[int, int],
+) -> Optional[Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int]]]:
+    """Find the part of a crop that lands inside the reference frame.
+
+    Mirrors the clipping of ``move_masks``: a crop may start before the
+    reference origin (negative offset) or extend past its far edge.
+
+    Args:
+        crop_shape: ``(crop_h, crop_w)`` of the crop masks.
+        offset: ``(x, y)`` position of the crop in the reference image.
+        resolution_wh: ``(width, height)`` of the reference image.
+
+    Returns:
+        ``((source_y1, source_y2, source_x1, source_x2), (target_y1, target_y2,
+        target_x1, target_x2))`` - the crop slice and the reference slice it
+        maps onto - or ``None`` if the crop is entirely outside the frame.
+    """
+    reference_width, reference_height = resolution_wh
+    offset_x, offset_y = int(offset[0]), int(offset[1])
+    crop_height, crop_width = crop_shape
+    source_x1, source_y1 = max(0, -offset_x), max(0, -offset_y)
+    source_x2 = min(crop_width, reference_width - offset_x)
+    source_y2 = min(crop_height, reference_height - offset_y)
+    if source_x2 <= source_x1 or source_y2 <= source_y1:
+        return None
+    target_x1, target_y1 = offset_x + source_x1, offset_y + source_y1
+    target_x2 = target_x1 + (source_x2 - source_x1)
+    target_y2 = target_y1 + (source_y2 - source_y1)
+    return (
+        (source_y1, source_y2, source_x1, source_x2),
+        (target_y1, target_y2, target_x1, target_x2),
+    )
+
+
+def stitch_masks_dense(
+    crop_masks: List[Tuple[Union[np.ndarray, CompactMask], np.ndarray]],
+    *,
+    resolution_wh: Tuple[int, int],
+) -> np.ndarray:
+    """Place every crop's masks in one dense reference-size stack.
+
+    Equivalent to ``move_masks`` per crop followed by ``np.concatenate``, but
+    the output ``(N, reference_h, reference_w)`` array is the only
+    reference-size allocation: no per-crop full-frame stacks, concatenation
+    copy or compact intermediates. Only each mask's tight bounding box is
+    written, so the rest of the (calloc-zeroed) output is never touched;
+    writing the whole crop window per mask was 2x slower and left ~50% more
+    resident memory on 300 masks from 640x640 crops.
+
+    A crop given as ``CompactMask`` is decoded inside the loop, so at most
+    one crop's dense ``(n_i, crop_h, crop_w)`` stack is alive at a time.
+
+    Args:
+        crop_masks: ``(masks, offset)`` per crop, in output order; ``masks``
+            is ``(n_i, crop_h, crop_w)``, dense or ``CompactMask``, and
+            ``offset`` is the crop's ``(x, y)`` position in the reference
+            image.
+        resolution_wh: ``(width, height)`` of the reference image.
+
+    Returns:
+        Boolean ``(sum(n_i), height, width)`` array.
+    """
+    reference_width, reference_height = resolution_wh
+    total = sum(masks.shape[0] for masks, _ in crop_masks)
+    stitched = np.zeros((total, reference_height, reference_width), dtype=bool)
+    row = 0
+    for masks, offset in crop_masks:
+        count = masks.shape[0]
+        region = visible_crop_region(
+            masks.shape[1:], offset=offset, resolution_wh=resolution_wh
+        )
+        if region is not None:
+            (sy1, sy2, sx1, sx2), (ty1, _, tx1, _) = region
+            visible = np.asarray(masks)[:, sy1:sy2, sx1:sx2]
+            # half-open boxes; an empty mask comes back as all zeros and is
+            # skipped, which leaves its output rows False
+            tight = sv.mask_to_xyxy(masks=visible, coordinate_convention="exclusive")
+            for index, (x1, y1, x2, y2) in enumerate(tight.tolist()):
+                if x2 <= x1 or y2 <= y1:
+                    continue
+                stitched[row + index, ty1 + y1 : ty1 + y2, tx1 + x1 : tx1 + x2] = (
+                    visible[index, y1:y2, x1:x2]
+                )
+            # drop the decoded crop before the next one is decoded
+            del visible
+        row += count
+    return stitched
+
+
 def compact_mask_for_crop(
     masks: np.ndarray,
     *,
@@ -311,27 +401,22 @@ def compact_mask_for_crop(
         raise ValueError("To move non-empty detections offset is needed, but not given")
 
     reference_width, reference_height = resolution_wh
-    offset_x, offset_y = int(offset[0]), int(offset[1])
-    _, crop_height, crop_width = masks.shape
-    # The part of the crop that lands inside the reference frame; the rest is
-    # what move_masks would clip away.
-    source_x1, source_y1 = max(0, -offset_x), max(0, -offset_y)
-    source_x2 = min(crop_width, reference_width - offset_x)
-    source_y2 = min(crop_height, reference_height - offset_y)
-    if source_x2 <= source_x1 or source_y2 <= source_y1:
+    region = visible_crop_region(
+        masks.shape[1:], offset=offset, resolution_wh=resolution_wh
+    )
+    if region is None:
         visible = np.zeros((masks.shape[0], 1, 1), dtype=bool)
-        source_x1, source_y1 = 0, 0
+        target_x1, target_y1 = 0, 0
     else:
-        visible = np.ascontiguousarray(
-            masks[:, source_y1:source_y2, source_x1:source_x2]
-        )
+        (sy1, sy2, sx1, sx2), (target_y1, _, target_x1, _) = region
+        visible = np.ascontiguousarray(masks[:, sy1:sy2, sx1:sx2])
 
     visible_shape = (visible.shape[1], visible.shape[2])
     tight_boxes = sv.mask_to_xyxy(masks=visible)
     compact = CompactMask.from_dense(visible, tight_boxes, visible_shape)
     positioned = compact.with_offset(
-        offset_x + source_x1,
-        offset_y + source_y1,
+        target_x1,
+        target_y1,
         (reference_height, reference_width),
     )
     return positioned

{roboflow_workflows-0.2.12 → roboflow_workflows-0.2.13}/roboflow_workflows/enterprise_blocks/loader.py

@@ -19,6 +19,7 @@ from roboflow_workflows.enterprise_blocks.sinks.mqtt_writer.v1 import (
 from roboflow_workflows.enterprise_blocks.sinks.mqtt_writer.v2 import (
     MQTTWriterSinkBlockV2,
 )
+from roboflow_workflows.enterprise_blocks.sinks.opc_reader.v1 import OPCReaderBlockV1
 from roboflow_workflows.enterprise_blocks.sinks.opc_writer.v1 import (
     OPCWriterSinkBlockV1,
 )
@@ -46,6 +47,7 @@ def load_blocks() -> List[Type[WorkflowBlock]]:
 def load_enterprise_blocks() -> List[Type[WorkflowBlock]]:
     return [
         OPCWriterSinkBlockV1,
+        OPCReaderBlockV1,
         MQTTWriterSinkBlockV1,
         MQTTWriterSinkBlockV2,
         MQTTReaderBlockV1,