roboflow-workflows 0.2.5rc2__tar.gz → 0.2.6__tar.gz

{roboflow_workflows-0.2.5rc2/roboflow_workflows.egg-info → roboflow_workflows-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roboflow-workflows
-Version: 0.2.5rc2
+Version: 0.2.6
 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

{roboflow_workflows-0.2.5rc2 → roboflow_workflows-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "roboflow-workflows"
-version = "0.2.5rc2"
+version = "0.2.6"
 description = "Roboflow Workflows execution engine and block library"
 readme = "README.md"
 license = {file = "LICENSE"}

{roboflow_workflows-0.2.5rc2 → roboflow_workflows-0.2.6}/roboflow_workflows/core_steps/models/foundation/segment_anything3/v1.py

@@ -39,6 +39,7 @@ from roboflow_workflows.environment import (
     SAM3_EXEC_MODE,
     WORKFLOWS_REMOTE_API_KEY_TRANSPORT,
     WORKFLOWS_REMOTE_API_TARGET,
+    WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS,
 )
 from roboflow_workflows.execution_engine.entities.base import (
     Batch,
@@ -392,7 +393,45 @@ class SegmentAnything3BlockV1(WorkflowBlock):
         class_names: Optional[List[str]],
         threshold: float,
     ) -> BlockResult:
+        """Run per-image SAM3 requests with bounded SDK concurrency.
+
+        Args:
+            images: Images in workflow batch order.
+            model_id: SAM3 model identifier.
+            class_names: Text prompts in class order.
+            threshold: Minimum prediction confidence.
+
+        Returns:
+            Predictions aligned with the input image order.
+        """
         ensure_builtin_remote_execution_allowed("SAM3 remote execution")
+        results: List[dict] = []
+        group_size = max(1, WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS)
+        for start in range(0, len(images), group_size):
+            # Finish conversion and release response data before the next group.
+            # An HTTP failure propagates here, preventing any later dispatch.
+            results.extend(
+                self._run_remote_batch(
+                    images=images[start : start + group_size],
+                    model_id=model_id,
+                    class_names=class_names,
+                    threshold=threshold,
+                )
+            )
+        return results
+
+    def _run_remote_batch(
+        self,
+        images: Batch[WorkflowImageData],
+        model_id: str,
+        class_names: Optional[List[str]],
+        threshold: float,
+    ) -> BlockResult:
+        """Request and convert one concurrency-sized group of images."""
+        ensure_builtin_remote_execution_allowed("SAM3 remote execution")
+        if len(images) == 0:
+            return []
+
         predictions = []
         if class_names is None:
             class_names = []
@@ -409,27 +448,39 @@ class SegmentAnything3BlockV1(WorkflowBlock):
             api_key=self._api_key,
         )
         client.configure(
-            InferenceConfiguration(api_key_transport=WORKFLOWS_REMOTE_API_KEY_TRANSPORT)
+            InferenceConfiguration(
+                api_key_transport=WORKFLOWS_REMOTE_API_KEY_TRANSPORT,
+                # The endpoint segments exactly one image per request.
+                max_batch_size=1,
+                max_concurrent_requests=WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS,
+            )
         )
         if WORKFLOWS_REMOTE_API_TARGET == "hosted":
             client.select_api_v0()
 
-        for single_image in images:
+        http_prompts: List[dict] = [
+            {"type": "text", "text": class_name} for class_name in class_names
+        ]
+
+        responses = client.sam3_concept_segment(
+            inference_input=[single_image.base64_image for single_image in images],
+            prompts=http_prompts,
+            model_id=model_id,
+            output_prob_thresh=threshold,
+        )
+        # A single-image batch comes back as a bare dict.
+        if not isinstance(responses, list):
+            responses = [responses]
+        if len(responses) != len(images):
+            raise ValueError(
+                f"SAM3 returned {len(responses)} responses for {len(images)} images"
+            )
+
+        for single_image, resp_json in zip(images, responses):
             prompt_class_ids: List[Optional[int]] = []
             prompt_class_names: List[Optional[str]] = []
             prompt_detection_ids: List[Optional[str]] = []
 
-            http_prompts: List[dict] = []
-            for class_name in class_names:
-                http_prompts.append({"type": "text", "text": class_name})
-
-            resp_json = client.sam3_concept_segment(
-                inference_input=single_image.base64_image,
-                prompts=http_prompts,
-                model_id=model_id,
-                output_prob_thresh=threshold,
-            )
-
             class_predictions: List[InstanceSegmentationPrediction] = []
             for prompt_result in resp_json.get("prompt_results", []):
                 idx = prompt_result.get("prompt_index", 0)

{roboflow_workflows-0.2.5rc2 → roboflow_workflows-0.2.6}/roboflow_workflows/core_steps/models/foundation/segment_anything3/v1_tensor.py

@@ -46,6 +46,7 @@ from roboflow_workflows.environment import (
     WORKFLOWS_IMAGE_TENSOR_DEVICE,
     WORKFLOWS_REMOTE_API_KEY_TRANSPORT,
     WORKFLOWS_REMOTE_API_TARGET,
+    WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS,
 )
 from roboflow_workflows.execution_engine.constants import (
     CLASS_NAME_KEY,
@@ -360,7 +361,48 @@ class SegmentAnything3BlockV1(WorkflowBlock):
         threshold: float,
         mask_representation: str,
     ) -> BlockResult:
+        """Run per-image SAM3 requests with bounded SDK concurrency.
+
+        Args:
+            images: Images in workflow batch order.
+            model_id: SAM3 model identifier.
+            class_names: Text prompts in class order.
+            threshold: Minimum prediction confidence.
+            mask_representation: Representation for the returned native masks.
+
+        Returns:
+            Predictions aligned with the input image order.
+        """
+        ensure_builtin_remote_execution_allowed("SAM3 remote execution")
+        results: List[dict] = []
+        group_size = max(1, WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS)
+        for start in range(0, len(images), group_size):
+            # Finish conversion and release response data before the next group.
+            # An HTTP failure propagates here, preventing any later dispatch.
+            results.extend(
+                self._run_remote_batch(
+                    images=images[start : start + group_size],
+                    model_id=model_id,
+                    class_names=class_names,
+                    threshold=threshold,
+                    mask_representation=mask_representation,
+                )
+            )
+        return results
+
+    def _run_remote_batch(
+        self,
+        images: Batch[WorkflowImageData],
+        model_id: str,
+        class_names: List[Optional[str]],
+        threshold: float,
+        mask_representation: str,
+    ) -> BlockResult:
+        """Request and convert one concurrency-sized group of images."""
         ensure_builtin_remote_execution_allowed("SAM3 remote execution")
+        if len(images) == 0:
+            return []
+
         api_url = (
             LOCAL_INFERENCE_API_URL
             if WORKFLOWS_REMOTE_API_TARGET != "hosted"
@@ -368,20 +410,33 @@ class SegmentAnything3BlockV1(WorkflowBlock):
         )
         client = InferenceHTTPClient(api_url=api_url, api_key=self._api_key)
         client.configure(
-            InferenceConfiguration(api_key_transport=WORKFLOWS_REMOTE_API_KEY_TRANSPORT)
+            InferenceConfiguration(
+                api_key_transport=WORKFLOWS_REMOTE_API_KEY_TRANSPORT,
+                # The endpoint segments exactly one image per request.
+                max_batch_size=1,
+                max_concurrent_requests=WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS,
+            )
         )
         if WORKFLOWS_REMOTE_API_TARGET == "hosted":
             client.select_api_v0()
         http_prompts = [{"type": "text", "text": cn} for cn in class_names]
 
-        results: List[dict] = []
-        for single_image in images:
-            resp_json = client.sam3_concept_segment(
-                inference_input=single_image.base64_image,
-                prompts=http_prompts,
-                model_id=model_id,
-                output_prob_thresh=threshold,
+        responses = client.sam3_concept_segment(
+            inference_input=[single_image.base64_image for single_image in images],
+            prompts=http_prompts,
+            model_id=model_id,
+            output_prob_thresh=threshold,
+        )
+        # A single-image batch comes back as a bare dict.
+        if not isinstance(responses, list):
+            responses = [responses]
+        if len(responses) != len(images):
+            raise ValueError(
+                f"SAM3 returned {len(responses)} responses for {len(images)} images"
             )
+
+        results: List[dict] = []
+        for single_image, resp_json in zip(images, responses):
             results.append(
                 self._build_from_polygon_response(
                     resp_json=resp_json,

{roboflow_workflows-0.2.5rc2 → roboflow_workflows-0.2.6}/roboflow_workflows/core_steps/models/foundation/segment_anything3/v2.py

@@ -39,6 +39,7 @@ from roboflow_workflows.environment import (
     SAM3_EXEC_MODE,
     WORKFLOWS_REMOTE_API_KEY_TRANSPORT,
     WORKFLOWS_REMOTE_API_TARGET,
+    WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS,
 )
 from roboflow_workflows.execution_engine.entities.base import (
     Batch,
@@ -470,7 +471,54 @@ class SegmentAnything3BlockV2(WorkflowBlock):
         apply_nms: bool = True,
         nms_iou_threshold: float = 0.9,
     ) -> BlockResult:
+        """Run per-image SAM3 requests with bounded SDK concurrency.
+
+        Args:
+            images: Images in workflow batch order.
+            model_id: SAM3 model identifier.
+            class_names: Text prompts in class order.
+            confidence: Default minimum prediction confidence.
+            per_class_confidence: Optional confidence overrides in prompt order.
+            apply_nms: Whether the server suppresses overlapping masks.
+            nms_iou_threshold: Mask overlap threshold for suppression.
+
+        Returns:
+            Predictions aligned with the input image order.
+        """
+        ensure_builtin_remote_execution_allowed("SAM3 remote execution")
+        results: List[dict] = []
+        group_size = max(1, WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS)
+        for start in range(0, len(images), group_size):
+            # Finish conversion and release response data before the next group.
+            # An HTTP failure propagates here, preventing any later dispatch.
+            results.extend(
+                self._run_remote_batch(
+                    images=images[start : start + group_size],
+                    model_id=model_id,
+                    class_names=class_names,
+                    confidence=confidence,
+                    per_class_confidence=per_class_confidence,
+                    apply_nms=apply_nms,
+                    nms_iou_threshold=nms_iou_threshold,
+                )
+            )
+        return results
+
+    def _run_remote_batch(
+        self,
+        images: Batch[WorkflowImageData],
+        model_id: str,
+        class_names: Optional[List[str]],
+        confidence: float,
+        per_class_confidence: Optional[List[float]] = None,
+        apply_nms: bool = True,
+        nms_iou_threshold: float = 0.9,
+    ) -> BlockResult:
+        """Request and convert one concurrency-sized group of images."""
         ensure_builtin_remote_execution_allowed("SAM3 remote execution")
+        if len(images) == 0:
+            return []
+
         predictions = []
         if class_names is None:
             class_names = []
@@ -487,31 +535,43 @@ class SegmentAnything3BlockV2(WorkflowBlock):
             api_key=self._api_key,
         )
         client.configure(
-            InferenceConfiguration(api_key_transport=WORKFLOWS_REMOTE_API_KEY_TRANSPORT)
+            InferenceConfiguration(
+                api_key_transport=WORKFLOWS_REMOTE_API_KEY_TRANSPORT,
+                # The endpoint segments exactly one image per request.
+                max_batch_size=1,
+                max_concurrent_requests=WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS,
+            )
         )
         if WORKFLOWS_REMOTE_API_TARGET == "hosted":
             client.select_api_v0()
 
-        for single_image in images:
+        http_prompts: List[dict] = []
+        for idx, class_name in enumerate(class_names):
+            prompt_data = {"type": "text", "text": class_name}
+            if per_class_confidence is not None:
+                prompt_data["output_prob_thresh"] = per_class_confidence[idx]
+            http_prompts.append(prompt_data)
+
+        responses = client.sam3_concept_segment(
+            inference_input=[single_image.base64_image for single_image in images],
+            prompts=http_prompts,
+            model_id=model_id,
+            output_prob_thresh=confidence,
+            nms_iou_threshold=nms_iou_threshold if apply_nms else None,
+        )
+        # A single-image batch comes back as a bare dict.
+        if not isinstance(responses, list):
+            responses = [responses]
+        if len(responses) != len(images):
+            raise ValueError(
+                f"SAM3 returned {len(responses)} responses for {len(images)} images"
+            )
+
+        for single_image, resp_json in zip(images, responses):
             prompt_class_ids: List[Optional[int]] = []
             prompt_class_names: List[Optional[str]] = []
             prompt_detection_ids: List[Optional[str]] = []
 
-            http_prompts: List[dict] = []
-            for idx, class_name in enumerate(class_names):
-                prompt_data = {"type": "text", "text": class_name}
-                if per_class_confidence is not None:
-                    prompt_data["output_prob_thresh"] = per_class_confidence[idx]
-                http_prompts.append(prompt_data)
-
-            resp_json = client.sam3_concept_segment(
-                inference_input=single_image.base64_image,
-                prompts=http_prompts,
-                model_id=model_id,
-                output_prob_thresh=confidence,
-                nms_iou_threshold=nms_iou_threshold if apply_nms else None,
-            )
-
             class_predictions: List[InstanceSegmentationPrediction] = []
             for prompt_result in resp_json.get("prompt_results", []):
                 idx = prompt_result.get("prompt_index", 0)

{roboflow_workflows-0.2.5rc2 → roboflow_workflows-0.2.6}/roboflow_workflows/core_steps/models/foundation/segment_anything3/v2_tensor.py

@@ -55,6 +55,7 @@ from roboflow_workflows.environment import (
     WORKFLOWS_IMAGE_TENSOR_DEVICE,
     WORKFLOWS_REMOTE_API_KEY_TRANSPORT,
     WORKFLOWS_REMOTE_API_TARGET,
+    WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS,
 )
 from roboflow_workflows.execution_engine.constants import (
     CLASS_NAME_KEY,
@@ -458,7 +459,57 @@ class SegmentAnything3BlockV2(WorkflowBlock):
         nms_iou_threshold: float,
         mask_representation: str,
     ) -> BlockResult:
+        """Run per-image SAM3 requests with bounded SDK concurrency.
+
+        Args:
+            images: Images in workflow batch order.
+            model_id: SAM3 model identifier.
+            class_names: Text prompts in class order.
+            confidence: Default minimum prediction confidence.
+            per_class_confidence: Optional confidence overrides in prompt order.
+            apply_nms: Whether the server suppresses overlapping masks.
+            nms_iou_threshold: Mask overlap threshold for suppression.
+            mask_representation: Representation for the returned native masks.
+
+        Returns:
+            Predictions aligned with the input image order.
+        """
+        ensure_builtin_remote_execution_allowed("SAM3 remote execution")
+        results: List[dict] = []
+        group_size = max(1, WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS)
+        for start in range(0, len(images), group_size):
+            # Finish conversion and release response data before the next group.
+            # An HTTP failure propagates here, preventing any later dispatch.
+            results.extend(
+                self._run_remote_batch(
+                    images=images[start : start + group_size],
+                    model_id=model_id,
+                    class_names=class_names,
+                    confidence=confidence,
+                    per_class_confidence=per_class_confidence,
+                    apply_nms=apply_nms,
+                    nms_iou_threshold=nms_iou_threshold,
+                    mask_representation=mask_representation,
+                )
+            )
+        return results
+
+    def _run_remote_batch(
+        self,
+        images: Batch[WorkflowImageData],
+        model_id: str,
+        class_names: List[Optional[str]],
+        confidence: float,
+        per_class_confidence: Optional[List[float]],
+        apply_nms: bool,
+        nms_iou_threshold: float,
+        mask_representation: str,
+    ) -> BlockResult:
+        """Request and convert one concurrency-sized group of images."""
         ensure_builtin_remote_execution_allowed("SAM3 remote execution")
+        if len(images) == 0:
+            return []
+
         api_url = (
             LOCAL_INFERENCE_API_URL
             if WORKFLOWS_REMOTE_API_TARGET != "hosted"
@@ -466,21 +517,34 @@ class SegmentAnything3BlockV2(WorkflowBlock):
         )
         client = InferenceHTTPClient(api_url=api_url, api_key=self._api_key)
         client.configure(
-            InferenceConfiguration(api_key_transport=WORKFLOWS_REMOTE_API_KEY_TRANSPORT)
+            InferenceConfiguration(
+                api_key_transport=WORKFLOWS_REMOTE_API_KEY_TRANSPORT,
+                # The endpoint segments exactly one image per request.
+                max_batch_size=1,
+                max_concurrent_requests=WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS,
+            )
         )
         if WORKFLOWS_REMOTE_API_TARGET == "hosted":
             client.select_api_v0()
         http_prompts = _build_http_prompts(class_names, per_class_confidence)
 
-        results: List[dict] = []
-        for single_image in images:
-            resp_json = client.sam3_concept_segment(
-                inference_input=single_image.base64_image,
-                prompts=http_prompts,
-                model_id=model_id,
-                output_prob_thresh=confidence,
-                nms_iou_threshold=nms_iou_threshold if apply_nms else None,
+        responses = client.sam3_concept_segment(
+            inference_input=[single_image.base64_image for single_image in images],
+            prompts=http_prompts,
+            model_id=model_id,
+            output_prob_thresh=confidence,
+            nms_iou_threshold=nms_iou_threshold if apply_nms else None,
+        )
+        # A single-image batch comes back as a bare dict.
+        if not isinstance(responses, list):
+            responses = [responses]
+        if len(responses) != len(images):
+            raise ValueError(
+                f"SAM3 returned {len(responses)} responses for {len(images)} images"
             )
+
+        results: List[dict] = []
+        for single_image, resp_json in zip(images, responses):
             results.append(
                 self._build_from_polygon_response(
                     resp_json=resp_json,

{roboflow_workflows-0.2.5rc2 → roboflow_workflows-0.2.6}/roboflow_workflows/core_steps/models/foundation/segment_anything3/v3.py

@@ -38,6 +38,7 @@ from roboflow_workflows.environment import (
     SAM3_EXEC_MODE,
     WORKFLOWS_REMOTE_API_KEY_TRANSPORT,
     WORKFLOWS_REMOTE_API_TARGET,
+    WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS,
 )
 from roboflow_workflows.execution_engine.constants import (
     DETECTION_ID_KEY,
@@ -514,7 +515,57 @@ class SegmentAnything3BlockV3(WorkflowBlock):
         nms_iou_threshold: float = 0.9,
         output_format: Literal["rle", "polygons"] = "rle",
     ) -> BlockResult:
+        """Run per-image SAM3 requests with bounded SDK concurrency.
+
+        Args:
+            images: Images in workflow batch order.
+            model_id: SAM3 model identifier.
+            class_names: Text prompts in class order.
+            confidence: Default minimum prediction confidence.
+            per_class_confidence: Optional confidence overrides in prompt order.
+            apply_nms: Whether the server suppresses overlapping masks.
+            nms_iou_threshold: Mask overlap threshold for suppression.
+            output_format: Requested RLE or polygon response representation.
+
+        Returns:
+            Predictions aligned with the input image order.
+        """
+        ensure_builtin_remote_execution_allowed("SAM3 remote execution")
+        results: List[dict] = []
+        group_size = max(1, WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS)
+        for start in range(0, len(images), group_size):
+            # Finish conversion and release response data before the next group.
+            # An HTTP failure propagates here, preventing any later dispatch.
+            results.extend(
+                self._run_remote_batch(
+                    images=images[start : start + group_size],
+                    model_id=model_id,
+                    class_names=class_names,
+                    confidence=confidence,
+                    per_class_confidence=per_class_confidence,
+                    apply_nms=apply_nms,
+                    nms_iou_threshold=nms_iou_threshold,
+                    output_format=output_format,
+                )
+            )
+        return results
+
+    def _run_remote_batch(
+        self,
+        images: Batch[WorkflowImageData],
+        model_id: str,
+        class_names: Optional[List[str]],
+        confidence: float,
+        per_class_confidence: Optional[List[float]] = None,
+        apply_nms: bool = True,
+        nms_iou_threshold: float = 0.9,
+        output_format: Literal["rle", "polygons"] = "rle",
+    ) -> BlockResult:
+        """Request and convert one concurrency-sized group of images."""
         ensure_builtin_remote_execution_allowed("SAM3 remote execution")
+        if len(images) == 0:
+            return []
+
         if class_names is None:
             class_names = []
         if len(class_names) == 0:
@@ -530,31 +581,43 @@ class SegmentAnything3BlockV3(WorkflowBlock):
             api_key=self._api_key,
         )
         client.configure(
-            InferenceConfiguration(api_key_transport=WORKFLOWS_REMOTE_API_KEY_TRANSPORT)
+            InferenceConfiguration(
+                api_key_transport=WORKFLOWS_REMOTE_API_KEY_TRANSPORT,
+                # The endpoint segments exactly one image per request.
+                max_batch_size=1,
+                max_concurrent_requests=WORKFLOWS_REMOTE_EXECUTION_MAX_STEP_CONCURRENT_REQUESTS,
+            )
         )
         if WORKFLOWS_REMOTE_API_TARGET == "hosted":
             client.select_api_v0()
 
         model_format = "rle" if output_format == "rle" else "polygon"
 
-        all_detections = []
-        for single_image in images:
-            http_prompts: List[dict] = []
-            for idx, class_name in enumerate(class_names):
-                prompt_data = {"type": "text", "text": class_name}
-                if per_class_confidence is not None:
-                    prompt_data["output_prob_thresh"] = per_class_confidence[idx]
-                http_prompts.append(prompt_data)
+        http_prompts: List[dict] = []
+        for idx, class_name in enumerate(class_names):
+            prompt_data = {"type": "text", "text": class_name}
+            if per_class_confidence is not None:
+                prompt_data["output_prob_thresh"] = per_class_confidence[idx]
+            http_prompts.append(prompt_data)
 
-            resp_json = client.sam3_concept_segment(
-                inference_input=single_image.base64_image,
-                prompts=http_prompts,
-                model_id=model_id,
-                output_prob_thresh=confidence,
-                nms_iou_threshold=nms_iou_threshold if apply_nms else None,
-                format=model_format,
+        responses = client.sam3_concept_segment(
+            inference_input=[single_image.base64_image for single_image in images],
+            prompts=http_prompts,
+            model_id=model_id,
+            output_prob_thresh=confidence,
+            nms_iou_threshold=nms_iou_threshold if apply_nms else None,
+            format=model_format,
+        )
+        # A single-image batch comes back as a bare dict.
+        if not isinstance(responses, list):
+            responses = [responses]
+        if len(responses) != len(images):
+            raise ValueError(
+                f"SAM3 returned {len(responses)} responses for {len(images)} images"
             )
 
+        all_detections = []
+        for single_image, resp_json in zip(images, responses):
             image_width = single_image.numpy_image.shape[1]
             image_height = single_image.numpy_image.shape[0]