roboflow-workflows 0.2.8__tar.gz → 0.2.9__tar.gz

{roboflow_workflows-0.2.8/roboflow_workflows.egg-info → roboflow_workflows-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roboflow-workflows
-Version: 0.2.8
+Version: 0.2.9
 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
@@ -61,6 +61,7 @@ Requires-Dist: fastapi<0.142,>=0.134; extra == "enterprise"
 Provides-Extra: test
 Requires-Dist: pytest<10.0.0,>=9.0.3; extra == "test"
 Requires-Dist: requests-mock~=1.12.1; extra == "test"
+Requires-Dist: pytest-xdist<4.0.0,>=3.6; extra == "test"
 Dynamic: license-file
 
 # roboflow-workflows

{roboflow_workflows-0.2.8 → roboflow_workflows-0.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "roboflow-workflows"
-version = "0.2.8"
+version = "0.2.9"
 description = "Roboflow Workflows execution engine and block library"
 readme = "README.md"
 license = {file = "LICENSE"}
@@ -59,6 +59,7 @@ enterprise = [
 test = [
   "pytest>=9.0.3,<10.0.0",
   "requests-mock~=1.12.1",
+  "pytest-xdist>=3.6,<4.0.0",
 ]
 
 [build-system]

{roboflow_workflows-0.2.8 → roboflow_workflows-0.2.9}/roboflow_workflows/_compat_names.py

@@ -14,12 +14,25 @@ We map at read-time; ``class.__module__`` stays canonical so pickling and
 from __future__ import annotations
 
 import logging
+from typing import Optional
 
 _CANONICAL_ROOT = "roboflow_workflows"
 _ENTERPRISE_CANONICAL = "roboflow_workflows.enterprise_blocks"
 _CORE_LEGACY = "inference.core.workflows"
 _ENTERPRISE_LEGACY = "inference.enterprise.workflows.enterprise_blocks"
 
+# Paths of inference.roboflow_workflows_plugin (1.6.1-1.7.2), for disable patterns.
+_PLATFORM_BLOCKS_PLUGIN_PREFIXES = (
+    (
+        "roboflow_workflows.core_steps.sinks.roboflow.",
+        "inference.roboflow_workflows_plugin.sinks.",
+    ),
+    (
+        "roboflow_workflows.core_steps.integrations.roboflow.",
+        "inference.roboflow_workflows_plugin.integrations.",
+    ),
+)
+
 
 def to_legacy_module(module_name: str) -> str:
     """Return the historic ``inference.*`` dotted form of a canonical module."""
@@ -32,6 +45,15 @@ def to_legacy_module(module_name: str) -> str:
     return module_name
 
 
+def to_historic_plugin_module(module_name: str) -> Optional[str]:
+    """Return the 1.6.1-1.7.2 plugin-package path of a Roboflow-platform block
+    module, or ``None`` for any other module. For disable-pattern matching only."""
+    for canonical_prefix, plugin_prefix in _PLATFORM_BLOCKS_PLUGIN_PREFIXES:
+        if module_name.startswith(canonical_prefix):
+            return plugin_prefix + module_name[len(canonical_prefix) :]
+    return None
+
+
 def get_logger(module_name: str) -> logging.Logger:
     """``logging.getLogger`` under the historic ``inference.*`` name.
 

roboflow_workflows-0.2.9/roboflow_workflows/core_steps/integrations/roboflow/visual_search/helpers.py

@@ -0,0 +1,43 @@
+from typing import Any, Dict, List, Optional
+
+from roboflow_workflows.execution_engine.entities.base import (
+    ImageParentMetadata,
+    WorkflowImageData,
+)
+
+
+def format_visual_search_candidate(
+    candidate: Dict[str, Any],
+    extra_fields: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    filename = candidate.get("filename") or candidate.get("name")
+    formatted_candidate = {
+        "image_id": candidate.get("id"),
+        "image_url": candidate.get("url"),
+        "name": candidate.get("name") or filename,
+        "filename": filename,
+        "metadata": candidate.get("user_metadata") or {},
+        "tags": candidate.get("tags") or [],
+        "width": candidate.get("width"),
+        "height": candidate.get("height"),
+        "aspect_ratio": candidate.get("aspectRatio"),
+    }
+    for field in extra_fields or []:
+        formatted_candidate[field] = candidate.get(field)
+    return formatted_candidate
+
+
+def build_visual_search_candidate_image(
+    candidate: Dict[str, Any],
+    fallback_parent_id: str,
+) -> Optional[WorkflowImageData]:
+    image_url = candidate.get("image_url")
+    if not image_url:
+        return None
+    parent_id = (
+        candidate.get("image_id") or candidate.get("filename") or fallback_parent_id
+    )
+    return WorkflowImageData(
+        parent_metadata=ImageParentMetadata(parent_id=str(parent_id)),
+        image_reference=image_url,
+    )

roboflow_workflows-0.2.9/roboflow_workflows/core_steps/integrations/roboflow/visual_search/v1.py

@@ -0,0 +1,248 @@
+from typing import Any, Dict, List, Literal, Optional, Type, Union
+
+from pydantic import ConfigDict, Field
+from roboflow_workflows.core_steps.integrations.roboflow.visual_search.helpers import (
+    build_visual_search_candidate_image,
+    format_visual_search_candidate,
+)
+from roboflow_workflows.execution_engine.entities.base import (
+    Batch,
+    OutputDefinition,
+    WorkflowImageData,
+)
+from roboflow_workflows.execution_engine.entities.types import (
+    BOOLEAN_KIND,
+    DICTIONARY_KIND,
+    IMAGE_KIND,
+    INTEGER_KIND,
+    LIST_OF_VALUES_KIND,
+    ROBOFLOW_PROJECT_KIND,
+    STRING_KIND,
+    Selector,
+)
+from roboflow_workflows.execution_engine.entities.workload import (
+    Discovery,
+    RuntimeRestriction,
+    WorkOperation,
+)
+from roboflow_workflows.prototypes.block import (
+    AirGappedAvailability,
+    BlockResult,
+    DependentResource,
+    WorkflowBlock,
+    WorkflowBlockManifest,
+    roboflow_platform_project,
+)
+from roboflow_workflows.prototypes.platform_client import (
+    OFFLINE_PLATFORM_CLIENT,
+    RoboflowPlatformClient,
+    resolve_platform_blocks_client,
+)
+from typing_extensions import Annotated
+
+SHORT_DESCRIPTION = "Find visually similar image candidates in a Roboflow project."
+
+LONG_DESCRIPTION = """
+Search a Roboflow project for images that look similar to an input image and return
+the nearest candidate plus metadata.
+
+## How This Block Works
+
+This block uses the existing Roboflow project image search API:
+
+1. Receives an input image from the workflow
+2. Sends the image to Roboflow project search as `image_base64`
+3. Requests useful fields such as image URL, tags, and user metadata
+4. Returns the best candidate, best candidate image, metadata, tags, and the top candidates list
+
+The target project should already contain uploaded images. Roboflow indexes those
+images for visual search using the platform's existing image indexing pipeline.
+This block does not create images, update metadata, or manage the index.
+"""
+
+TopK = Annotated[int, Field(ge=1, le=50)]
+
+
+class BlockManifest(WorkflowBlockManifest):
+    model_config = ConfigDict(
+        json_schema_extra={
+            "name": "Roboflow Visual Search",
+            "version": "v1",
+            "short_description": SHORT_DESCRIPTION,
+            "long_description": LONG_DESCRIPTION,
+            "license": "Apache-2.0",
+            "block_type": "fusion",
+            "ui_manifest": {
+                "section": "advanced",
+                "icon": "far fa-search",
+                "blockPriority": 1,
+                "requires_rf_key": True,
+            },
+        }
+    )
+    type: Literal["roboflow_core/visual_search@v1"]
+    image: Selector(kind=[IMAGE_KIND]) = Field(
+        description="Image to use as the visual search query.",
+        examples=["$inputs.image", "$steps.crop.crops"],
+    )
+    workspace: Union[Selector(kind=[STRING_KIND]), str] = Field(
+        description="Roboflow workspace URL slug that owns the target project.",
+        examples=["my-workspace", "$inputs.workspace"],
+    )
+    target_project: Union[Selector(kind=[ROBOFLOW_PROJECT_KIND]), str] = Field(
+        description="Roboflow project URL slug to search.",
+        examples=["reference-images", "$inputs.target_project"],
+    )
+    top_k: Union[TopK, Selector(kind=[INTEGER_KIND])] = Field(
+        default=1,
+        description=(
+            "Number of visually similar image candidates to return. Use 1 when you "
+            "only need the nearest candidate."
+        ),
+        examples=[1, 5, "$inputs.top_k"],
+    )
+
+    @classmethod
+    def get_air_gapped_availability(cls) -> AirGappedAvailability:
+        return AirGappedAvailability(available=False, reason="requires_internet")
+
+    @classmethod
+    def get_parameters_accepting_batches(cls) -> List[str]:
+        return ["image"]
+
+    @classmethod
+    def describe_outputs(cls) -> List[OutputDefinition]:
+        return [
+            OutputDefinition(name="candidate_found", kind=[BOOLEAN_KIND]),
+            OutputDefinition(name="best_candidate", kind=[DICTIONARY_KIND]),
+            OutputDefinition(name="candidates", kind=[LIST_OF_VALUES_KIND]),
+            OutputDefinition(name="error_status", kind=[BOOLEAN_KIND]),
+            OutputDefinition(name="message", kind=[STRING_KIND]),
+            OutputDefinition(name="best_candidate_image", kind=[IMAGE_KIND]),
+            OutputDefinition(name="best_candidate_metadata", kind=[DICTIONARY_KIND]),
+            OutputDefinition(name="best_candidate_tags", kind=[LIST_OF_VALUES_KIND]),
+        ]
+
+    @classmethod
+    def get_execution_engine_compatibility(cls) -> Optional[str]:
+        return ">=1.3.0,<2.0.0"
+
+    def discover_dependent_resources(self) -> Optional[List[DependentResource]]:
+        return [roboflow_platform_project(project_url=self.target_project)]
+
+    def discover_work_operations(self) -> List[WorkOperation]:
+        return [WorkOperation.EXTERNAL_REQUEST, WorkOperation.IMAGE_ENCODING]
+
+    def get_actual_restrictions(
+        self, *, ignore_environment_restrictions: bool = False
+    ) -> Discovery[RuntimeRestriction]:
+        return Discovery[RuntimeRestriction](
+            items=[], complete=True, unknown_reasons=[]
+        )
+
+
+class RoboflowVisualSearchBlockV1(WorkflowBlock):
+    def __init__(
+        self,
+        api_key: Optional[str],
+        platform_client: RoboflowPlatformClient = OFFLINE_PLATFORM_CLIENT,
+    ):
+        self._api_key = api_key
+        self._platform_client = resolve_platform_blocks_client(platform_client)
+
+    @classmethod
+    def get_init_parameters(cls) -> List[str]:
+        return ["api_key", "platform_client"]
+
+    @classmethod
+    def get_manifest(cls) -> Type[WorkflowBlockManifest]:
+        return BlockManifest
+
+    def run(
+        self,
+        image: Union[WorkflowImageData, Batch[WorkflowImageData]],
+        workspace: str,
+        target_project: str,
+        top_k: int = 1,
+    ) -> BlockResult:
+        if self._api_key is None:
+            raise ValueError(
+                "Roboflow Visual Search block cannot run without a Roboflow API key. "
+                "Visit https://docs.roboflow.com/api-reference/authentication"
+                "#retrieve-an-api-key to learn how to retrieve one."
+            )
+
+        if isinstance(image, Batch):
+            return [
+                self._search_single_image(
+                    image=single_image,
+                    workspace=workspace,
+                    target_project=target_project,
+                    top_k=top_k,
+                )
+                for single_image in image
+            ]
+
+        return self._search_single_image(
+            image=image,
+            workspace=workspace,
+            target_project=target_project,
+            top_k=top_k,
+        )
+
+    def _search_single_image(
+        self,
+        image: WorkflowImageData,
+        workspace: str,
+        target_project: str,
+        top_k: int,
+    ) -> Dict[str, Any]:
+        try:
+            response = self._platform_client.search_project_images_at_roboflow(
+                api_key=self._api_key,
+                workspace=workspace,
+                project=target_project,
+                image_base64=image.base64_image,
+                limit=top_k,
+            )
+            candidates = [
+                format_visual_search_candidate(candidate=candidate)
+                for candidate in response.get("results", [])
+            ]
+            if not candidates:
+                return {
+                    "candidate_found": False,
+                    "best_candidate": {},
+                    "candidates": [],
+                    "error_status": False,
+                    "message": "No visually similar images found.",
+                    "best_candidate_image": None,
+                    "best_candidate_metadata": {},
+                    "best_candidate_tags": [],
+                }
+
+            best_candidate = candidates[0]
+            return {
+                "candidate_found": True,
+                "best_candidate": best_candidate,
+                "candidates": candidates,
+                "error_status": False,
+                "message": "Visual search completed.",
+                "best_candidate_image": build_visual_search_candidate_image(
+                    candidate=best_candidate,
+                    fallback_parent_id="visual_search_candidate",
+                ),
+                "best_candidate_metadata": best_candidate["metadata"],
+                "best_candidate_tags": best_candidate["tags"],
+            }
+        except Exception as error:
+            return {
+                "candidate_found": False,
+                "best_candidate": {},
+                "candidates": [],
+                "error_status": True,
+                "message": f"Visual search failed: {error}",
+                "best_candidate_image": None,
+                "best_candidate_metadata": {},
+                "best_candidate_tags": [],
+            }

roboflow_workflows-0.2.9/roboflow_workflows/core_steps/integrations/roboflow/visual_search_classifier/__init__.py

@@ -0,0 +1 @@
+

roboflow_workflows-0.2.9/roboflow_workflows/core_steps/integrations/roboflow/visual_search_classifier/classification_annotations.py

@@ -0,0 +1,177 @@
+from typing import Any, Dict, List, Optional
+
+
+def parse_visual_search_classification(
+    candidate: Dict[str, Any],
+) -> Optional[Dict[str, Any]]:
+    classification = parse_classification_annotation(
+        classification=candidate.get("classification")
+    )
+    if classification is not None:
+        return classification
+    classification = parse_labels(labels=candidate.get("labels"))
+    if classification is not None:
+        return classification
+    return parse_annotations(annotations=candidate.get("annotations"))
+
+
+def parse_classification_annotation(
+    classification: Any,
+) -> Optional[Dict[str, Any]]:
+    if not isinstance(classification, dict):
+        return None
+    if _has_single_label_annotation(classification=classification):
+        return {
+            "type": "single_label",
+            "classes": [_build_class_entry(classification=classification)],
+        }
+    return _parse_multi_label_annotation(classification=classification)
+
+
+def parse_labels(labels: Any) -> Optional[Dict[str, Any]]:
+    if not isinstance(labels, list):
+        return None
+    class_entries = []
+    for label in labels:
+        if isinstance(label, str):
+            class_entries.append({"class": label})
+        elif isinstance(label, dict):
+            class_entries.append(
+                {
+                    "class": label.get("class"),
+                    "class_id": label.get("class_id"),
+                }
+            )
+    return _build_annotation_from_class_entries(class_entries=class_entries)
+
+
+def parse_annotations(annotations: Any) -> Optional[Dict[str, Any]]:
+    if not isinstance(annotations, list):
+        return None
+    class_names = []
+    for annotation in annotations:
+        if not isinstance(annotation, dict):
+            continue
+        classes = annotation.get("classes")
+        if isinstance(classes, list):
+            class_names.extend(classes)
+    return _build_annotation_from_class_entries(
+        class_entries=[{"class": class_name} for class_name in class_names]
+    )
+
+
+def _has_single_label_annotation(classification: Dict[str, Any]) -> bool:
+    return (
+        isinstance(classification.get("class"), str)
+        and len(classification["class"]) > 0
+    )
+
+
+def _build_annotation_from_class_entries(
+    class_entries: List[Dict[str, Any]],
+) -> Optional[Dict[str, Any]]:
+    classes = []
+    seen_class_names = set()
+    used_class_ids = set()
+    for fallback_class_id, class_entry in enumerate(class_entries):
+        class_name = class_entry.get("class")
+        if (
+            not isinstance(class_name, str)
+            or not class_name
+            or class_name in seen_class_names
+        ):
+            continue
+        class_id = _normalise_class_id(class_entry.get("class_id"))
+        if class_id < 0 or class_id in used_class_ids:
+            class_id = _next_available_class_id(
+                preferred_class_id=fallback_class_id,
+                used_class_ids=used_class_ids,
+            )
+        classes.append(
+            {
+                "class": class_name,
+                "class_id": class_id,
+            }
+        )
+        seen_class_names.add(class_name)
+        used_class_ids.add(class_id)
+    if not classes:
+        return None
+    if len(classes) == 1:
+        return {
+            "type": "single_label",
+            "classes": classes,
+        }
+    return {
+        "type": "multi_label",
+        "classes": classes,
+    }
+
+
+def _parse_multi_label_annotation(
+    classification: Dict[str, Any],
+) -> Optional[Dict[str, Any]]:
+    predicted_classes = classification.get("predicted_classes")
+    if not isinstance(predicted_classes, list) or not predicted_classes:
+        return None
+    predictions = classification.get("predictions")
+    if not isinstance(predictions, dict):
+        predictions = {}
+    classes = []
+    seen_class_names = set()
+    used_class_ids = set()
+    for fallback_class_id, class_name in enumerate(predicted_classes):
+        if (
+            not isinstance(class_name, str)
+            or not class_name
+            or class_name in seen_class_names
+        ):
+            continue
+        prediction = predictions.get(class_name) or {}
+        if not isinstance(prediction, dict):
+            prediction = {}
+        class_id = _normalise_class_id(prediction.get("class_id"))
+        if class_id < 0 or class_id in used_class_ids:
+            class_id = _next_available_class_id(
+                preferred_class_id=fallback_class_id,
+                used_class_ids=used_class_ids,
+            )
+        classes.append(
+            {
+                "class": class_name,
+                "class_id": class_id,
+            }
+        )
+        seen_class_names.add(class_name)
+        used_class_ids.add(class_id)
+    if not classes:
+        return None
+    return {
+        "type": "multi_label",
+        "classes": classes,
+    }
+
+
+def _build_class_entry(classification: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "class": classification["class"],
+        "class_id": _normalise_class_id(classification.get("class_id")),
+    }
+
+
+def _normalise_class_id(class_id: Any) -> int:
+    if class_id is None:
+        return -1
+    try:
+        return int(class_id)
+    except (TypeError, ValueError):
+        return -1
+
+
+def _next_available_class_id(
+    preferred_class_id: int,
+    used_class_ids: set,
+) -> int:
+    while preferred_class_id in used_class_ids:
+        preferred_class_id += 1
+    return preferred_class_id