Add coordinate format normalization for Mask geometry

Author: paulnoirel

libs/labelbox/src/labelbox/data/annotation_types/geometry/mask.py

@@ -4,11 +4,29 @@
 import numpy as np
 from pydantic import field_validator
 from shapely.geometry import MultiPolygon, Polygon
+from shapely import geometry as geom
 
 from ..data import MaskData
 from .geometry import Geometry
 
 
+class NormalizedShapelyWrapper:
+    """Wrapper for shapely objects that normalizes coordinate format in __geo_interface__"""
+
+    def __init__(self, shapely_obj, normalizer_func):
+        self._shapely_obj = shapely_obj
+        self._normalizer_func = normalizer_func
+
+    def __getattr__(self, name):
+        """Delegate all attributes to the wrapped shapely object"""
+        return getattr(self._shapely_obj, name)
+
+    @property
+    def __geo_interface__(self):
+        """Return normalized coordinates"""
+        return self._normalizer_func(self._shapely_obj.__geo_interface__)
+
+
 class Mask(Geometry):
     """Mask used to represent a single class in a larger segmentation mask
 
@@ -35,8 +53,71 @@ class Mask(Geometry):
     mask: MaskData
     color: Union[Tuple[int, int, int], int]
 
+    def _normalize_coordinates(self, geometry_dict: Dict) -> Dict:
+        """
+        Normalize coordinate format to match expected GeoJSON structure.
+
+        Ensures that coordinate pairs are tuples (x, y) and coordinate rings are tuples,
+        but preserves the outer list structure to match GeoJSON specification.
+
+        Args:
+            geometry_dict: GeoJSON-style geometry dictionary
+
+        Returns:
+            Geometry dictionary with coordinates normalized to expected format
+        """
+
+        def normalize_coord_sequence(coords, level=0):
+            """Recursively normalize coordinate sequences"""
+            if isinstance(coords, (list, tuple)):
+                if len(coords) == 2 and isinstance(coords[0], (int, float)):
+                    # This is a coordinate pair [x, y] or (x, y) - convert to tuple
+                    return (float(coords[0]), float(coords[1]))
+                else:
+                    # This is a sequence of coordinates or nested sequences
+                    # For MultiPolygon: preserve outermost list, convert inner structures to tuples
+                    if level == 0:
+                        # Keep outermost as list for GeoJSON compatibility
+                        return [
+                            normalize_coord_sequence(item, level + 1)
+                            for item in coords
+                        ]
+                    else:
+                        # Convert inner coordinate rings to tuples
+                        return tuple(
+                            normalize_coord_sequence(item, level + 1)
+                            for item in coords
+                        )
+            return coords
+
+        if "coordinates" in geometry_dict:
+            geometry_dict = geometry_dict.copy()
+            geometry_dict["coordinates"] = normalize_coord_sequence(
+                geometry_dict["coordinates"]
+            )
+
+        return geometry_dict
+
+    @property
+    def shapely(
+        self,
+    ) -> Union[
+        geom.Point,
+        geom.LineString,
+        geom.Polygon,
+        geom.MultiPoint,
+        geom.MultiLineString,
+        geom.MultiPolygon,
+    ]:
+        """Override shapely property to ensure normalized coordinates via wrapper"""
+        original_shapely = geom.shape(self.geometry)
+        return NormalizedShapelyWrapper(
+            original_shapely, self._normalize_coordinates
+        )
+
     @property
     def geometry(self) -> Dict[str, Tuple[int, int, int]]:
+        # Extract mask contours and build geometry
         mask = self.draw(color=1)
         contours, hierarchy = cv2.findContours(
             image=mask, mode=cv2.RETR_TREE, method=cv2.CHAIN_APPROX_NONE
@@ -62,7 +143,10 @@ def geometry(self) -> Dict[str, Tuple[int, int, int]]:
         if not holes.is_valid:
             holes = holes.buffer(0)
 
-        return external_polygons.difference(holes).__geo_interface__
+        # Get geometry from shapely and normalize coordinates for consistency
+        # This ensures customers always get list format regardless of shapely version
+        geometry_dict = external_polygons.difference(holes).__geo_interface__
+        return self._normalize_coordinates(geometry_dict)
 
     def draw(
         self,