fix: UTC-539: Handle Labels split format in prediction validations (#755)

Co-authored-by: robot-ci-heartex <robot-ci-heartex@users.noreply.github.com>

Author: mcanu

src/label_studio_sdk/label_interface/control_tags.py

@@ -298,7 +298,7 @@ def _validate_value_labels(self, value):
             return self._validate_labels(value.get(self._label_attr_name))
         return False
 
-    def validate_value(self, value: dict) -> bool:
+    def validate_value(self, value: dict, context: Optional[dict] = None) -> bool:
         """
         Given "value" from [annotation result format](https://labelstud.io/guide/task_format),
         validate if it's a valid value for this control tag.
@@ -311,6 +311,11 @@ def validate_value(self, value: dict) -> bool:
             ```python
             RectangleTag(name="rect", to_name=["img"], tag="rectangle", attr={}).validate_value({"x": 10, "y": 10, "width": 10, "height": 10, "rotation": 10})
             ```
+        context : dict, optional
+            Additional context about sibling regions.  May contain
+            ``result`` (the full result list) and ``region`` (the current
+            region dict).  Subclasses can inspect this to adjust
+            validation behaviour.
 
         Returns:
         --------
@@ -567,6 +572,79 @@ class LabelsTag(ControlTag):
     _label_attr_name: str = "labels"
     _value_class: Type[LabelsValue] = LabelsValue
 
+    def _get_split_partner_value_class(self, context: dict) -> Optional[Type[BaseModel]]:
+        """Return the geometry value class if this region is a split-format labels companion.
+
+        In split format a geometry result (rectangle, polygon, …) and a
+        separate labels result share the same ``id``.  When detected, this
+        method returns the geometry partner's pydantic value class so the
+        labels value can be validated against the expected geometry fields.
+
+        Returns ``None`` when the region is not part of a split-format pair.
+        """
+        # Lazy import avoided: the mapping references value classes defined
+        # later in this file, but they are available at call time.
+        geometry_type_to_value_class: Dict[str, Type[BaseModel]] = {
+            'rectangle': RectangleValue,
+            'polygon': PolygonValue,
+            'ellipse': EllipseValue,
+            'keypoint': KeyPointValue,
+            'brush': BrushValue,
+        }
+
+        region = context.get('region', {})
+        result = context.get('result', [])
+
+        # Only check for split-format pairs if the current region is a labels region
+        if (region.get('type') or '').lower() != 'labels':
+            return None
+
+        # Check if the current region has an id
+        region_id = region.get('id')
+        if region_id is None:
+            return None
+
+        # Iterate through all regions to find a matching geometry partner
+        for r in result:
+            if not isinstance(r, dict):
+                continue
+            r_type = (r.get('type') or '').lower()
+            # Checks if sibling region has the same id and is a geometry type
+            if r.get('id') == region_id and r_type in geometry_type_to_value_class:
+                # Return the geometry value class to validate the attributes of the current region
+                return geometry_type_to_value_class[r_type]
+
+        return None
+
+    def validate_value(self, value: dict, context: Optional[dict] = None) -> bool:
+        """Validate value, selecting the pydantic model based on format.
+
+        When the ``context`` indicates this region is the labels companion
+        of a split-format pair the partner's geometry value class (e.g.
+        :class:`RectangleValue`, :class:`PolygonValue`) is used to
+        validate the geometry fields.  The ``labels`` subset is validated
+        separately via :meth:`_validate_value_labels`.
+
+        Otherwise the strict :class:`LabelsValue` model is used
+        (``start`` and ``end`` required alongside ``labels``).
+        """
+        if isinstance(value, dict) and self.name in value and isinstance(value[self.name], dict):
+            value = value[self.name]
+
+        if not self._validate_value_labels(value):
+            return False
+
+        geometry_value_class = (
+            self._get_split_partner_value_class(context) if context else None
+        )
+        # Use the geometry partner's value class for split format,
+        # otherwise the default text-span LabelsValue.
+        value_class = geometry_value_class or self._value_class
+        try:
+            value_class(**value)
+            return True
+        except Exception:
+            return False
 
     def to_json_schema(self):
         """
@@ -961,7 +1039,7 @@ class RankerTag(ControlTag):
     tag: str = "Ranker"
     _value_class: Type[RankerValue] = RankerValue
 
-    def validate_value(self, value: dict) -> bool:
+    def validate_value(self, value: dict, **kwargs) -> bool:
         """
         Accept only:
           - {"ranker": {"<control_tag_name>": [str, ...]}}
@@ -1069,7 +1147,7 @@ def to_json_schema(self):
 class RelationsTag(ControlTag):
     """ """
     tag: str = "Relations"
-    def validate_value(self, ) -> bool:
+    def validate_value(self, **kwargs) -> bool:
         """ """
         raise NotImplemented("""Should not be called directly, instead
         use validate_relation() method found in LabelInterface class""")

src/label_studio_sdk/label_interface/interface.py

@@ -832,7 +832,10 @@ def _validate_object_logic(self, obj) -> List[str]:
                     continue
 
                 if region.get('type') != "relation":
-                    region_errors = self.validate_region(region, return_errors=True, region_index=i)
+                    region_errors = self.validate_region(
+                        region, return_errors=True, region_index=i,
+                        context={'result': result, 'region': region},
+                    )
                     errors.extend(region_errors)
                     if not region_errors:  # Only add to regions if no errors
                         regions.append(region)
@@ -886,12 +889,14 @@ def validate_prediction(self, prediction, return_errors=False):
         """
         return self._validate_object(prediction, return_errors)
 
-    def _validate_region_logic(self, region, region_index=0) -> Tuple[bool, List[str]]:
+    def _validate_region_logic(self, region, region_index=0, context=None) -> Tuple[bool, List[str]]:
         """Helper method to perform region validation logic.
 
         Args:
             region (dict): The region to be validated.
             region_index (int): Index of the region for error reporting.
+            context (dict, optional): Additional context forwarded to
+                ``control.validate_value()``.
 
         Returns:
             tuple: (is_valid, errors) where is_valid is bool and errors is list of strings.
@@ -934,7 +939,7 @@ def _validate_region_logic(self, region, region_index=0) -> Tuple[bool, List[str
 
         # Validate the value using control's validate_value method
         try:
-            if not control.validate_value(region["value"]):
+            if not control.validate_value(region["value"], context=context):
                 # Prefer a clearer message for rectangle geometry bounds
                 tag_lower = getattr(control, 'tag', '').lower()
                 if tag_lower in ('rectangle', 'rectanglelabels'):
@@ -985,7 +990,7 @@ def _get_valid_values_for_control(self, control):
         except Exception:
             return "unknown validation rules"
 
-    def validate_region(self, region, return_errors=False, region_index=0):
+    def validate_region(self, region, return_errors=False, region_index=0, context=None):
         """Validates a region from the annotation against the current
         configuration.
 
@@ -999,12 +1004,16 @@ def validate_region(self, region, return_errors=False, region_index=0):
             region (dict): The region to be validated.
             return_errors (bool): If True, returns a list of error messages instead of boolean
             region_index (int): Index of the region for error reporting (used when return_errors=True)
+            context (dict, optional): Additional context passed through to
+                ``control.validate_value()``.  May contain ``result`` (the
+                full result list) and ``region`` (the current region dict)
+                so that control tags can inspect sibling regions.
 
         Returns:
             Union[bool, List[str]]: If return_errors=False, returns True/False.
                                    If return_errors=True, returns list of error messages.
         """
-        is_valid, errors = self._validate_region_logic(region, region_index)
+        is_valid, errors = self._validate_region_logic(region, region_index, context=context)
 
         if return_errors:
             return errors